Thread: [Sblim-commit] cmpi-dns/provider/Linux_DnsAllowTransferACLForZone Linux_DnsAllowTransferACLForZoneEx

SourceForge Headquarters 1320 Columbia Street Suite 310 San Diego, CA 92101 +1 (858) 422-6466

Update of /cvsroot/sblim/cmpi-dns/provider/Linux_DnsAllowTransferACLForZone
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv20455/provider/Linux_DnsAllowTransferACLForZone

Added Files:
	Linux_DnsAllowTransferACLForZoneExternal.h 
	Linux_DnsAllowTransferACLForZoneRepositoryExternal.cpp 
	Linux_DnsAllowTransferACLForZoneDefaultImplementation.cpp 
	Linux_DnsAllowTransferACLForZoneDefaultImplementation.h 
	Linux_DnsAllowTransferACLForZoneInstance.h 
	Linux_DnsAllowTransferACLForZoneFactory.h 
	Linux_DnsAllowTransferACLForZoneFactory.cpp 
	Linux_DnsAllowTransferACLForZoneRepositoryExternal.h 
	Linux_DnsAllowTransferACLForZoneResourceAccess.h 
	Linux_DnsAllowTransferACLForZoneRepositoryInstance.h 
	setting.provider makefile 
	Linux_DnsAllowTransferACLForZoneResourceAccess.cpp 
	CmpiLinux_DnsAllowTransferACLForZoneProvider.h 
	Linux_DnsAllowTransferACLForZoneInterface.h 
	Linux_DnsAllowTransferACLForZoneManualInstance.cpp 
	Linux_DnsAllowTransferACLForZoneFakeFactory.cpp 
	Linux_DnsAllowTransferACLForZoneExternal.cpp 
	Linux_DnsAllowTransferACLForZoneInstanceName.h 
	Linux_DnsAllowTransferACLForZoneInstance.cpp 
	Linux_DnsAllowTransferACLForZoneInstanceName.cpp 
	CmpiLinux_DnsAllowTransferACLForZoneProvider.cpp 
	Linux_DnsAllowTransferACLForZoneManualInstance.h 
	Linux_DnsAllowTransferACLForZoneRepositoryInstance.cpp 
Log Message:
WBEM-SMT DNS provider component.

First initial upload.

This module includes: 
- CIM model for DNS
- CMPI provider for DNS
- Resource Access layer for DNS

--- NEW FILE: setting.provider ---
#Provider configuration

#CPPFLAGS.provider
#LDFLAGS.provider

--- NEW FILE: Linux_DnsAllowTransferACLForZoneInstanceName.cpp ---
 /**
 * Linux_DnsAllowTransferACLForZoneInstanceName.cpp
 *
 * (C) Copyright IBM Corp. 2005
 *
 * THIS FILE IS PROVIDED UNDER THE TERMS OF THE COMMON PUBLIC LICENSE
 * ("AGREEMENT"). ANY USE, REPRODUCTION OR DISTRIBUTION OF THIS FILE
 * CONSTITUTES RECIPIENTS ACCEPTANCE OF THE AGREEMENT.
 *
 * You can obtain a current copy of the Common Public License from
 * http://www.opensource.org/licenses/cpl1.0.php
 *
 * author:     Murillo Bernardes <ber...@br...>
 *
 * Contributors:
 *
 */
#include "Linux_DnsAllowTransferACLForZoneInstanceName.h"
#include "CmpiData.h"
#include "CmpiString.h"
#include "CmpiArray.h"
#include <string>

namespace genProvider {

  //*********************************************************
  //Linux_DnsAllowTransferACLForZoneInstanceName
  //*********************************************************

  //empty constructor
  Linux_DnsAllowTransferACLForZoneInstanceName::
   Linux_DnsAllowTransferACLForZoneInstanceName(){
   	init();  	
  };

  //copy constructor	
  Linux_DnsAllowTransferACLForZoneInstanceName::
   Linux_DnsAllowTransferACLForZoneInstanceName
   (const Linux_DnsAllowTransferACLForZoneInstanceName& original){
   	init(original);  	
  };

  //contructor using CmpiObjectPath
  Linux_DnsAllowTransferACLForZoneInstanceName::
   Linux_DnsAllowTransferACLForZoneInstanceName (const CmpiObjectPath& path){

    init();

    m_CIMClassNameP=path.getClassName().charPtr();

    CmpiString namespaceOP;
    namespaceOP=path.getNameSpace();
    setNamespace(namespaceOP.charPtr(),1);

    CmpiObjectPath Element = path.getKey("Element");
    setElement(Linux_DnsZoneInstanceName(Element));

    CmpiObjectPath Setting = path.getKey("Setting");
    setSetting(Linux_DnsAddressMatchListInstanceName(Setting));

  }

