[Sblim-commit] cmpi-dns/provider/Linux_DnsServiceConfiguration Linux_DnsServiceConfigurationInterface.h,NONE,1.1 CmpiLinux_DnsServiceConfigurationProvider.cpp,NONE,1.1 Linux_DnsServiceConfigurationManualInstance.h,NONE,1.1 Linux_DnsServiceConfigurationInstance.h,NONE,1.1 Linux_DnsServiceConfigurationInstance.cpp,NONE,1.1 Linux_DnsServiceConfigurationRepositoryExternal.cpp,NONE,1.1 Linux_DnsServiceConfigurationExternal.cpp,NONE,1.1 Linux_DnsServiceConfigurationRepositoryInstance.h,NONE,1.1 Linux_DnsServiceConfigurationResourceAccess.h,NONE,1.1 Linux_DnsServiceConfigurationRepositoryExternal.h,NONE,1.1 Linux_DnsServiceConfigurationManualInstance.cpp,NONE,1.1 Linux_DnsServiceConfigurationDefaultImplementation.cpp,NONE,1.1 Linux_DnsServiceConfigurationFactory.h,NONE,1.1 Linux_DnsServiceConfigurationDefaultImplementation.h,NONE,1.1 Linux_DnsServiceConfigurationInstanceName.cpp,NONE,1.1 CmpiLinux_DnsServiceConfigurationProvider.h,NONE,1.1 makefile,NONE,1.1 Linux_DnsServiceConfigurationExternal.h,NONE,1.1 Linux_DnsServiceConfigurationResourceAccess.cpp,NONE,1.1 Linux_DnsServiceConfigurationRepositoryInstance.cpp,NONE,1.1 Linux_DnsServiceConfigurationInstanceName.h,NONE,1.1 setting.provider,NONE,1.1 Linux_DnsServiceConfigurationFakeFactory.cpp,NONE,1.1 Linux_DnsServiceConfigurationFactory.cpp,NONE,1.1

[Wolfgang T. <ta...@us...>]

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