  //destructor
  Linux_DnsAllowTransferACLForZoneInstanceName::
   ~Linux_DnsAllowTransferACLForZoneInstanceName(){
   	reset();  	  
  };

  //copy operator
  Linux_DnsAllowTransferACLForZoneInstanceName&
   Linux_DnsAllowTransferACLForZoneInstanceName::operator=
   (const Linux_DnsAllowTransferACLForZoneInstanceName& original){    
    init(original);
   	return *this;    
  }

  //returns the related CmpiObjectPath
  CmpiObjectPath Linux_DnsAllowTransferACLForZoneInstanceName::
   getObjectPath() const{

   	CmpiObjectPath objectPath(m_namespace, m_CIMClassNameP);

  	objectPath.setKey("Element",CmpiData(m_Element.getObjectPath()));

  	objectPath.setKey("Setting",CmpiData(m_Setting.getObjectPath()));

  	return objectPath;

  }

  //adds the related CmpiObjectPath to an existing cmpiInstance
  void Linux_DnsAllowTransferACLForZoneInstanceName::fillKeys(CmpiInstance& cmpiInstance) const{

  	if(isSet.Element){
  	  cmpiInstance.setProperty("Element",CmpiData(m_Element.getObjectPath()));
  	}

  	if(isSet.Setting){
  	  cmpiInstance.setProperty("Setting",CmpiData(m_Setting.getObjectPath()));
  	}
  }

  //NameSpace related methods
  unsigned int Linux_DnsAllowTransferACLForZoneInstanceName::
   isNameSpaceSet() const{
  	return isSet.m_namespace;
  }

  const char * Linux_DnsAllowTransferACLForZoneInstanceName::
   getNamespace() const {
    if(!isSet.m_namespace)
   	  throw CmpiErrorFormater::getErrorException(
   	   CmpiErrorFormater::NOT_SET,
   	   "NameSpace not set in Linux_DnsAllowTransferACLForZone instanceName");
  	return m_namespace;
  }

  void Linux_DnsAllowTransferACLForZoneInstanceName::
   setNamespace(const char* val, int makeCopy){
    if (isSet.m_namespace) {
      delete m_namespace;
    }
    if (makeCopy&&val) {
      char* tmpval = new char[strlen(val)+1];
      strcpy(tmpval,val);
      m_namespace = tmpval;
    } else {
      m_namespace = val;
    }
    isSet.m_namespace=1;
  }

  //Element related methods
  unsigned int Linux_DnsAllowTransferACLForZoneInstanceName::isElementSet() const{
    return isSet.Element;
  }
  void Linux_DnsAllowTransferACLForZoneInstanceName::
   setElement(const Linux_DnsZoneInstanceName& val){
    m_Element = val;
    isSet.Element=1;
  }       
  const Linux_DnsZoneInstanceName& Linux_DnsAllowTransferACLForZoneInstanceName::
   getElement() const{

    if(!isSet.Element)
   	  throw CmpiErrorFormater::getErrorException(
   	   CmpiErrorFormater::NOT_SET,
   	   "Element not set");

    return m_Element;
  }

  //Setting related methods
  unsigned int Linux_DnsAllowTransferACLForZoneInstanceName::isSettingSet() const{
    return isSet.Setting;
  }
  void Linux_DnsAllowTransferACLForZoneInstanceName::
   setSetting(const Linux_DnsAddressMatchListInstanceName& val){
    m_Setting = val;
    isSet.Setting=1;
  }       
  const Linux_DnsAddressMatchListInstanceName& Linux_DnsAllowTransferACLForZoneInstanceName::
   getSetting() const{

    if(!isSet.Setting)
   	  throw CmpiErrorFormater::getErrorException(
   	   CmpiErrorFormater::NOT_SET,
   	   "Setting not set");

    return m_Setting;
  }

  //set isSet variables to FALSE
  void Linux_DnsAllowTransferACLForZoneInstanceName::init(){

  	m_CIMClassNameP="Linux_DnsAllowTransferACLForZone";
  	isSet.m_namespace=0;    	
    isSet.Element=0;   	
    isSet.Setting=0;
  }

  //copies another instance properties in this
  void Linux_DnsAllowTransferACLForZoneInstanceName::init
   (const Linux_DnsAllowTransferACLForZoneInstanceName& original){
   	init();

    m_CIMClassNameP=original.m_CIMClassNameP;
    if(original.isNameSpaceSet()){
      setNamespace(original.getNamespace(),1);
    }   	
    if(original.isElementSet()){
      const Linux_DnsZoneInstanceName& ElementOriginal=original.getElement();
      setElement(ElementOriginal);
    }   	
    if(original.isSettingSet()){
      const Linux_DnsAddressMatchListInstanceName& SettingOriginal=original.getSetting();
      setSetting(SettingOriginal);
    }    
  }

  //reset the instanceName data
  void Linux_DnsAllowTransferACLForZoneInstanceName::reset(){   	
  	if (isSet.m_namespace)
  	  delete(m_namespace);  	  
  };

  //*********************************************************
  //Linux_DnsAllowTransferACLForZoneInstanceNameEnumerationElement	
  //*********************************************************

  Linux_DnsAllowTransferACLForZoneInstanceNameEnumerationElement::
   Linux_DnsAllowTransferACLForZoneInstanceNameEnumerationElement(){

  	m_elementP=0;
  	m_nextP=0;

  };

  Linux_DnsAllowTransferACLForZoneInstanceNameEnumerationElement::
   ~Linux_DnsAllowTransferACLForZoneInstanceNameEnumerationElement(){

  	if (m_elementP!=0)
  	  delete(m_elementP);
  	if (m_nextP!=0)
  	  delete(m_nextP);

  };

  //*********************************************************
  //Linux_DnsAllowTransferACLForZoneInstanceNameEnumeration
  //*********************************************************

  Linux_DnsAllowTransferACLForZoneInstanceNameEnumeration::
   Linux_DnsAllowTransferACLForZoneInstanceNameEnumeration(){

  	 firstElementP=0;
     currentElementP=0;
     endElementP=0;
  };

  Linux_DnsAllowTransferACLForZoneInstanceNameEnumeration::
   Linux_DnsAllowTransferACLForZoneInstanceNameEnumeration(const CmpiArray& arr){

  	firstElementP=0;
    currentElementP=0;
    endElementP=0;

    int size = arr.size();
    for (int i=0; i < size; i++) {
     addElement(Linux_DnsAllowTransferACLForZoneInstanceName(arr[i]));
    }
  }

  Linux_DnsAllowTransferACLForZoneInstanceNameEnumeration::
   Linux_DnsAllowTransferACLForZoneInstanceNameEnumeration(
   const Linux_DnsAllowTransferACLForZoneInstanceNameEnumeration& original){

     firstElementP=0;
     currentElementP=0;
     endElementP=0;

     int size=original.getSize();
     for(int i=0;i<size;i++)
       addElement(original.getElement(i));           
  };

  Linux_DnsAllowTransferACLForZoneInstanceNameEnumeration::
   ~Linux_DnsAllowTransferACLForZoneInstanceNameEnumeration(){

  	if (firstElementP!=0)
  	  delete(firstElementP);

  };

  void Linux_DnsAllowTransferACLForZoneInstanceNameEnumeration::reset(){

  	currentElementP=firstElementP;
  };

  bool Linux_DnsAllowTransferACLForZoneInstanceNameEnumeration::hasNext() const{

  	return (currentElementP!=0);

  };

  int Linux_DnsAllowTransferACLForZoneInstanceNameEnumeration::getSize() const{

    int size=0;
    Linux_DnsAllowTransferACLForZoneInstanceNameEnumerationElement* followingP=firstElementP;

  	while(followingP!=0){
        followingP=followingP->m_nextP;
        size++;
    }

    return size;
  };

  const Linux_DnsAllowTransferACLForZoneInstanceName&  
   Linux_DnsAllowTransferACLForZoneInstanceNameEnumeration::getElement(int pos) const{

    Linux_DnsAllowTransferACLForZoneInstanceNameEnumerationElement* followingP=firstElementP;

    int i=0;
    while((followingP!=0)&&(i<pos)){
        followingP=followingP->m_nextP;
        i++;
    }

    return *(followingP->m_elementP);
  };

  const Linux_DnsAllowTransferACLForZoneInstanceName&
   Linux_DnsAllowTransferACLForZoneInstanceNameEnumeration::getNext() {

  	 Linux_DnsAllowTransferACLForZoneInstanceNameEnumerationElement* currentP=
  	  currentElementP;
  	 currentElementP=currentElementP->m_nextP;

  	 return *(currentP->m_elementP);
  };

  void Linux_DnsAllowTransferACLForZoneInstanceNameEnumeration::addElement
   (const Linux_DnsAllowTransferACLForZoneInstanceName& elementP){

  	if(firstElementP==0){
  	  firstElementP=new Linux_DnsAllowTransferACLForZoneInstanceNameEnumerationElement();
  	  firstElementP->m_elementP=new Linux_DnsAllowTransferACLForZoneInstanceName(elementP);
  	  endElementP=firstElementP;
  	  currentElementP=firstElementP;
  	}else{
  	  endElementP->m_nextP=new Linux_DnsAllowTransferACLForZoneInstanceNameEnumerationElement();
  	  endElementP=endElementP->m_nextP;
  	  endElementP->m_elementP=new Linux_DnsAllowTransferACLForZoneInstanceName(elementP);
  	}
  };