Added Files:
	Linux_DnsServiceConfigurationInterface.h 
	CmpiLinux_DnsServiceConfigurationProvider.cpp 
	Linux_DnsServiceConfigurationManualInstance.h 
	Linux_DnsServiceConfigurationInstance.h 
	Linux_DnsServiceConfigurationInstance.cpp 
	Linux_DnsServiceConfigurationRepositoryExternal.cpp 
	Linux_DnsServiceConfigurationExternal.cpp 
	Linux_DnsServiceConfigurationRepositoryInstance.h 
	Linux_DnsServiceConfigurationResourceAccess.h 
	Linux_DnsServiceConfigurationRepositoryExternal.h 
	Linux_DnsServiceConfigurationManualInstance.cpp 
	Linux_DnsServiceConfigurationDefaultImplementation.cpp 
	Linux_DnsServiceConfigurationFactory.h 
	Linux_DnsServiceConfigurationDefaultImplementation.h 
	Linux_DnsServiceConfigurationInstanceName.cpp 
	CmpiLinux_DnsServiceConfigurationProvider.h makefile 
	Linux_DnsServiceConfigurationExternal.h 
	Linux_DnsServiceConfigurationResourceAccess.cpp 
	Linux_DnsServiceConfigurationRepositoryInstance.cpp 
	Linux_DnsServiceConfigurationInstanceName.h setting.provider 
	Linux_DnsServiceConfigurationFakeFactory.cpp 
	Linux_DnsServiceConfigurationFactory.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: Linux_DnsServiceConfigurationRepositoryInstance.cpp ---
 /**
 * Linux_DnsServiceConfigurationRepositoryInstance.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_DnsServiceConfigurationRepositoryInstance.h"
#include "CmpiData.h"
#include "CmpiString.h"
#include "CmpiArray.h"
#include <string>

namespace genProvider {

  //*********************************************************
  //Linux_DnsServiceConfigurationRepositoryInstance
  //*********************************************************

  //empty constructor
  Linux_DnsServiceConfigurationRepositoryInstance::
   Linux_DnsServiceConfigurationRepositoryInstance(){   	
   	init();  	   	
  };
  
  
  //copy constructor	
  Linux_DnsServiceConfigurationRepositoryInstance::
   Linux_DnsServiceConfigurationRepositoryInstance
   (const Linux_DnsServiceConfigurationRepositoryInstance& original){   	
   	init(original);  	   	
  };
  
  
  //constructor using CmpiInstance
  Linux_DnsServiceConfigurationRepositoryInstance::
   Linux_DnsServiceConfigurationRepositoryInstance (const CmpiInstance& inst, const char* instanceNamespace){
    CmpiData cmpiData;
    init(); 
    
    CmpiObjectPath cop=inst.getObjectPath();
    cop.setNameSpace(instanceNamespace);
    setInstanceName(Linux_DnsServiceConfigurationInstanceName(cop));
    
  }
  
  
  //Destructor
  Linux_DnsServiceConfigurationRepositoryInstance::
   ~Linux_DnsServiceConfigurationRepositoryInstance(){
   	reset();  	  
  };
  
  
  //copy operator
  Linux_DnsServiceConfigurationRepositoryInstance&
   Linux_DnsServiceConfigurationRepositoryInstance::operator=
   (const Linux_DnsServiceConfigurationRepositoryInstance& original){   	
   	init(original);
   	return *this;
  };
  
  
  //converts to CmpiInstance
  CmpiInstance Linux_DnsServiceConfigurationRepositoryInstance::
   getCmpiInstance(const char** properties) const{
   	
   	CmpiObjectPath objectPath=getInstanceName().getObjectPath();      
    CmpiInstance cmpiInstance(objectPath);    
    getInstanceName().fillKeys(cmpiInstance);
    
    if (properties) {
	  cmpiInstance.setPropertyFilter(properties,0);
    }
  	
  	return cmpiInstance;
  	
  }
  
  
  //InstanceName related methods
  unsigned int Linux_DnsServiceConfigurationRepositoryInstance::
   isInstanceNameSet() const{
  	return isSet.instanceName;
  }
  
  const Linux_DnsServiceConfigurationInstanceName&
    Linux_DnsServiceConfigurationRepositoryInstance::getInstanceName() const{

    if(!isSet.instanceName)
   	  throw CmpiErrorFormater::getErrorException(
   	   CmpiErrorFormater::NOT_SET,
   	   "InstanceName not set in Linux_DnsServiceConfiguration instance");
  		
   	return m_instanceName;
  }

  void Linux_DnsServiceConfigurationRepositoryInstance::setInstanceName(
   const Linux_DnsServiceConfigurationInstanceName& val){
    m_instanceName = val;
    isSet.instanceName=1;
  }


  
  //set isSet attributes to FALSE
  void Linux_DnsServiceConfigurationRepositoryInstance::init(){
   	isSet.instanceName=0;
   	  	
  };
  
  
  //copies another instance properties in this
  void Linux_DnsServiceConfigurationRepositoryInstance::init
   (const Linux_DnsServiceConfigurationRepositoryInstance& original){   	
   	init();
   	   	
    if(original.isInstanceNameSet()){
      setInstanceName(original.getInstanceName());
    }    
   }
  
  
  //reset the instance data
  void Linux_DnsServiceConfigurationRepositoryInstance::reset(){
   	
  	  
  };
  
  
  //*********************************************************
  //Linux_DnsServiceConfigurationRepositoryInstanceEnumerationElement	
  //*********************************************************
  
  Linux_DnsServiceConfigurationRepositoryInstanceEnumerationElement::
   Linux_DnsServiceConfigurationRepositoryInstanceEnumerationElement(){
   	
  	m_elementP=0;
  	m_nextP=0;
  	  
  };
  
  
  Linux_DnsServiceConfigurationRepositoryInstanceEnumerationElement::
   ~Linux_DnsServiceConfigurationRepositoryInstanceEnumerationElement(){
   	
  	if (m_elementP!=0)
  	  delete(m_elementP);
  	if (m_nextP!=0)
  	  delete(m_nextP);
  	  
  };

  
  //*********************************************************
  //Linux_DnsServiceConfigurationRepositoryInstanceNameEnumeration
  //*********************************************************

  Linux_DnsServiceConfigurationRepositoryInstanceEnumeration::
   Linux_DnsServiceConfigurationRepositoryInstanceEnumeration(){
   	
  	 firstElementP=0;
     currentElementP=0;
     endElementP=0;
  };
  
  Linux_DnsServiceConfigurationRepositoryInstanceEnumeration::
   Linux_DnsServiceConfigurationRepositoryInstanceEnumeration(
   const Linux_DnsServiceConfigurationRepositoryInstanceEnumeration& original){
   	
     firstElementP=0;
     currentElementP=0;
     endElementP=0;
  	 
     int size=original.getSize();
     for(int i=0;i<size;i++)
       addElement(original.getElement(i));           
  };
  
  	  
  Linux_DnsServiceConfigurationRepositoryInstanceEnumeration::
   ~Linux_DnsServiceConfigurationRepositoryInstanceEnumeration(){
   	
  	if (firstElementP!=0)
  	  delete(firstElementP);
  	  	
  };
  
  	  
  void Linux_DnsServiceConfigurationRepositoryInstanceEnumeration::reset(){
  	
  	currentElementP=firstElementP;
  };
  
  	  
  bool Linux_DnsServiceConfigurationRepositoryInstanceEnumeration::hasNext() const{
  	
  	return (currentElementP!=0);
  
  };
  
  int Linux_DnsServiceConfigurationRepositoryInstanceEnumeration::getSize() const{
  	
    int size=0;
    Linux_DnsServiceConfigurationRepositoryInstanceEnumerationElement* followingP=firstElementP;
  	
  	while(followingP!=0){
        followingP=followingP->m_nextP;
        size++;
    }
  	
    return size;
    
  };
  
  const Linux_DnsServiceConfigurationRepositoryInstance&  
   Linux_DnsServiceConfigurationRepositoryInstanceEnumeration::getElement(int pos) const{
   
    Linux_DnsServiceConfigurationRepositoryInstanceEnumerationElement* followingP=firstElementP;
   
    int i=0;
    while((followingP!=0)&&(i<pos)){
        followingP=followingP->m_nextP;
        i++;
    }
    
    return *(followingP->m_elementP);
  };
  
  	  
  const Linux_DnsServiceConfigurationRepositoryInstance&
   Linux_DnsServiceConfigurationRepositoryInstanceEnumeration::getNext() {
   	
  	 Linux_DnsServiceConfigurationRepositoryInstanceEnumerationElement* currentP=
  	  currentElementP;
  	 currentElementP=currentElementP->m_nextP;
  	 
  	 return *(currentP->m_elementP);
  };
  	  
  void Linux_DnsServiceConfigurationRepositoryInstanceEnumeration::addElement
   (const Linux_DnsServiceConfigurationRepositoryInstance& elementP){
   	
  	if(firstElementP==0){
  	  firstElementP=new Linux_DnsServiceConfigurationRepositoryInstanceEnumerationElement();
  	  firstElementP->m_elementP=new Linux_DnsServiceConfigurationRepositoryInstance(elementP);
  	  endElementP=firstElementP;
  	  currentElementP=firstElementP;
  	}else{
  	  endElementP->m_nextP=new Linux_DnsServiceConfigurationRepositoryInstanceEnumerationElement();
  	  endElementP=endElementP->m_nextP;
  	  endElementP->m_elementP=new Linux_DnsServiceConfigurationRepositoryInstance(elementP);
  	}
  };  
}
 

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

#CPPFLAGS.provider
#LDFLAGS.provider


--- NEW FILE: Linux_DnsServiceConfigurationRepositoryInstance.h ---
 /**
 * Linux_DnsServiceConfigurationRepositoryInstance.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_DnsServiceConfigurationRepositoryInstance_h
#define Linux_DnsServiceConfigurationRepositoryInstance_h

#include "cmpidt.h"
#include "CmpiObjectPath.h"
#include "CmpiInstance.h"
#include "CmpiBooleanData.h"
#include "CmpiCharData.h"
#include "CmpiDateTime.h"

#include "Linux_DnsServiceConfigurationInstanceName.h"

namespace genProvider {

  class Linux_DnsServiceConfigurationRepositoryInstance {
  public:
       Linux_DnsServiceConfigurationRepositoryInstance();
  	
       Linux_DnsServiceConfigurationRepositoryInstance
  	    (const Linux_DnsServiceConfigurationRepositoryInstance& original);
  	   
       Linux_DnsServiceConfigurationRepositoryInstance
        (const CmpiInstance& inst, const char* instanceNamespace);
  	 
       ~Linux_DnsServiceConfigurationRepositoryInstance();
       
       Linux_DnsServiceConfigurationRepositoryInstance& operator=
  	    (const Linux_DnsServiceConfigurationRepositoryInstance& original);
       
       CmpiInstance getCmpiInstance(const char** properties=0) const;
       
       unsigned int isInstanceNameSet() const;
       void setInstanceName(
        const Linux_DnsServiceConfigurationInstanceName& val);        
       const Linux_DnsServiceConfigurationInstanceName&
        getInstanceName() const;
       
  private:
       void init();
       void init(const Linux_DnsServiceConfigurationRepositoryInstance& original);
       void reset();
       
       Linux_DnsServiceConfigurationInstanceName m_instanceName;
       
       struct isSetType{
       	 unsigned int instanceName:1;
       } isSet;
  };
  
  
  struct Linux_DnsServiceConfigurationRepositoryInstanceEnumerationElement{
  	Linux_DnsServiceConfigurationRepositoryInstance* m_elementP;
  	Linux_DnsServiceConfigurationRepositoryInstanceEnumerationElement* m_nextP;
  	
  	Linux_DnsServiceConfigurationRepositoryInstanceEnumerationElement();
  	~Linux_DnsServiceConfigurationRepositoryInstanceEnumerationElement();  	
  };
  

  class Linux_DnsServiceConfigurationRepositoryInstanceEnumeration {
  	private:
  	  Linux_DnsServiceConfigurationRepositoryInstanceEnumerationElement* firstElementP;
  	  Linux_DnsServiceConfigurationRepositoryInstanceEnumerationElement* currentElementP;
  	  Linux_DnsServiceConfigurationRepositoryInstanceEnumerationElement* endElementP;
  	
  	public:
  	  Linux_DnsServiceConfigurationRepositoryInstanceEnumeration();
  	  
  	  Linux_DnsServiceConfigurationRepositoryInstanceEnumeration(
  	   const Linux_DnsServiceConfigurationRepositoryInstanceEnumeration& original);
  	  
  	  ~Linux_DnsServiceConfigurationRepositoryInstanceEnumeration();
  	  
  	  void reset();
  	  
  	  bool hasNext() const;
  	  
  	  const Linux_DnsServiceConfigurationRepositoryInstance& getNext();
  	  
  	  int getSize() const;
  	  
  	  const Linux_DnsServiceConfigurationRepositoryInstance& getElement(int pos) const;  	  
  	  
  	 void addElement(const Linux_DnsServiceConfigurationRepositoryInstance& elementP);
  };
}
#endif


--- NEW FILE: Linux_DnsServiceConfigurationRepositoryExternal.cpp ---
 /**
 * Linux_DnsServiceConfigurationRepositoryExternal.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_DnsServiceConfigurationRepositoryExternal.h"

namespace genProvider{
	
  Linux_DnsServiceConfigurationRepositoryExternal::Linux_DnsServiceConfigurationRepositoryExternal(
   const CmpiBroker& brkr, const CmpiContext& ctx ) 
   : broker(brkr), context(ctx) {};
  
  const char * Linux_DnsServiceConfigurationRepositoryExternal::
   nsp="IBMShadow/cimv2";
   
  Linux_DnsServiceConfigurationRepositoryExternal::
   ~Linux_DnsServiceConfigurationRepositoryExternal(){};
    
  void Linux_DnsServiceConfigurationRepositoryExternal::enumInstanceNames(
   Linux_DnsServiceConfigurationInstanceNameEnumeration& instnames) {

    CmpiObjectPath op(nsp,"Linux_DnsServiceConfiguration");
    CmpiEnumeration en=broker.enumInstanceNames(context,op);
    while(en.hasNext()) {
      CmpiObjectPath opi = en.getNext();
      Linux_DnsServiceConfigurationInstanceName iname(opi);
      instnames.addElement(iname);
    }
  };
  	  
  void Linux_DnsServiceConfigurationRepositoryExternal::enumInstances(
   const char* *properties,
   Linux_DnsServiceConfigurationRepositoryInstanceEnumeration& instances) {
   		
    CmpiObjectPath op(nsp,"Linux_DnsServiceConfiguration");
    CmpiEnumeration en=broker.enumInstances(context,op,properties);
    while(en.hasNext()) {
      CmpiInstance inst = en.getNext();
      Linux_DnsServiceConfigurationRepositoryInstance instance(inst,nsp);
      instances.addElement(instance);
    }
  };
  	  
  Linux_DnsServiceConfigurationRepositoryInstance
   Linux_DnsServiceConfigurationRepositoryExternal::getInstance(
   const char* *properties,
   const Linux_DnsServiceConfigurationInstanceName& instanceName) {
    
    CmpiObjectPath op=instanceName.getObjectPath();
    op.setNameSpace(nsp);
    CmpiInstance inst=broker.getInstance(context,op,properties);
    return Linux_DnsServiceConfigurationRepositoryInstance(inst,nsp);
  }
      
  void Linux_DnsServiceConfigurationRepositoryExternal::setInstance(
   const char* *properties,
   const Linux_DnsServiceConfigurationRepositoryInstance& instance){
  
    //make a copy of the given instance and set it to the right nameSpace
    Linux_DnsServiceConfigurationInstanceName instanceName(instance.getInstanceName());
    instanceName.setNamespace(nsp,1);
    Linux_DnsServiceConfigurationRepositoryInstance copiedInstance(instance);
    copiedInstance.setInstanceName(instanceName);
    
    CmpiObjectPath op=instanceName.getObjectPath();
    CmpiInstance inst=copiedInstance.getCmpiInstance();
    broker.setInstance(context,op,inst,properties);
  }
      
  void Linux_DnsServiceConfigurationRepositoryExternal::createInstance(
   const Linux_DnsServiceConfigurationRepositoryInstance& instance){
  
    //make a copy of the given instance and set it to the right nameSpace
    Linux_DnsServiceConfigurationInstanceName instanceName(instance.getInstanceName());
    instanceName.setNamespace(nsp,1);
    Linux_DnsServiceConfigurationRepositoryInstance copiedInstance(instance);
    copiedInstance.setInstanceName(instanceName);
    
    CmpiObjectPath op=instanceName.getObjectPath();
    CmpiInstance inst=copiedInstance.getCmpiInstance();
    broker.createInstance(context,op,inst);
  }
  
  void Linux_DnsServiceConfigurationRepositoryExternal::deleteInstance(
   const Linux_DnsServiceConfigurationInstanceName& instanceName){
    
    CmpiObjectPath op=instanceName.getObjectPath();
    op.setNameSpace(nsp);
    broker.deleteInstance(context,op);
  }  
}

--- NEW FILE: Linux_DnsServiceConfigurationRepositoryExternal.h ---
 /**
 * Linux_DnsServiceConfigurationRepositoryExternal.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_DnsServiceConfigurationRepositoryExternal_h
#define Linux_DnsServiceConfigurationRepositoryExternal_h

#include "Linux_DnsServiceConfigurationInstanceName.h"
#include "Linux_DnsServiceConfigurationRepositoryInstance.h"
#include "CmpiBroker.h"

namespace genProvider {

  class Linux_DnsServiceConfigurationRepositoryExternal {
  	
    public:
    Linux_DnsServiceConfigurationRepositoryExternal(
     const CmpiBroker& brkr,
     const CmpiContext& ctx);
    virtual ~Linux_DnsServiceConfigurationRepositoryExternal();
    
    virtual void enumInstanceNames(
     Linux_DnsServiceConfigurationInstanceNameEnumeration&);
     
    virtual void enumInstances(
     const char* *properties,
     Linux_DnsServiceConfigurationRepositoryInstanceEnumeration&);
     
    virtual Linux_DnsServiceConfigurationRepositoryInstance getInstance(
     const char* *properties,
     const Linux_DnsServiceConfigurationInstanceName&);
     
    virtual void setInstance(
     const char* *properties,
     const Linux_DnsServiceConfigurationRepositoryInstance&);
     
    virtual void createInstance(
     const Linux_DnsServiceConfigurationRepositoryInstance&);
     
    virtual void deleteInstance(
     const Linux_DnsServiceConfigurationInstanceName&);
     
    private:
    CmpiBroker  broker;
    CmpiContext context;
    const static char *nsp;
  };
}
#endif

--- NEW FILE: Linux_DnsServiceConfigurationInstanceName.h ---
 /**
 * Linux_DnsServiceConfigurationInstanceName.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_DnsServiceConfigurationInstanceName_h
#define Linux_DnsServiceConfigurationInstanceName_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_DnsServiceInstanceName.h"
#include "Linux_DnsConfigurationInstanceName.h"

namespace genProvider {

  class Linux_DnsServiceConfigurationInstanceName {
  public:
       Linux_DnsServiceConfigurationInstanceName();
  	
       Linux_DnsServiceConfigurationInstanceName
  	    (const Linux_DnsServiceConfigurationInstanceName& original);
  	   
       Linux_DnsServiceConfigurationInstanceName
        (const CmpiObjectPath& path);
  	 
       ~Linux_DnsServiceConfigurationInstanceName();
       
       Linux_DnsServiceConfigurationInstanceName& operator=
  	    (const Linux_DnsServiceConfigurationInstanceName& 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_DnsServiceInstanceName& val);
       const Linux_DnsServiceInstanceName& getElement() const;

       unsigned int isConfigurationSet() const;
       void setConfiguration(const Linux_DnsConfigurationInstanceName& val);
       const Linux_DnsConfigurationInstanceName& getConfiguration() const;
       
  private:
       void init();
       void init(const Linux_DnsServiceConfigurationInstanceName& original);
       void reset();
       
       const char* m_CIMClassNameP;
       const char* m_namespace;
       Linux_DnsServiceInstanceName m_Element;
       Linux_DnsConfigurationInstanceName m_Configuration;
       
       struct isSetType{
       	 unsigned int m_namespace:1;
         unsigned int Element:1;
         unsigned int Configuration:1;
       } isSet;
  };
  
  
  struct Linux_DnsServiceConfigurationInstanceNameEnumerationElement{
  	Linux_DnsServiceConfigurationInstanceName* m_elementP;
  	Linux_DnsServiceConfigurationInstanceNameEnumerationElement* m_nextP;
  	
  	Linux_DnsServiceConfigurationInstanceNameEnumerationElement();
  	~Linux_DnsServiceConfigurationInstanceNameEnumerationElement();  	
  };
  

  class Linux_DnsServiceConfigurationInstanceNameEnumeration {
  	private:
  	  Linux_DnsServiceConfigurationInstanceNameEnumerationElement* firstElementP;
  	  Linux_DnsServiceConfigurationInstanceNameEnumerationElement* currentElementP;
  	  Linux_DnsServiceConfigurationInstanceNameEnumerationElement* endElementP;
  	
  	public:
  	  Linux_DnsServiceConfigurationInstanceNameEnumeration();
  	  
  	  Linux_DnsServiceConfigurationInstanceNameEnumeration(const CmpiArray& arr);
  	  
  	  Linux_DnsServiceConfigurationInstanceNameEnumeration(
  	   const Linux_DnsServiceConfigurationInstanceNameEnumeration& original);
  	  
  	  ~Linux_DnsServiceConfigurationInstanceNameEnumeration();
  	  
  	  void reset();
  	  
  	  bool hasNext() const;
  	  
  	  const Linux_DnsServiceConfigurationInstanceName& getNext();
  	  
  	  int getSize() const;
  	  
  	  const Linux_DnsServiceConfigurationInstanceName& getElement(int pos) const;  	  
  	  
  	  //no copy of the element is done
  	  void addElement(const Linux_DnsServiceConfigurationInstanceName& elementP);
  	  
  	  operator CmpiArray() const;
  };
}
#endif


--- NEW FILE: Linux_DnsServiceConfigurationInstance.h ---
 /**
 * Linux_DnsServiceConfigurationInstance.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_DnsServiceConfigurationInstance_h
#define Linux_DnsServiceConfigurationInstance_h

#include "cmpidt.h"
#include "CmpiObjectPath.h"
#include "CmpiInstance.h"
#include "CmpiBooleanData.h"
#include "CmpiCharData.h"
#include "CmpiDateTime.h"

#include "Linux_DnsServiceConfigurationInstanceName.h"

namespace genProvider {

  class Linux_DnsServiceConfigurationInstance {
  public:
       Linux_DnsServiceConfigurationInstance();
  	
       Linux_DnsServiceConfigurationInstance
  	    (const Linux_DnsServiceConfigurationInstance& original);
  	   
       Linux_DnsServiceConfigurationInstance
        (const CmpiInstance& inst, const char* instanceNamespace);
  	 
       ~Linux_DnsServiceConfigurationInstance();
       
       Linux_DnsServiceConfigurationInstance& operator=
  	    (const Linux_DnsServiceConfigurationInstance& original);
       
       CmpiInstance getCmpiInstance(const char** properties=0) const;
       
       unsigned int isInstanceNameSet() const;
       void setInstanceName(
        const Linux_DnsServiceConfigurationInstanceName& val);        
       const Linux_DnsServiceConfigurationInstanceName&
        getInstanceName() const;
       
  private:
       void init();
       void init(const Linux_DnsServiceConfigurationInstance& original);
       void reset();
       
       Linux_DnsServiceConfigurationInstanceName m_instanceName;
       
       struct isSetType{
       	 unsigned int instanceName:1;
       } isSet;
  };
  
  
  struct Linux_DnsServiceConfigurationInstanceEnumerationElement{
  	Linux_DnsServiceConfigurationInstance* m_elementP;
  	Linux_DnsServiceConfigurationInstanceEnumerationElement* m_nextP;
  	
  	Linux_DnsServiceConfigurationInstanceEnumerationElement();
  	~Linux_DnsServiceConfigurationInstanceEnumerationElement();  	
  };
  

  class Linux_DnsServiceConfigurationInstanceEnumeration {
  	private:
  	  Linux_DnsServiceConfigurationInstanceEnumerationElement* firstElementP;
  	  Linux_DnsServiceConfigurationInstanceEnumerationElement* currentElementP;
  	  Linux_DnsServiceConfigurationInstanceEnumerationElement* endElementP;
  	
  	public:
  	  Linux_DnsServiceConfigurationInstanceEnumeration();
  	  
  	  Linux_DnsServiceConfigurationInstanceEnumeration(
  	   const Linux_DnsServiceConfigurationInstanceEnumeration& original);
  	  
  	  ~Linux_DnsServiceConfigurationInstanceEnumeration();
  	  
  	  void reset();
  	  
  	  bool hasNext() const;
  	  
  	  const Linux_DnsServiceConfigurationInstance& getNext();
  	  
  	  int getSize() const;
  	  
  	  const Linux_DnsServiceConfigurationInstance& getElement(int pos) const;  	  
  	  
  	 void addElement(const Linux_DnsServiceConfigurationInstance& elementP);
  };
}
#endif


--- NEW FILE: Linux_DnsServiceConfigurationManualInstance.cpp ---
 /**
 * Linux_DnsServiceConfigurationManualInstance.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_DnsServiceConfigurationManualInstance.h"
#include "CmpiData.h"
#include "CmpiString.h"
#include "CmpiArray.h"
#include <string>

namespace genProvider {

  //*********************************************************
  //Linux_DnsServiceConfigurationManualInstance
  //*********************************************************

  //empty constructor
  Linux_DnsServiceConfigurationManualInstance::
   Linux_DnsServiceConfigurationManualInstance(){   	
   	init();  	   	
  };
  
  
  //copy constructor	
  Linux_DnsServiceConfigurationManualInstance::
   Linux_DnsServiceConfigurationManualInstance
   (const Linux_DnsServiceConfigurationManualInstance& original){   	
   	init(original);  	   	
  };
  
  
  //constructor using CmpiInstance
  Linux_DnsServiceConfigurationManualInstance::
   Linux_DnsServiceConfigurationManualInstance (const CmpiInstance& inst, const char* instanceNamespace){
    CmpiData cmpiData;
    init(); 
    
    CmpiObjectPath cop=inst.getObjectPath();
    cop.setNameSpace(instanceNamespace);
    setInstanceName(Linux_DnsServiceConfigurationInstanceName(cop));
    
  }
  
  
  //Destructor
  Linux_DnsServiceConfigurationManualInstance::
   ~Linux_DnsServiceConfigurationManualInstance(){
   	reset();  	  
  };
  
  
  //copy operator
  Linux_DnsServiceConfigurationManualInstance&
   Linux_DnsServiceConfigurationManualInstance::operator=
   (const Linux_DnsServiceConfigurationManualInstance& original){   	
   	init(original);
   	return *this;
  };
  
  
  //converts to CmpiInstance
  CmpiInstance Linux_DnsServiceConfigurationManualInstance::
   getCmpiInstance(const char** properties) const{
   	
   	CmpiObjectPath objectPath=getInstanceName().getObjectPath();      
    CmpiInstance cmpiInstance(objectPath);    
    getInstanceName().fillKeys(cmpiInstance);
    
    if (properties) {
	  cmpiInstance.setPropertyFilter(properties,0);
    }
  	
  	return cmpiInstance;
  	
  }
  
  
  //InstanceName related methods
  unsigned int Linux_DnsServiceConfigurationManualInstance::
   isInstanceNameSet() const{
  	return isSet.instanceName;
  }
  
  const Linux_DnsServiceConfigurationInstanceName&
    Linux_DnsServiceConfigurationManualInstance::getInstanceName() const{

    if(!isSet.instanceName)
   	  throw CmpiErrorFormater::getErrorException(
   	   CmpiErrorFormater::NOT_SET,
   	   "InstanceName not set in Linux_DnsServiceConfiguration instance");
  		
   	return m_instanceName;
  }

  void Linux_DnsServiceConfigurationManualInstance::setInstanceName(
   const Linux_DnsServiceConfigurationInstanceName& val){
    m_instanceName = val;
    isSet.instanceName=1;
  }


  
  //set isSet attributes to FALSE
  void Linux_DnsServiceConfigurationManualInstance::init(){
   	isSet.instanceName=0;
   	  	
  };
  
  
  //copies another instance properties in this
  void Linux_DnsServiceConfigurationManualInstance::init
   (const Linux_DnsServiceConfigurationManualInstance& original){   	
   	init();
   	   	
    if(original.isInstanceNameSet()){
      setInstanceName(original.getInstanceName());
    }    
   }
  
  
  //reset the instance data
  void Linux_DnsServiceConfigurationManualInstance::reset(){
   	
  	  
  };
  
  
  //*********************************************************
  //Linux_DnsServiceConfigurationManualInstanceEnumerationElement	
  //*********************************************************
  
  Linux_DnsServiceConfigurationManualInstanceEnumerationElement::
   Linux_DnsServiceConfigurationManualInstanceEnumerationElement(){
   	
  	m_elementP=0;
  	m_nextP=0;
  	  
  };
  
  
  Linux_DnsServiceConfigurationManualInstanceEnumerationElement::
   ~Linux_DnsServiceConfigurationManualInstanceEnumerationElement(){
   	
  	if (m_elementP!=0)
  	  delete(m_elementP);
  	if (m_nextP!=0)
  	  delete(m_nextP);
  	  
  };

  
  //*********************************************************
  //Linux_DnsServiceConfigurationManualInstanceNameEnumeration
  //*********************************************************

  Linux_DnsServiceConfigurationManualInstanceEnumeration::
   Linux_DnsServiceConfigurationManualInstanceEnumeration(){
   	
  	 firstElementP=0;
     currentElementP=0;
     endElementP=0;
  };
  
  Linux_DnsServiceConfigurationManualInstanceEnumeration::
   Linux_DnsServiceConfigurationManualInstanceEnumeration(
   const Linux_DnsServiceConfigurationManualInstanceEnumeration& original){
   	
     firstElementP=0;
     currentElementP=0;
     endElementP=0;
  	 
     int size=original.getSize();
     for(int i=0;i<size;i++)
       addElement(original.getElement(i));           
  };
  
  	  
  Linux_DnsServiceConfigurationManualInstanceEnumeration::
   ~Linux_DnsServiceConfigurationManualInstanceEnumeration(){
   	
  	if (firstElementP!=0)
  	  delete(firstElementP);
  	  	
  };
  
  	  
  void Linux_DnsServiceConfigurationManualInstanceEnumeration::reset(){
  	
  	currentElementP=firstElementP;
  };
  
  	  
  bool Linux_DnsServiceConfigurationManualInstanceEnumeration::hasNext() const{
  	
  	return (currentElementP!=0);
  
  };
  
  int Linux_DnsServiceConfigurationManualInstanceEnumeration::getSize() const{
  	
    int size=0;
    Linux_DnsServiceConfigurationManualInstanceEnumerationElement* followingP=firstElementP;
  	
  	while(followingP!=0){
        followingP=followingP->m_nextP;
        size++;
    }
  	
    return size;
    
  };
  
  const Linux_DnsServiceConfigurationManualInstance&  
   Linux_DnsServiceConfigurationManualInstanceEnumeration::getElement(int pos) const{
   
    Linux_DnsServiceConfigurationManualInstanceEnumerationElement* followingP=firstElementP;
   
    int i=0;
    while((followingP!=0)&&(i<pos)){
        followingP=followingP->m_nextP;
        i++;
    }
    
    return *(followingP->m_elementP);
  };
  
  	  
  const Linux_DnsServiceConfigurationManualInstance&
   Linux_DnsServiceConfigurationManualInstanceEnumeration::getNext() {
   	
  	 Linux_DnsServiceConfigurationManualInstanceEnumerationElement* currentP=
  	  currentElementP;
  	 currentElementP=currentElementP->m_nextP;
  	 
  	 return *(currentP->m_elementP);
  };
  	  
  void Linux_DnsServiceConfigurationManualInstanceEnumeration::addElement
   (const Linux_DnsServiceConfigurationManualInstance& elementP){
   	
  	if(firstElementP==0){
  	  firstElementP=new Linux_DnsServiceConfigurationManualInstanceEnumerationElement();
  	  firstElementP->m_elementP=new Linux_DnsServiceConfigurationManualInstance(elementP);
  	  endElementP=firstElementP;
  	  currentElementP=firstElementP;
  	}else{
  	  endElementP->m_nextP=new Linux_DnsServiceConfigurationManualInstanceEnumerationElement();
  	  endElementP=endElementP->m_nextP;
  	  endElementP->m_elementP=new Linux_DnsServiceConfigurationManualInstance(elementP);
  	}
  };  
}
 

--- NEW FILE: Linux_DnsServiceConfigurationFactory.h ---
 /**
 * Linux_DnsServiceConfigurationFactory.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_DnsServiceConfigurationFactory_h
#define Linux_DnsServiceConfigurationFactory_h


#include "Linux_DnsServiceConfigurationInterface.h"

namespace genProvider{
	
class Linux_DnsServiceConfigurationFactory{
public:

	Linux_DnsServiceConfigurationFactory(){};
	~Linux_DnsServiceConfigurationFactory(){};
	
	static Linux_DnsServiceConfigurationInterface* getImplementation();
};
}
#endif
 

--- NEW FILE: Linux_DnsServiceConfigurationResourceAccess.cpp ---
 /**
 * Linux_DnsServiceConfigurationResourceAccess.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_DnsServiceConfigurationResourceAccess.h"

namespace genProvider {
  
    //Linux_DnsServiceConfigurationResourceAccess::Linux_DnsServiceConfigurationResourceAccess();
    Linux_DnsServiceConfigurationResourceAccess::~Linux_DnsServiceConfigurationResourceAccess() { };
    
    /* intrinsic methods */
    /*
    void Linux_DnsServiceConfigurationResourceAccess::enumInstanceNames(
     const CmpiContext& ctx, const CmpiBroker &mbp, const char *nsp,
     Linux_DnsServiceConfigurationInstanceNameEnumeration& instnames){
      
      int numInstanceNames=1;
      for(int i=0;i<numInstanceNames;i++){
      
        //place here the code retrieving your instanceName
      
        Linux_DnsServiceConfigurationInstanceName instanceName;
        
      }      
    }
    */
  	/*
    void Linux_DnsServiceConfigurationResourceAccess::enumInstances(
     const CmpiContext& ctx,
     const CmpiBroker &mbp,
     const char *nsp,
     const char* *properties,
  	 Linux_DnsServiceConfigurationManualInstanceEnumeration& instances){};
  	*/
  	/*
    Linux_DnsServiceConfigurationManualInstance 
     Linux_DnsServiceConfigurationResourceAccess::getInstance(
     const CmpiContext& ctx,
     const CmpiBroker &mbp,
     const char* *properties,
     const Linux_DnsServiceConfigurationInstanceName&){
      Linux_DnsServiceConfigurationManualInstance instance;
      
    }
  	*/
  	/*
    void Linux_DnsServiceConfigurationResourceAccess::setInstance(
     const CmpiContext& ctx,
     const CmpiBroker &mbp,
     const char* *properties,
     const Linux_DnsServiceConfigurationManualInstance&){};
  	*/
  	/*
    void Linux_DnsServiceConfigurationResourceAccess::createInstance(
     const CmpiContext& ctx, const CmpiBroker &mbp,
     const Linux_DnsServiceConfigurationManualInstance&){};
  	*/
  	/*
    void Linux_DnsServiceConfigurationResourceAccess::deleteInstance(
     const CmpiContext& ctx, const CmpiBroker &mbp,
     const Linux_DnsServiceConfigurationInstanceName&){};
	*/
    
    /* Association Interface */
    
    void Linux_DnsServiceConfigurationResourceAccess::referencesElement( 
     const CmpiContext& ctx,  
     const CmpiBroker &mbp,
     const char *nsp,
     const char** properties,
     const Linux_DnsConfigurationInstanceName& sourceInst,
     Linux_DnsServiceConfigurationManualInstanceEnumeration& instEnum) {

     	Linux_DnsServiceInstanceName serviceInstanceName;
	
       	serviceInstanceName.setNamespace(nsp);
       	serviceInstanceName.setName(DEFAULT_SERVICE_NAME);
        serviceInstanceName.setSystemCreationClassName(DEFAULT_SYSTEM_CREATION_CLASS_NAME);
        serviceInstanceName.setSystemName(DEFAULT_SYSTEM_NAME);
        serviceInstanceName.setCreationClassName(DEFAULT_CREATION_CLASS_NAME);

	Linux_DnsServiceConfigurationManualInstance aManualInstance;
	Linux_DnsServiceConfigurationInstanceName instanceName;
	instanceName.setNamespace( nsp );	
	instanceName.setElement( serviceInstanceName );
	instanceName.setConfiguration( sourceInst );
	
	aManualInstance.setInstanceName(instanceName);

        instEnum.addElement(aManualInstance);
     };


    void Linux_DnsServiceConfigurationResourceAccess::referencesConfiguration( 
     const CmpiContext& ctx,  
     const CmpiBroker &mbp,
     const char *nsp,
     const char** properties,
     const Linux_DnsServiceInstanceName& sourceInst,
     Linux_DnsServiceConfigurationManualInstanceEnumeration& instEnum) {
	
	Linux_DnsConfigurationInstanceName confInstanceName;
        confInstanceName.setNamespace(nsp);
        confInstanceName.setName(DEFAULT_SERVICE_NAME);
	
	Linux_DnsServiceConfigurationManualInstance aManualInstance;
	Linux_DnsServiceConfigurationInstanceName instanceName;
	instanceName.setNamespace( nsp );
	instanceName.setElement( sourceInst );
	instanceName.setConfiguration( confInstanceName );
	
	aManualInstance.setInstanceName(instanceName);

        instEnum.addElement(aManualInstance);

     };
    
    void Linux_DnsServiceConfigurationResourceAccess::associatorsElement( 
     const CmpiContext& ctx,  
     const CmpiBroker &mbp,
     const char *nsp,
     const char** properties,
     const Linux_DnsConfigurationInstanceName& sourceInst,
     Linux_DnsServiceInstanceEnumeration& instEnum) {
     	Linux_DnsServiceInstance inst;
	Linux_DnsServiceInstanceName instanceName;
	
       	instanceName.setNamespace(nsp);
       	instanceName.setName(DEFAULT_SERVICE_NAME);
        instanceName.setSystemCreationClassName(DEFAULT_SYSTEM_CREATION_CLASS_NAME);
        instanceName.setSystemName(DEFAULT_SYSTEM_NAME);
        instanceName.setCreationClassName(DEFAULT_CREATION_CLASS_NAME);
	inst.setInstanceName(instanceName);
	
	instEnum.addElement(inst); 
     };
     
    void Linux_DnsServiceConfigurationResourceAccess::associatorsConfiguration( 
     const CmpiContext& ctx,  
     const CmpiBroker &mbp,
     const char *nsp,
     const char** properties,
     const Linux_DnsServiceInstanceName& sourceInst,
     Linux_DnsConfigurationInstanceEnumeration& instEnum) {
	Linux_DnsConfigurationInstanceName instanceName;
	Linux_DnsConfigurationInstance aManualInstance;

        instanceName.setNamespace(nsp);
        instanceName.setName(DEFAULT_SERVICE_NAME);
	
	aManualInstance.setInstanceName(instanceName);
	aManualInstance.setConfigurationFile(DEFAULT_CONFIGURATION_FILE);

        instEnum.addElement(aManualInstance);
     };
    
     
    /* extrinsic methods */
	
}