  Linux_DnsAllowTransferACLForZoneInstanceNameEnumeration::operator CmpiArray() const{
  	int size=getSize();
   	CmpiArray arr=CmpiArray(size,CMPI_instance);
   	for(int i=0;i<size;i++){
   	  arr[i]=getElement(i).getObjectPath();
   	}
   	return arr;
  };  
}

--- NEW FILE: Linux_DnsAllowTransferACLForZoneResourceAccess.h ---
 /**
 * Linux_DnsAllowTransferACLForZoneResourceAccess.h
 *
 * (C) Copyright IBM Corp. 2005
 *
 * THIS FILE IS PROVIDED UNDER THE TERMS OF THE COMMON PUBLIC LICENSE
 * ("AGREEMENT"). ANY USE, REPRODUCTION OR DISTRIBUTION OF THIS FILE
 * CONSTITUTES RECIPIENTS ACCEPTANCE OF THE AGREEMENT.
 *
 * You can obtain a current copy of the Common Public License from
 * http://www.opensource.org/licenses/cpl1.0.php
 *
 * author:     Murillo Bernardes <ber...@br...>
 *
 * Contributors:
 *
 */
#ifndef Linux_DnsAllowTransferACLForZoneResourceAccess_h
#define Linux_DnsAllowTransferACLForZoneResourceAccess_h

#include "Linux_DnsAllowTransferACLForZoneInstanceName.h"
#include "Linux_DnsAllowTransferACLForZoneManualInstance.h"
#include "CmpiObjectPath.h"
#include "CmpiInstance.h"
#include "CmpiDateTime.h"
#include "CmpiBroker.h"
#include "Linux_DnsZoneInstance.h"
#include "Linux_DnsAddressMatchListInstance.h"
#include "Linux_DnsZoneExternal.h"
#include "Linux_DnsAddressMatchListExternal.h"
#include "Linux_DnsAllowTransferACLForZoneDefaultImplementation.h"

#include <string>
#include <list>

using namespace std;

#include "dnssupport.h"
#include "defaultvalues.h"
#include "DnsArray.h"
#include "DnsValueMap.h"

namespace genProvider {

  class Linux_DnsAllowTransferACLForZoneResourceAccess:
   public Linux_DnsAllowTransferACLForZoneDefaultImplementation {

    public:
    /*Linux_DnsAllowTransferACLForZoneResourceAccess();*/    
    virtual ~Linux_DnsAllowTransferACLForZoneResourceAccess() ;

    /* intrinsic methods */
    virtual void enumInstanceNames(
     const CmpiContext& ctx,
     const CmpiBroker &mbp,
     const char *nsp,
     Linux_DnsAllowTransferACLForZoneInstanceNameEnumeration& instnames);

    virtual void enumInstances(
     const CmpiContext& ctx,
     const CmpiBroker &mbp,
     const char *nsp,
     const char* *properties,
  	 Linux_DnsAllowTransferACLForZoneManualInstanceEnumeration& instances);

    virtual Linux_DnsAllowTransferACLForZoneManualInstance getInstance(
     const CmpiContext& ctx,
     const CmpiBroker &mbp,
     const char* *properties,
     const Linux_DnsAllowTransferACLForZoneInstanceName&);

    /*virtual void setInstance(
     const CmpiContext& ctx,
     const CmpiBroker &mbp,
     const char* *properties,
     const Linux_DnsAllowTransferACLForZoneManualInstance&);*/

    virtual void createInstance(
     const CmpiContext& ctx,
     const CmpiBroker &mbp,
     const Linux_DnsAllowTransferACLForZoneManualInstance&);

    virtual void deleteInstance(
     const CmpiContext& ctx,
     const CmpiBroker &mbp,
     const Linux_DnsAllowTransferACLForZoneInstanceName&);

    /* Association Interface */

    virtual void referencesElement( 
     const CmpiContext& ctx,  
     const CmpiBroker &mbp,
     const char *nsp,
     const char** properties,
     const Linux_DnsAddressMatchListInstanceName& sourceInst,
     Linux_DnsAllowTransferACLForZoneManualInstanceEnumeration& instances);

    virtual void referencesSetting( 
     const CmpiContext& ctx,  
     const CmpiBroker &mbp,
     const char *nsp,
     const char** properties,
     const Linux_DnsZoneInstanceName& sourceInst,
     Linux_DnsAllowTransferACLForZoneManualInstanceEnumeration& instances);

    virtual void associatorsElement( 
     const CmpiContext& ctx,  
     const CmpiBroker &mbp,
     const char *nsp,
     const char** properties,
     const Linux_DnsAddressMatchListInstanceName& sourceInst,
     Linux_DnsZoneInstanceEnumeration& instances);

    virtual void associatorsSetting( 
     const CmpiContext& ctx,  
     const CmpiBroker &mbp,
     const char *nsp,
     const char** properties,
     const Linux_DnsZoneInstanceName& sourceInst,
     Linux_DnsAddressMatchListInstanceEnumeration& instances);

    /* extrinsic methods */

  };
}
#endif