--- NEW FILE: Linux_DnsServiceConfigurationInstance.cpp ---
 /**
 * Linux_DnsServiceConfigurationInstance.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_DnsServiceConfigurationInstance.h"
#include "CmpiData.h"
#include "CmpiString.h"
#include "CmpiArray.h"
#include <string>

namespace genProvider {

  //*********************************************************
  //Linux_DnsServiceConfigurationInstance
  //*********************************************************

  //empty constructor
  Linux_DnsServiceConfigurationInstance::
   Linux_DnsServiceConfigurationInstance(){   	
   	init();  	   	
  };
  
  
  //copy constructor	
  Linux_DnsServiceConfigurationInstance::
   Linux_DnsServiceConfigurationInstance
   (const Linux_DnsServiceConfigurationInstance& original){   	
   	init(original);  	   	
  };
  
  
  //constructor using CmpiInstance
  Linux_DnsServiceConfigurationInstance::
   Linux_DnsServiceConfigurationInstance (const CmpiInstance& inst, const char* instanceNamespace){
    CmpiData cmpiData;
    init(); 
    
    CmpiObjectPath cop=inst.getObjectPath();
    cop.setNameSpace(instanceNamespace);
    setInstanceName(Linux_DnsServiceConfigurationInstanceName(cop));
    
  }
  
  
  //Destructor
  Linux_DnsServiceConfigurationInstance::
   ~Linux_DnsServiceConfigurationInstance(){
   	reset();  	  
  };
  
  
  //copy operator
  Linux_DnsServiceConfigurationInstance&
   Linux_DnsServiceConfigurationInstance::operator=
   (const Linux_DnsServiceConfigurationInstance& original){   	
   	init(original);
   	return *this;
  };
  
  
  //converts to CmpiInstance
  CmpiInstance Linux_DnsServiceConfigurationInstance::
   getCmpiInstance(const char** properties) const{
   	
   	CmpiObjectPath objectPath=getInstanceName().getObjectPath();      
    CmpiInstance cmpiInstance(objectPath);    
    getInstanceName().fillKeys(cmpiInstance);
    
    if (properties) {
	  cmpiInstance.setPropertyFilter(properties,0);
    }
  	
  	return cmpiInstance;
  	
  }
  
  
  //InstanceName related methods
  unsigned int Linux_DnsServiceConfigurationInstance::
   isInstanceNameSet() const{
  	return isSet.instanceName;
  }
  
  const Linux_DnsServiceConfigurationInstanceName&
    Linux_DnsServiceConfigurationInstance::getInstanceName() const{

    if(!isSet.instanceName)
   	  throw CmpiErrorFormater::getErrorException(
   	   CmpiErrorFormater::NOT_SET,
   	   "InstanceName not set in Linux_DnsServiceConfiguration instance");
  		
   	return m_instanceName;
  }

  void Linux_DnsServiceConfigurationInstance::setInstanceName(
   const Linux_DnsServiceConfigurationInstanceName& val){
    m_instanceName = val;
    isSet.instanceName=1;
  }


  
  //set isSet attributes to FALSE
  void Linux_DnsServiceConfigurationInstance::init(){
   	isSet.instanceName=0;
   	  	
  };
  
  
  //copies another instance properties in this
  void Linux_DnsServiceConfigurationInstance::init
   (const Linux_DnsServiceConfigurationInstance& original){   	
   	init();
   	   	
    if(original.isInstanceNameSet()){
      setInstanceName(original.getInstanceName());
    }    
   }
  
  
  //reset the instance data
  void Linux_DnsServiceConfigurationInstance::reset(){
   	
  	  
  };
  
  
  //*********************************************************
  //Linux_DnsServiceConfigurationInstanceEnumerationElement	
  //*********************************************************
  
  Linux_DnsServiceConfigurationInstanceEnumerationElement::
   Linux_DnsServiceConfigurationInstanceEnumerationElement(){
   	
  	m_elementP=0;
  	m_nextP=0;
  	  
  };
  
  
  Linux_DnsServiceConfigurationInstanceEnumerationElement::
   ~Linux_DnsServiceConfigurationInstanceEnumerationElement(){
   	
  	if (m_elementP!=0)
  	  delete(m_elementP);
  	if (m_nextP!=0)
  	  delete(m_nextP);
  	  
  };

  
  //*********************************************************
  //Linux_DnsServiceConfigurationInstanceNameEnumeration
  //*********************************************************

  Linux_DnsServiceConfigurationInstanceEnumeration::
   Linux_DnsServiceConfigurationInstanceEnumeration(){
   	
  	 firstElementP=0;
     currentElementP=0;
     endElementP=0;
  };
  
  Linux_DnsServiceConfigurationInstanceEnumeration::
   Linux_DnsServiceConfigurationInstanceEnumeration(
   const Linux_DnsServiceConfigurationInstanceEnumeration& original){
   	
     firstElementP=0;
     currentElementP=0;
     endElementP=0;
  	 
     int size=original.getSize();
     for(int i=0;i<size;i++)
       addElement(original.getElement(i));           
  };
  
  	  
  Linux_DnsServiceConfigurationInstanceEnumeration::
   ~Linux_DnsServiceConfigurationInstanceEnumeration(){
   	
  	if (firstElementP!=0)
  	  delete(firstElementP);
  	  	
  };
  
  	  
  void Linux_DnsServiceConfigurationInstanceEnumeration::reset(){
  	
  	currentElementP=firstElementP;
  };
  
  	  
  bool Linux_DnsServiceConfigurationInstanceEnumeration::hasNext() const{
  	
  	return (currentElementP!=0);
  
  };
  
  int Linux_DnsServiceConfigurationInstanceEnumeration::getSize() const{
  	
    int size=0;
    Linux_DnsServiceConfigurationInstanceEnumerationElement* followingP=firstElementP;
  	
  	while(followingP!=0){
        followingP=followingP->m_nextP;
        size++;
    }
  	
    return size;
    
  };
  
  const Linux_DnsServiceConfigurationInstance&  
   Linux_DnsServiceConfigurationInstanceEnumeration::getElement(int pos) const{
   
    Linux_DnsServiceConfigurationInstanceEnumerationElement* followingP=firstElementP;
   
    int i=0;
    while((followingP!=0)&&(i<pos)){
        followingP=followingP->m_nextP;
        i++;
    }
    
    return *(followingP->m_elementP);
  };
  
  	  
  const Linux_DnsServiceConfigurationInstance&
   Linux_DnsServiceConfigurationInstanceEnumeration::getNext() {
   	
  	 Linux_DnsServiceConfigurationInstanceEnumerationElement* currentP=
  	  currentElementP;
  	 currentElementP=currentElementP->m_nextP;
  	 
  	 return *(currentP->m_elementP);
  };
  	  
  void Linux_DnsServiceConfigurationInstanceEnumeration::addElement
   (const Linux_DnsServiceConfigurationInstance& elementP){
   	
  	if(firstElementP==0){
  	  firstElementP=new Linux_DnsServiceConfigurationInstanceEnumerationElement();
  	  firstElementP->m_elementP=new Linux_DnsServiceConfigurationInstance(elementP);
  	  endElementP=firstElementP;
  	  currentElementP=firstElementP;
  	}else{
  	  endElementP->m_nextP=new Linux_DnsServiceConfigurationInstanceEnumerationElement();
  	  endElementP=endElementP->m_nextP;
  	  endElementP->m_elementP=new Linux_DnsServiceConfigurationInstance(elementP);
  	}
  };  
}
 

--- NEW FILE: Linux_DnsServiceConfigurationDefaultImplementation.cpp ---
 /**
 * Linux_DnsServiceConfigurationDefaultImplementation.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_DnsServiceConfigurationDefaultImplementation.h"
#include <iostream>

using namespace std;

namespace genProvider {

  /* intrinsic methods */
  void Linux_DnsServiceConfigurationDefaultImplementation::enumInstanceNames(
   const CmpiContext& ctx, const CmpiBroker &mbp, const char *nsp,
   Linux_DnsServiceConfigurationInstanceNameEnumeration& instnames){
   	cout<<"enumInstances not supported for Linux_DnsServiceConfiguration"<<endl;
   	throw CmpiErrorFormater::getErrorException(
   	 CmpiErrorFormater::NOT_IMPLEMENTED,
   	 "enumInstances not implemented for Linux_DnsServiceConfiguration");   
  }
  	
  void Linux_DnsServiceConfigurationDefaultImplementation::enumInstances(
   const CmpiContext& ctx,
   const CmpiBroker &mbp,
   const char *nsp,
   const char* *properties,
   Linux_DnsServiceConfigurationManualInstanceEnumeration& instances){
    
    cout<<"Using default enumInstances implementation for Linux_DnsServiceConfiguration"<<endl;
    cout<<"LetŽs get the instanceNames"<<endl;
    Linux_DnsServiceConfigurationInstanceNameEnumeration namesEnumeration;
    enumInstanceNames(ctx, mbp,nsp,namesEnumeration);
    cout<<"Getting each instance"<<endl;
    while(namesEnumeration.hasNext()){
      Linux_DnsServiceConfigurationInstanceName name=
    	  namesEnumeration.getNext();
    	cout<<"Getting an instance for instanceName"<<endl;
    	Linux_DnsServiceConfigurationManualInstance instance=
    	  getInstance(ctx, mbp, properties, name);
    	cout<<"adding instance to enum"<<endl;
    	instances.addElement(instance);
    	cout<<"Added!"<<endl;
    };
  }
  	
  Linux_DnsServiceConfigurationManualInstance 
   Linux_DnsServiceConfigurationDefaultImplementation::getInstance(
   const CmpiContext& ctx,
   const CmpiBroker &mbp,
   const char* *properties,
   const Linux_DnsServiceConfigurationInstanceName&){
    cout<<"getInstance not supported for Linux_DnsServiceConfiguration"<<endl;
    throw CmpiErrorFormater::getErrorException(
   	 CmpiErrorFormater::NOT_IMPLEMENTED,
   	 "getInstance not implemented for Linux_DnsServiceConfiguration");
  }
  	
  void Linux_DnsServiceConfigurationDefaultImplementation::setInstance(
   const CmpiContext& ctx,
   const CmpiBroker &mbp,
   const char* *properties,
   const Linux_DnsServiceConfigurationManualInstance&){
   	cout<<"setInstance not supported for Linux_DnsServiceConfiguration"<<endl;
     throw CmpiErrorFormater::getErrorException(
   	 CmpiErrorFormater::NOT_IMPLEMENTED,
   	 "setInstance not implemented for Linux_DnsServiceConfiguration");
  }
  	
  void Linux_DnsServiceConfigurationDefaultImplementation::
   createInstance(const CmpiContext& ctx, const CmpiBroker &mbp,
   const Linux_DnsServiceConfigurationManualInstance&){
   	cout<<"createInstance not supported for Linux_DnsServiceConfiguration"<<endl;
    throw CmpiErrorFormater::getErrorException(
   	 CmpiErrorFormater::NOT_IMPLEMENTED,
   	 "createInstance not implemented for Linux_DnsServiceConfiguration");
  }
  	
  void Linux_DnsServiceConfigurationDefaultImplementation::
   deleteInstance(const CmpiContext& ctx, const CmpiBroker &mbp,
   const Linux_DnsServiceConfigurationInstanceName&){
   	cout<<"deleteInstance not supported for Linux_DnsServiceConfiguration"<<endl;
    throw CmpiErrorFormater::getErrorException(
   	 CmpiErrorFormater::NOT_IMPLEMENTED,
   	 "deleteInstance not implemented for Linux_DnsServiceConfiguration");
  }
	
  
    /* Association Interface */

    void Linux_DnsServiceConfigurationDefaultImplementation::
     referencesElement( 
     const CmpiContext& ctx,  
     const CmpiBroker &mbp,
     const char *nsp,
     const char** properties,
     const Linux_DnsConfigurationInstanceName& sourceInst,
     Linux_DnsServiceConfigurationManualInstanceEnumeration& instances){
      throw CmpiErrorFormater::getErrorException(
   	   CmpiErrorFormater::NOT_IMPLEMENTED,
   	   "getElementReferences between Linux_DnsService and Linux_DnsConfiguration not implemented for Linux_DnsServiceConfiguration");
    }

    void Linux_DnsServiceConfigurationDefaultImplementation::
     referencesConfiguration( 
     const CmpiContext& ctx,  
     const CmpiBroker &mbp,
     const char *nsp,
     const char** properties,
     const Linux_DnsServiceInstanceName& sourceInst,
     Linux_DnsServiceConfigurationManualInstanceEnumeration& instances){
      throw CmpiErrorFormater::getErrorException(
   	   CmpiErrorFormater::NOT_IMPLEMENTED,
   	   "getConfigurationReferences between Linux_DnsService and Linux_DnsConfiguration not implemented for Linux_DnsServiceConfiguration");
    }

    void Linux_DnsServiceConfigurationDefaultImplementation::
     associatorsElement( 
     const CmpiContext& ctx,  
     const CmpiBroker &mbp,
     const char *nsp,
     const char** properties,
     const Linux_DnsConfigurationInstanceName& sourceInst,
     Linux_DnsServiceInstanceEnumeration& instances){
      
      std::cout<<"Linux_DnsServiceConfiguration : associatorsLinux_DnsService() ... returns one instance"<<std::endl;
      
      Linux_DnsServiceConfigurationManualInstanceEnumeration enumeration;
      
      referencesElement(ctx, mbp, sourceInst.getNamespace(), 
       properties, sourceInst, enumeration);

      Linux_DnsServiceExternal external(mbp, ctx);

      while(enumeration.hasNext()) {
        const Linux_DnsServiceConfigurationManualInstance instance =
	     enumeration.getNext();
	     
        const Linux_DnsServiceConfigurationInstanceName instanceName = 
         instance.getInstanceName();
         
        const Linux_DnsServiceInstanceName Element = 
         instanceName.getElement();
         
        Linux_DnsServiceInstance inst = external.getInstance(properties,Element);
        
        instances.addElement(inst);
      }
    }

    void Linux_DnsServiceConfigurationDefaultImplementation::
     associatorsConfiguration( 
     const CmpiContext& ctx,  
     const CmpiBroker &mbp,
     const char *nsp,
     const char** properties,
     const Linux_DnsServiceInstanceName& sourceInst,
     Linux_DnsConfigurationInstanceEnumeration& instances){
     
      std::cout<<"Linux_DnsServiceConfiguration : associatorsLinux_DnsConfiguration() ... returns one instance"<<std::endl;
      
      Linux_DnsServiceConfigurationManualInstanceEnumeration enumeration;
      
      referencesConfiguration(ctx, mbp, sourceInst.getNamespace(), 
       properties, sourceInst, enumeration);

      Linux_DnsConfigurationExternal external(mbp, ctx);

      while(enumeration.hasNext()) {
        const Linux_DnsServiceConfigurationManualInstance instance =
	     enumeration.getNext();
	     
        const Linux_DnsServiceConfigurationInstanceName instanceName = 
         instance.getInstanceName();
         
        const Linux_DnsConfigurationInstanceName Configuration = 
         instanceName.getConfiguration();
         
        Linux_DnsConfigurationInstance inst = external.getInstance(properties,Configuration);
        
        instances.addElement(inst);
      }
    }

   
  /* extrinsic methods */
	
}


--- NEW FILE: makefile ---
include ../setting.cmpi
include setting.provider

CPPFLAGS=$(CPPFLAGS.provider) -I. -I$(CIMOMINC) -I$(COMMONINC) -I$(CIMOMINC)/cpp -I../Linux_DnsService -I../CIM_ConcreteJob -I../Linux_DnsConfiguration -D_COMPILE_UNIX -DCMPI_STANDALONE

CXXFLAGS=-Wall -g -fPIC -fno-implicit-templates
LDFLAGS=-L. -L$(COMMONLIB) -L$(COMMONLIB_OUT) -shared -lLinux_DnsServiceSupport -lLinux_DnsConfigurationSupport -lcmpiCppImpl -lIBM_ProviderTooling

OBJECTS=Linux_DnsServiceConfigurationInstanceName.o \
        Linux_DnsServiceConfigurationInstance.o \
        Linux_DnsServiceConfigurationExternal.o \
        Linux_DnsServiceConfigurationRepositoryInstance.o \
        Linux_DnsServiceConfigurationRepositoryExternal.o \
        Linux_DnsServiceConfigurationManualInstance.o \
        Linux_DnsServiceConfigurationDefaultImplementation.o

FAKEFACTORY= Linux_DnsServiceConfigurationFakeFactory.o