--- NEW FILE: Linux_DnsAllowTransferACLForZoneRepositoryExternal.h ---
 /**
 * Linux_DnsAllowTransferACLForZoneRepositoryExternal.h
 *
 * (C) Copyright IBM Corp. 2005
 *
 * THIS FILE IS PROVIDED UNDER THE TERMS OF THE COMMON PUBLIC LICENSE
 * ("AGREEMENT"). ANY USE, REPRODUCTION OR DISTRIBUTION OF THIS FILE
 * CONSTITUTES RECIPIENTS ACCEPTANCE OF THE AGREEMENT.
 *
 * You can obtain a current copy of the Common Public License from
 * http://www.opensource.org/licenses/cpl1.0.php
 *
 * author:     Murillo Bernardes <ber...@br...>
 *
 * Contributors:
 *
 */
#ifndef Linux_DnsAllowTransferACLForZoneRepositoryExternal_h
#define Linux_DnsAllowTransferACLForZoneRepositoryExternal_h

#include "Linux_DnsAllowTransferACLForZoneInstanceName.h"
#include "Linux_DnsAllowTransferACLForZoneRepositoryInstance.h"
#include "CmpiBroker.h"

namespace genProvider {

  class Linux_DnsAllowTransferACLForZoneRepositoryExternal {

    public:
    Linux_DnsAllowTransferACLForZoneRepositoryExternal(
     const CmpiBroker& brkr,
     const CmpiContext& ctx);
    virtual ~Linux_DnsAllowTransferACLForZoneRepositoryExternal();

    virtual void enumInstanceNames(
     Linux_DnsAllowTransferACLForZoneInstanceNameEnumeration&);

    virtual void enumInstances(
     const char* *properties,
     Linux_DnsAllowTransferACLForZoneRepositoryInstanceEnumeration&);

    virtual Linux_DnsAllowTransferACLForZoneRepositoryInstance getInstance(
     const char* *properties,
     const Linux_DnsAllowTransferACLForZoneInstanceName&);

    virtual void setInstance(
     const char* *properties,
     const Linux_DnsAllowTransferACLForZoneRepositoryInstance&);

    virtual void createInstance(
     const Linux_DnsAllowTransferACLForZoneRepositoryInstance&);

    virtual void deleteInstance(
     const Linux_DnsAllowTransferACLForZoneInstanceName&);

    private:
    CmpiBroker  broker;
    CmpiContext context;
    const static char *nsp;
  };
}
#endif

--- NEW FILE: Linux_DnsAllowTransferACLForZoneRepositoryExternal.cpp ---
 /**
 * Linux_DnsAllowTransferACLForZoneRepositoryExternal.cpp
 *
 * (C) Copyright IBM Corp. 2005
 *
 * THIS FILE IS PROVIDED UNDER THE TERMS OF THE COMMON PUBLIC LICENSE
 * ("AGREEMENT"). ANY USE, REPRODUCTION OR DISTRIBUTION OF THIS FILE
 * CONSTITUTES RECIPIENTS ACCEPTANCE OF THE AGREEMENT.
 *
 * You can obtain a current copy of the Common Public License from
 * http://www.opensource.org/licenses/cpl1.0.php
 *
 * author:     Murillo Bernardes <ber...@br...>
 *
 * Contributors:
 *
 */
#include "Linux_DnsAllowTransferACLForZoneRepositoryExternal.h"

namespace genProvider{

  Linux_DnsAllowTransferACLForZoneRepositoryExternal::Linux_DnsAllowTransferACLForZoneRepositoryExternal(
   const CmpiBroker& brkr, const CmpiContext& ctx ) 
   : broker(brkr), context(ctx) {};

  const char * Linux_DnsAllowTransferACLForZoneRepositoryExternal::
   nsp="IBMShadow/cimv2";

  Linux_DnsAllowTransferACLForZoneRepositoryExternal::
   ~Linux_DnsAllowTransferACLForZoneRepositoryExternal(){};