NORMALFACTORY= Linux_DnsServiceConfigurationFactory.o

RESOURCEOBJECT= Linux_DnsServiceConfigurationResourceAccess.o

PROVIDEROBJECT=CmpiLinux_DnsServiceConfigurationProvider.o 

all: testfiles preinstall install

buildall: clean all

#------------------------------------------------------------------------------#

compile: $(OBJECTS) $(FAKEFACTORY) $(NORMALFACTORY) $(RESOURCEOBJECT) $(PROVIDEROBJECT)

#------------------------------------------------------------------------------#

prelink: $(OBJECTS) $(FAKEFACTORY)
	$(LINK.cpp) -o libLinux_DnsServiceConfigurationSupport.so $^
	
link: deleteFakeLib \
      libLinux_DnsServiceConfigurationSupport.so \
      libLinux_DnsServiceConfiguration.so

libLinux_DnsServiceConfigurationSupport.so: LDFLAGS+=$(LDFLAGS.provider)
libLinux_DnsServiceConfigurationSupport.so: $(OBJECTS) $(NORMALFACTORY) $(RESOURCEOBJECT) $(PROVIDEROBJECT)
	$(LINK.cpp) -o $@ $^

libLinux_DnsServiceConfiguration.so: LDFLAGS+=-lLinux_DnsServiceConfigurationSupport
libLinux_DnsServiceConfiguration.so: $(PROVIDEROBJECT)
	$(LINK.cpp) -o $@ $^

deleteFakeLib:
	$(RM) *.so

#------------------------------------------------------------------------------#

preinstall: prelink
	install libLinux_DnsServiceConfigurationSupport.so $(COMMONLIB_OUT)

#------------------------------------------------------------------------------#

install: link
	install libLinux_DnsServiceConfigurationSupport.so $(COMMONLIB_OUT)	
	install libLinux_DnsServiceConfiguration.so $(CIMOMLIB_OUT)
#	install -m 644 Linux_DnsServiceConfiguration*.h $(COMMONINC)
	$(MAKE) -C mof -f $(MOFMAKEFILE) install

#------------------------------------------------------------------------------#

testfiles:	
	@[ -d $(CIMOMLIB) ] || ( echo directory $(CIMOMLIB) does not exist && false)
	@[ -d $(CIMOMINC) ] || ( echo directory $(CIMOMINC) does not exist - please create manually && false)
	@[ -d $(CIMOMMOF) ] || ( echo directory $(CIMOMMOF) does not exist - please create manually && false)
	@[ -d $(COMMONINC) ] || ( echo directory $(COMMONINC) does not exist - please create manually && false)
	@[ -d $(COMMONLIB) ] || ( echo directory $(COMMONLIB) does not exist - please create manually && false)

#------------------------------------------------------------------------------#