  void Linux_DnsAllowTransferACLForZoneRepositoryExternal::enumInstanceNames(
   Linux_DnsAllowTransferACLForZoneInstanceNameEnumeration& instnames) {

    CmpiObjectPath op(nsp,"Linux_DnsAllowTransferACLForZone");
    CmpiEnumeration en=broker.enumInstanceNames(context,op);
    while(en.hasNext()) {
      CmpiObjectPath opi = en.getNext();
      Linux_DnsAllowTransferACLForZoneInstanceName iname(opi);
      instnames.addElement(iname);
    }
  };

  void Linux_DnsAllowTransferACLForZoneRepositoryExternal::enumInstances(
   const char* *properties,
   Linux_DnsAllowTransferACLForZoneRepositoryInstanceEnumeration& instances) {

    CmpiObjectPath op(nsp,"Linux_DnsAllowTransferACLForZone");
    CmpiEnumeration en=broker.enumInstances(context,op,properties);
    while(en.hasNext()) {
      CmpiInstance inst = en.getNext();
      Linux_DnsAllowTransferACLForZoneRepositoryInstance instance(inst,nsp);
      instances.addElement(instance);
    }
  };

  Linux_DnsAllowTransferACLForZoneRepositoryInstance
   Linux_DnsAllowTransferACLForZoneRepositoryExternal::getInstance(
   const char* *properties,
   const Linux_DnsAllowTransferACLForZoneInstanceName& instanceName) {

    CmpiObjectPath op=instanceName.getObjectPath();
    op.setNameSpace(nsp);
    CmpiInstance inst=broker.getInstance(context,op,properties);
    return Linux_DnsAllowTransferACLForZoneRepositoryInstance(inst,nsp);
  }

  void Linux_DnsAllowTransferACLForZoneRepositoryExternal::setInstance(
   const char* *properties,
   const Linux_DnsAllowTransferACLForZoneRepositoryInstance& instance){

    //make a copy of the given instance and set it to the right nameSpace
    Linux_DnsAllowTransferACLForZoneInstanceName instanceName(instance.getInstanceName());
    instanceName.setNamespace(nsp,1);
    Linux_DnsAllowTransferACLForZoneRepositoryInstance copiedInstance(instance);
    copiedInstance.setInstanceName(instanceName);

    CmpiObjectPath op=instanceName.getObjectPath();
    CmpiInstance inst=copiedInstance.getCmpiInstance();
    broker.setInstance(context,op,inst,properties);
  }

  void Linux_DnsAllowTransferACLForZoneRepositoryExternal::createInstance(
   const Linux_DnsAllowTransferACLForZoneRepositoryInstance& instance){

    //make a copy of the given instance and set it to the right nameSpace
    Linux_DnsAllowTransferACLForZoneInstanceName instanceName(instance.getInstanceName());
    instanceName.setNamespace(nsp,1);
    Linux_DnsAllowTransferACLForZoneRepositoryInstance copiedInstance(instance);
    copiedInstance.setInstanceName(instanceName);

    CmpiObjectPath op=instanceName.getObjectPath();
    CmpiInstance inst=copiedInstance.getCmpiInstance();
    broker.createInstance(context,op,inst);
  }

  void Linux_DnsAllowTransferACLForZoneRepositoryExternal::deleteInstance(
   const Linux_DnsAllowTransferACLForZoneInstanceName& instanceName){

    CmpiObjectPath op=instanceName.getObjectPath();
    op.setNameSpace(nsp);
    broker.deleteInstance(context,op);
  }  
}

--- NEW FILE: Linux_DnsAllowTransferACLForZoneInstanceName.h ---
 /**
 * Linux_DnsAllowTransferACLForZoneInstanceName.h
 *
 * (C) Copyright IBM Corp. 2005
 *
 * THIS FILE IS PROVIDED UNDER THE TERMS OF THE COMMON PUBLIC LICENSE
 * ("AGREEMENT"). ANY USE, REPRODUCTION OR DISTRIBUTION OF THIS FILE
 * CONSTITUTES RECIPIENTS ACCEPTANCE OF THE AGREEMENT.
 *
 * You can obtain a current copy of the Common Public License from
 * http://www.opensource.org/licenses/cpl1.0.php
 *
 * author:     Murillo Bernardes <ber...@br...>
 *
 * Contributors:
 *
 */
#ifndef Linux_DnsAllowTransferACLForZoneInstanceName_h
#define Linux_DnsAllowTransferACLForZoneInstanceName_h