clean:
	$(RM) *.so *.o *~

#------------------------------------------------------------------------------#

uninstall: 
	$(MAKE) -C mof -f $(MOFMAKEFILE) uninstall;
#	$(RM) $(COMMONINC)/Linux_DnsServiceConfiguration*.h \
	$(RM) $(COMMONLIB)/libLinux_DnsServiceConfigurationSupport.so \
	$(RM) $(CIMOMLIB)/libLinux_DnsServiceConfiguration.so

--- NEW FILE: Linux_DnsServiceConfigurationInterface.h ---
 /**
 * Linux_DnsServiceConfigurationInterface.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_DnsServiceConfigurationInterface_h
#define Linux_DnsServiceConfigurationInterface_h

#include "Linux_DnsServiceConfigurationInstanceName.h"
#include "Linux_DnsServiceConfigurationManualInstance.h"
#include "CmpiObjectPath.h"
#include "CmpiInstance.h"
#include "CmpiDateTime.h"
#include "CmpiBroker.h"
#include "Linux_DnsServiceInstance.h"
#include "Linux_DnsConfigurationInstance.h"
#include "Linux_DnsServiceExternal.h"
#include "Linux_DnsConfigurationExternal.h"

namespace genProvider {

  class Linux_DnsServiceConfigurationInterface {
  	
    public:    
    virtual ~Linux_DnsServiceConfigurationInterface() { };
    
    /* intrinsic methods */
    virtual void enumInstanceNames(
     const CmpiContext& ctx,
     const CmpiBroker &mbp,
     const char *nsp,
     Linux_DnsServiceConfigurationInstanceNameEnumeration& instnames) = 0;
  	
    virtual void enumInstances(
     const CmpiContext& ctx,
     const CmpiBroker &mbp,
     const char *nsp,
     const char* *properties,
  	 Linux_DnsServiceConfigurationManualInstanceEnumeration& instances) = 0;
  	
    virtual Linux_DnsServiceConfigurationManualInstance getInstance(
     const CmpiContext& ctx,
     const CmpiBroker &mbp,
     const char* *properties,
     const Linux_DnsServiceConfigurationInstanceName&) = 0;
  	
    virtual void setInstance(
     const CmpiContext& ctx,
     const CmpiBroker &mbp,
     const char* *properties,
     const Linux_DnsServiceConfigurationManualInstance&) = 0;
  	
    virtual void createInstance(
     const CmpiContext& ctx,
     const CmpiBroker &mbp,
     const Linux_DnsServiceConfigurationManualInstance&) = 0;
  	
    virtual void deleteInstance(
     const CmpiContext& ctx,
     const CmpiBroker &mbp,
     const Linux_DnsServiceConfigura...
 
[truncated message content]