#include "cmpidt.h"
#include "CmpiObjectPath.h"
#include "CmpiInstance.h"
#include "CmpiBooleanData.h"
#include "CmpiCharData.h"
#include "CmpiDateTime.h"
#include "ArrayConverter.h"
#include "CmpiErrorFormater.h"
#include "Linux_DnsZoneInstanceName.h"
#include "Linux_DnsAddressMatchListInstanceName.h"

namespace genProvider {

  class Linux_DnsAllowTransferACLForZoneInstanceName {
  public:
       Linux_DnsAllowTransferACLForZoneInstanceName();

       Linux_DnsAllowTransferACLForZoneInstanceName
  	    (const Linux_DnsAllowTransferACLForZoneInstanceName& original);

       Linux_DnsAllowTransferACLForZoneInstanceName
        (const CmpiObjectPath& path);

       ~Linux_DnsAllowTransferACLForZoneInstanceName();

       Linux_DnsAllowTransferACLForZoneInstanceName& operator=
  	    (const Linux_DnsAllowTransferACLForZoneInstanceName& original);

       CmpiObjectPath getObjectPath() const;

       void fillKeys(CmpiInstance& cmpiInstance) const;

       unsigned int isNameSpaceSet() const;
       void setNamespace(const char * val, int makeCopy = 1);
       const char * getNamespace() const;

       unsigned int isElementSet() const;
       void setElement(const Linux_DnsZoneInstanceName& val);
       const Linux_DnsZoneInstanceName& getElement() const;

       unsigned int isSettingSet() const;
       void setSetting(const Linux_DnsAddressMatchListInstanceName& val);
       const Linux_DnsAddressMatchListInstanceName& getSetting() const;

  private:
       void init();
       void init(const Linux_DnsAllowTransferACLForZoneInstanceName& original);
       void reset();

       const char* m_CIMClassNameP;
       const char* m_namespace;
       Linux_DnsZoneInstanceName m_Element;
       Linux_DnsAddressMatchListInstanceName m_Setting;

       struct isSetType{
       	 unsigned int m_namespace:1;
         unsigned int Element:1;
         unsigned int Setting:1;
       } isSet;
  };

  struct Linux_DnsAllowTransferACLForZoneInstanceNameEnumerationElement{
  	Linux_DnsAllowTransferACLForZoneInstanceName* m_elementP;
  	Linux_DnsAllowTransferACLForZoneInstanceNameEnumerationElement* m_nextP;

  	Linux_DnsAllowTransferACLForZoneInstanceNameEnumerationElement();
  	~Linux_DnsAllowTransferACLForZoneInstanceNameEnumerationElement();  	
  };

  class Linux_DnsAllowTransferACLForZoneInstanceNameEnumeration {
  	private:
  	  Linux_DnsAllowTransferACLForZoneInstanceNameEnumerationElement* firstElementP;
  	  Linux_DnsAllowTransferACLForZoneInstanceNameEnumerationElement* currentElementP;
  	  Linux_DnsAllowTransferACLForZoneInstanceNameEnumerationElement* endElementP;

  	public:
  	  Linux_DnsAllowTransferACLForZoneInstanceNameEnumeration();

  	  Linux_DnsAllowTransferACLForZoneInstanceNameEnumeration(const CmpiArray& arr);

  	  Linux_DnsAllowTransferACLForZoneInstanceNameEnumeration(
  	   const Linux_DnsAllowTransferACLForZoneInstanceNameEnumeration& original);

  	  ~Linux_DnsAllowTransferACLForZoneInstanceNameEnumeration();

  	  void reset();

  	  bool hasNext() const;

  	  const Linux_DnsAllowTransferACLForZoneInstanceName& getNext();

  	  int getSize() const;

  	  const Linux_DnsAllowTransferACLForZoneInstanceName& getElement(int pos) const;  	  

  	  //no copy of the element is done
  	  void addElement(const Linux_DnsAllowTransferACLForZoneInstanceName& elementP);

  	  operator CmpiArray() const;
  };
}
#endif

--- NEW FILE: Linux_DnsAllowTransferACLForZoneDefaultImplementation.cpp ---
 /**
 * Linux_DnsAllowTransferACLForZoneDefaultImplementation.cpp
 *
 * (C) Copyright IBM Corp. 2005
 *
 * THIS FILE IS PROVIDED UNDER THE TERMS OF THE COMMON PUBLIC LICENSE
 * ("AGREEMENT"). ANY USE, REPRODUCTION OR DISTRIBUTION OF THIS FILE
 * CONSTITUTES RECIPIENTS ACCEPTANCE OF THE AGREEMENT.
 *
 * You can obtain a current copy of the Common Public License from
 * http://www.opensource.org/licenses/cpl1.0.php
 *
 * author:     Murillo Bernardes <ber...@br...>
 *
 * Contributors:
 *
 */
#include "Linux_DnsAllowTransferACLForZoneDefaultImplementation.h"
#include <iostream>

using namespace std;

namespace genProvider {

  /* intrinsic methods */
  void Linux_DnsAllowTransferACLForZoneDefaultImplementation::enumInstanceNames(
   const CmpiContext& ctx, const CmpiBroker &mbp, const char *nsp,
   Linux_DnsAllowTransferACLForZoneInstanceNameEnumeration& instnames){
   	cout<<"enumInstances not supported for Linux_DnsAllowTransferACLForZone"<<endl;
   	throw CmpiErrorFormater::getErrorException(
   	 CmpiErrorFormater::NOT_IMPLEMENTED,
   	 "enumInstances not implemented for Linux_DnsAllowTransferACLForZone");   
  }

  void Linux_DnsAllowTransferACLForZoneDefaultImplementation::enumInstances(
   const CmpiContext& ctx,
   const CmpiBroker &mbp,
   const char *nsp,
   const char* *properties,
   Linux_DnsAllowTransferACLForZoneManualInstanceEnumeration& instances){

    cout<<"Using default enumInstances implementation for Linux_DnsAllowTransferACLForZone"<<endl;
    cout<<"LetÅ½s get the instanceNames"<<endl;
    Linux_DnsAllowTransferACLForZoneInstanceNameEnumeration namesEnumeration;
    enumInstanceNames(ctx, mbp,nsp,namesEnumeration);
    cout<<"Getting each instance"<<endl;
    while(namesEnumeration.hasNext()){
      Linux_DnsAllowTransferACLForZoneInstanceName name=
    	  namesEnumeration.getNext();
    	cout<<"Getting an instance for instanceName"<<endl;
    	Linux_DnsAllowTransferACLForZoneManualInstance instance=
    	  getInstance(ctx, mbp, properties, name);
    	cout<<"adding instance to enum"<<endl;
    	instances.addElement(instance);
    	cout<<"Added!"<<endl;
    };
  }

  Linux_DnsAllowTransferACLForZoneManualInstance 
   Linux_DnsAllowTransferACLForZoneDefaultImplementation::getInstance(
   const CmpiContext& ctx,
   const CmpiBroker &mbp,
   const char* *properties,
   const Linux_DnsAllowTransferACLForZoneInstanceName&){
    cout<<"getInstance not supported for Linux_DnsAllowTransferACLForZone"<<endl;
    throw CmpiErrorFormater::getErrorException(
   	 CmpiErrorFormater::NOT_IMPLEMENTED,
   	 "getInstance not implemented for Linux_DnsAllowTransferACLForZone");
  }

  void Linux_DnsAllowTransferACLForZoneDefaultImplementation::setInstance(
   const CmpiContext& ctx,
   const CmpiBroker &mbp,
   const char* *properties,
   const Linux_DnsAllowTransferACLForZoneManualInstance&){
   	cout<<"setInstance not supported for Linux_DnsAllowTransferACLForZone"<<endl;
     throw CmpiErrorFormater::getErrorException(
   	 CmpiErrorFormater::NOT_IMPLEMENTED,
   	 "setInstance not implemented for Linux_DnsAllowTransferACLForZone");
  }

  void Linux_DnsAllowTransferACLForZoneDefaultImplementation::
   createInstance(const CmpiContext& ctx, const CmpiBroker &mbp,
   const Linux_DnsAllowTransferACLForZoneManualInstance&){
   	cout<<"createInstance not supported for Linux_DnsAllowTransferACLForZone"<<endl;
    throw CmpiErrorFormater::getErrorException(
   	 CmpiErrorFormater::NOT_IMPLEMENTED,
   	 "createInstance not implemented for Linux_DnsAllowTransferACLForZone");
  }

  void Linux_DnsAllowTransferACLForZoneDefaultImplementation::
   deleteInstance(const CmpiContext& ctx, const CmpiBroker &mbp,
   const Linux_DnsAllowTransferACLForZoneInstanceName&){
   	cout<<"deleteInstance not supported for Linux_DnsAllowTransferACLForZone"<<endl;
    throw CmpiErrorFormater::getErrorException(
   	 CmpiErrorFormater::NOT_IMPLEMENTED,
   	 "deleteInstance not implemented for Linux_DnsAllowTransferACLForZone");
  }

    /* Association Interface */

    void Linux_DnsAllowTransferACLForZoneDefaultImplementation::
     referencesElement( 
     const Cm...

[truncated message content]

Thread: [Sblim-commit] cmpi-dns/provider/Linux_DnsAllowTransferACLForZone Linux_DnsAllowTransferACLForZoneEx

sblim-commit