[Sblim-commit] cmpi-dns/provider/Linux_DnsSetting Linux_DnsSettingExternal.cpp,NONE,1.1 Linux_DnsSettingDefaultImplementation.cpp,NONE,1.1 Linux_DnsSettingManualInstance.cpp,NONE,1.1 Linux_DnsSettingFactory.h,NONE,1.1 Linux_DnsSettingResourceAccess.cpp,NONE,1.1 Linux_DnsSettingRepositoryInstance.h,NONE,1.1 Linux_DnsSettingInstance.h,NONE,1.1 Linux_DnsSettingInterface.h,NONE,1.1 Linux_DnsSettingManualInstance.h,NONE,1.1 Linux_DnsSettingInstanceName.h,NONE,1.1 Linux_DnsSettingInstanceName.cpp,NONE,1.1 Linux_DnsSettingRepositoryInstance.cpp,NONE,1.1 Linux_DnsSettingDefaultImplementation.h,NONE,1.1 setting.provider,NONE,1.1 Linux_DnsSettingRepositoryExternal.h,NONE,1.1 Linux_DnsSettingExternal.h,NONE,1.1 Linux_DnsSettingRepositoryExternal.cpp,NONE,1.1 CmpiLinux_DnsSettingProvider.cpp,NONE,1.1 makefile,NONE,1.1 Linux_DnsSettingInstance.cpp,NONE,1.1 Linux_DnsSettingResourceAccess.h,NONE,1.1 CmpiLinux_DnsSettingProvider.h,NONE,1.1 Linux_DnsSettingFakeFactory.cpp,NONE,1.1 Linux_DnsSettingFactory.cpp,NONE,1.1

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

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

Added Files:
	Linux_DnsSettingExternal.cpp 
	Linux_DnsSettingDefaultImplementation.cpp 
	Linux_DnsSettingManualInstance.cpp Linux_DnsSettingFactory.h 
	Linux_DnsSettingResourceAccess.cpp 
	Linux_DnsSettingRepositoryInstance.h 
	Linux_DnsSettingInstance.h Linux_DnsSettingInterface.h 
	Linux_DnsSettingManualInstance.h 
	Linux_DnsSettingInstanceName.h 
	Linux_DnsSettingInstanceName.cpp 
	Linux_DnsSettingRepositoryInstance.cpp 
	Linux_DnsSettingDefaultImplementation.h setting.provider 
	Linux_DnsSettingRepositoryExternal.h 
	Linux_DnsSettingExternal.h 
	Linux_DnsSettingRepositoryExternal.cpp 
	CmpiLinux_DnsSettingProvider.cpp makefile 
	Linux_DnsSettingInstance.cpp Linux_DnsSettingResourceAccess.h 
	CmpiLinux_DnsSettingProvider.h Linux_DnsSettingFakeFactory.cpp 
	Linux_DnsSettingFactory.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=-ldnssupport


--- NEW FILE: Linux_DnsSettingManualInstance.h ---
 /**
 * Linux_DnsSettingManualInstance.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_DnsSettingManualInstance_h
#define Linux_DnsSettingManualInstance_h

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

#include "Linux_DnsSettingInstanceName.h"

namespace genProvider {

  class Linux_DnsSettingManualInstance {
  public:
       Linux_DnsSettingManualInstance();
  	
       Linux_DnsSettingManualInstance
  	    (const Linux_DnsSettingManualInstance& original);
  	   
       Linux_DnsSettingManualInstance
        (const CmpiInstance& inst, const char* instanceNamespace);
  	 
       ~Linux_DnsSettingManualInstance();
       
       Linux_DnsSettingManualInstance& operator=
  	    (const Linux_DnsSettingManualInstance& original);
       
       CmpiInstance getCmpiInstance(const char** properties=0) const;
       
       unsigned int isInstanceNameSet() const;
       void setInstanceName(
        const Linux_DnsSettingInstanceName& val);        
       const Linux_DnsSettingInstanceName&
        getInstanceName() const;

       unsigned int isConfigurationDirectorySet() const;
       void setConfigurationDirectory(const char* val, int makeCopy = 1);
       const char* getConfigurationDirectory() const;

       unsigned int isForwardSet() const;
       void setForward(const CMPIUint16 val);
       const CMPIUint16 getForward() const;

       unsigned int isForwardersSet() const;
       void setForwarders(const char** val, unsigned const int size, int makeCopy = 1);
       const char** getForwarders(unsigned int& size) const;

       unsigned int isPortNumberSet() const;
       void setPortNumber(const CMPIUint32 val);
       const CMPIUint32 getPortNumber() const;

       unsigned int isTSIGSet() const;
       void setTSIG(const CMPIUint16 val);
       const CMPIUint16 getTSIG() const;

       unsigned int isTTLSet() const;
       void setTTL(const CMPIUint32 val);
       const CMPIUint32 getTTL() const;

       unsigned int isXferFormatSet() const;
       void setXferFormat(const CMPIUint16 val);
       const CMPIUint16 getXferFormat() const;
       
  private:
       void init();
       void init(const Linux_DnsSettingManualInstance& original);
       void reset();
       
       Linux_DnsSettingInstanceName m_instanceName;
       const char* m_ConfigurationDirectory;
       CMPIUint16 m_Forward;
       const char** m_Forwarders;
        unsigned int ForwardersArraySize;
       CMPIUint32 m_PortNumber;
       CMPIUint16 m_TSIG;
       CMPIUint32 m_TTL;
       CMPIUint16 m_XferFormat;
       
       struct isSetType{
       	 unsigned int instanceName:1;
         unsigned int ConfigurationDirectory:1;
         unsigned int Forward:1;
         unsigned int Forwarders:1;
         unsigned int PortNumber:1;
         unsigned int TSIG:1;
         unsigned int TTL:1;
         unsigned int XferFormat:1;
       } isSet;
  };
  
  
  struct Linux_DnsSettingManualInstanceEnumerationElement{
  	Linux_DnsSettingManualInstance* m_elementP;
  	Linux_DnsSettingManualInstanceEnumerationElement* m_nextP;
  	
  	Linux_DnsSettingManualInstanceEnumerationElement();
  	~Linux_DnsSettingManualInstanceEnumerationElement();  	
  };
  

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


--- NEW FILE: Linux_DnsSettingInstanceName.h ---
 /**
 * Linux_DnsSettingInstanceName.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_DnsSettingInstanceName_h
#define Linux_DnsSettingInstanceName_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"

namespace genProvider {

  class Linux_DnsSettingInstanceName {
  public:
       Linux_DnsSettingInstanceName();
  	
       Linux_DnsSettingInstanceName
  	    (const Linux_DnsSettingInstanceName& original);
  	   
       Linux_DnsSettingInstanceName
        (const CmpiObjectPath& path);
  	 
       ~Linux_DnsSettingInstanceName();
       
       Linux_DnsSettingInstanceName& operator=
  	    (const Linux_DnsSettingInstanceName& 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 isNameSet() const;
       void setName(const char* val, int makeCopy = 1);
       const char* getName() const;
       
  private:
       void init();
       void init(const Linux_DnsSettingInstanceName& original);
       void reset();
       
       const char* m_CIMClassNameP;
       const char* m_namespace;
       const char* m_Name;
       
       struct isSetType{
       	 unsigned int m_namespace:1;
         unsigned int Name:1;
       } isSet;
  };
  
  
  struct Linux_DnsSettingInstanceNameEnumerationElement{
  	Linux_DnsSettingInstanceName* m_elementP;
  	Linux_DnsSettingInstanceNameEnumerationElement* m_nextP;
  	
  	Linux_DnsSettingInstanceNameEnumerationElement();
  	~Linux_DnsSettingInstanceNameEnumerationElement();  	
  };
  

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


--- NEW FILE: Linux_DnsSettingExternal.h ---
 /**
 * Linux_DnsSettingExternal.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_DnsSettingExternal_h
#define Linux_DnsSettingExternal_h

#include "Linux_DnsSettingInstance.h"
#include "CmpiBroker.h"

namespace genProvider {

  class Linux_DnsSettingExternal {
  	
    public:
    Linux_DnsSettingExternal(
     const CmpiBroker& brkr, const CmpiContext& ctx);
    virtual ~Linux_DnsSettingExternal();
    
    virtual void enumInstanceNames(
     const char *nsp,
     Linux_DnsSettingInstanceNameEnumeration&);
     
    virtual void enumInstances(
     const char *nsp,
     const char* *properties,
     Linux_DnsSettingInstanceEnumeration&);
     
    virtual Linux_DnsSettingInstance getInstance(
     const char* *properties,
     const Linux_DnsSettingInstanceName&);
     
    virtual void setInstance(
     const char* *properties,
     const Linux_DnsSettingInstance&);
     
    virtual void createInstance(
     const Linux_DnsSettingInstance&);
     
    virtual void deleteInstance(
     const Linux_DnsSettingInstanceName&);
     
    private:
    CmpiBroker  broker;
    CmpiContext context;
  };
}
#endif

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

namespace genProvider{
	
  Linux_DnsSettingExternal::Linux_DnsSettingExternal(
   const CmpiBroker& brkr, const CmpiContext& ctx ) 
   : broker(brkr), context(ctx) {};
   
  Linux_DnsSettingExternal::
   ~Linux_DnsSettingExternal(){};
    
  void Linux_DnsSettingExternal::enumInstanceNames(
   const char *nsp,
   Linux_DnsSettingInstanceNameEnumeration& instnames) {

    CmpiObjectPath op(nsp,"Linux_DnsSetting");
    CmpiEnumeration en=broker.enumInstanceNames(context,op);
    while(en.hasNext()) {
      CmpiObjectPath opi = en.getNext();
      Linux_DnsSettingInstanceName iname(opi);
      instnames.addElement(iname);
    }
  };
  	  
  void Linux_DnsSettingExternal::enumInstances(
   const char *nsp,
   const char* *properties,
   Linux_DnsSettingInstanceEnumeration& instances) {
   		
    CmpiObjectPath op(nsp,"Linux_DnsSetting");
    CmpiEnumeration en=broker.enumInstances(context,op,properties);
    while(en.hasNext()) {
      CmpiInstance inst = en.getNext();
      Linux_DnsSettingInstance instance(inst,nsp);
      instances.addElement(instance);
    }
  };
  	  
  Linux_DnsSettingInstance
   Linux_DnsSettingExternal::getInstance(
   const char* *properties,
   const Linux_DnsSettingInstanceName& instanceName) {
    
    CmpiObjectPath op=instanceName.getObjectPath();
    CmpiInstance inst=broker.getInstance(context,op,properties);
    return Linux_DnsSettingInstance(inst,instanceName.getNamespace());
  }
      
  void Linux_DnsSettingExternal::setInstance(
   const char* *properties,
   const Linux_DnsSettingInstance& instance){
  
    CmpiObjectPath op=instance.getInstanceName().getObjectPath();
    CmpiInstance inst=instance.getCmpiInstance();
    broker.setInstance(context,op,inst,properties);
  }
      
  void Linux_DnsSettingExternal::createInstance(
   const Linux_DnsSettingInstance& instance){
  
    CmpiObjectPath op=instance.getInstanceName().getObjectPath();
    CmpiInstance inst=instance.getCmpiInstance();
    broker.createInstance(context,op,inst);
  }
  
  void Linux_DnsSettingExternal::deleteInstance(
   const Linux_DnsSettingInstanceName& instanceName){
    
    CmpiObjectPath op=instanceName.getObjectPath();
    broker.deleteInstance(context,op);
  }
    
}

--- NEW FILE: Linux_DnsSettingRepositoryInstance.h ---
 /**
 * Linux_DnsSettingRepositoryInstance.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_DnsSettingRepositoryInstance_h
#define Linux_DnsSettingRepositoryInstance_h

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

#include "Linux_DnsSettingInstanceName.h"

namespace genProvider {

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

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


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

CPPFLAGS=$(CPPFLAGS.provider) -I. -I$(CIMOMINC) -I$(COMMONINC) -I$(CIMOMINC)/cpp -I../CIM_CollectionOfMSEs -I../CIM_ManagedSystemElement -D_COMPILE_UNIX -DCMPI_STANDALONE

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

OBJECTS=Linux_DnsSettingInstanceName.o \
        Linux_DnsSettingInstance.o \
        Linux_DnsSettingExternal.o \
        Linux_DnsSettingRepositoryInstance.o \
        Linux_DnsSettingRepositoryExternal.o \
        Linux_DnsSettingManualInstance.o \
        Linux_DnsSettingDefaultImplementation.o

FAKEFACTORY= Linux_DnsSettingFakeFactory.o

NORMALFACTORY= Linux_DnsSettingFactory.o

RESOURCEOBJECT= Linux_DnsSettingResourceAccess.o

PROVIDEROBJECT=CmpiLinux_DnsSettingProvider.o 

all: testfiles preinstall install

buildall: clean all

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

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

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

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

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

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

deleteFakeLib:
	$(RM) *.so

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

preinstall: prelink
	install libLinux_DnsSettingSupport.so $(COMMONLIB_OUT)

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

install: link
	install libLinux_DnsSettingSupport.so $(COMMONLIB_OUT)	
	install libLinux_DnsSetting.so $(CIMOMLIB_OUT)
#	install -m 644 Linux_DnsSetting*.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_DnsSetting*.h \
	$(RM) $(COMMONLIB)/libLinux_DnsSettingSupport.so \
	$(RM) $(CIMOMLIB)/libLinux_DnsSetting.so

--- NEW FILE: Linux_DnsSettingDefaultImplementation.h ---
 /**
 * Linux_DnsSettingDefaultImplementation.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_DnsSettingDefaultImplementation_h
#define Linux_DnsSettingDefaultImplementation_h

#include "Linux_DnsSettingInstanceName.h"
#include "Linux_DnsSettingManualInstance.h"
#include "CmpiObjectPath.h"
#include "CmpiInstance.h"
#include "CmpiDateTime.h"
#include "CmpiBroker.h"
#include "CIM_CollectionOfMSEsInstanceName.h"
#include "CIM_ManagedSystemElementInstanceName.h"
#include "Linux_DnsSettingInterface.h"

namespace genProvider {

  class Linux_DnsSettingDefaultImplementation:
   public Linux_DnsSettingInterface {
  	
    public:    
    virtual ~Linux_DnsSettingDefaultImplementation() { };
    
    /* intrinsic methods */
    virtual void enumInstanceNames(
     const CmpiContext& ctx,
     const CmpiBroker &mbp,
     const char *nsp,
     Linux_DnsSettingInstanceNameEnumeration& instnames);
  	
    virtual void enumInstances(
     const CmpiContext& ctx,
     const CmpiBroker &mbp,
     const char *nsp,
     const char* *properties,
  	 Linux_DnsSettingManualInstanceEnumeration& instances);
  	
    virtual Linux_DnsSettingManualInstance getInstance(
     const CmpiContext& ctx,
     const CmpiBroker &mbp,
     const char* *properties,
     const Linux_DnsSettingInstanceName&);
  	
    virtual void setInstance(
     const CmpiContext& ctx,
     const CmpiBroker &mbp,
     const char* *properties,
     const Linux_DnsSettingManualInstance&);
  	
    virtual void createInstance(
     const CmpiContext& ctx,
     const CmpiBroker &mbp,
     const Linux_DnsSettingManualInstance&);
  	
    virtual void deleteInstance(
     const CmpiContext& ctx,
     const CmpiBroker &mbp,
     const Linux_DnsSettingInstanceName&);
	
    
    /* extrinsic methods */

    virtual CMPIUint32 ApplyIncrementalChangeToCollection(
     const CmpiContext& ctx, const CmpiBroker &mbp,
     const Linux_DnsSettingInstanceName&,
      const CIM_CollectionOfMSEsInstanceName &Collection,
      int isCollectionPresent,
      const CmpiDateTime &TimeToApply,
      int isTimeToApplyPresent,
      const CMPIBoolean &ContinueOnError,
      int isContinueOnErrorPresent,
      const CmpiDateTime &MustBeCompletedBy,
      int isMustBeCompletedByPresent,
      const char** PropertiesToApply,
      const CMPICount PropertiesToApplySize,
      int isPropertiesToApplyPresent,
      char** &CanNotApply,
      CMPICount &CanNotApplySize);

    virtual CMPIUint32 ApplyIncrementalChangeToMSE(
     const CmpiContext& ctx, const CmpiBroker &mbp,
     const Linux_DnsSettingInstanceName&,
      const CIM_ManagedSystemElementInstanceName &MSE,
      int isMSEPresent,
      const CmpiDateTime &TimeToApply,
      int isTimeToApplyPresent,
      const CmpiDateTime &MustBeCompletedBy,
      int isMustBeCompletedByPresent,
      const char** PropertiesToApply,
      const CMPICount PropertiesToApplySize,
      int isPropertiesToApplyPresent);

    virtual CMPIUint32 ApplyToCollection(
     const CmpiContext& ctx, const CmpiBroker &mbp,
     const Linux_DnsSettingInstanceName&,
      const CIM_CollectionOfMSEsInstanceName &Collection,
      int isCollectionPresent,
      const CmpiDateTime &TimeToApply,
      int isTimeToApplyPresent,
      const CMPIBoolean &ContinueOnError,
      int isContinueOnErrorPresent,
      const CmpiDateTime &MustBeCompletedBy,
      int isMustBeCompletedByPresent,
      char** &CanNotApply,
      CMPICount &CanNotApplySize);

    virtual CMPIUint32 ApplyToMSE(
     const CmpiContext& ctx, const CmpiBroker &mbp,
     const Linux_DnsSettingInstanceName&,
      const CIM_ManagedSystemElementInstanceName &MSE,
      int isMSEPresent,
      const CmpiDateTime &TimeToApply,
      int isTimeToApplyPresent,
      const CmpiDateTime &MustBeCompletedBy,
      int isMustBeCompletedByPresent);

    virtual CMPIUint32 VerifyOKToApplyIncrementalChangeToCollection(
     const CmpiContext& ctx, const CmpiBroker &mbp,
     const Linux_DnsSettingInstanceName&,
      const CIM_CollectionOfMSEsInstanceName &Collection,
      int isCollectionPresent,
      const CmpiDateTime &TimeToApply,
      int isTimeToApplyPresent,
      const CmpiDateTime &MustBeCompletedBy,
      int isMustBeCompletedByPresent,
      const char** PropertiesToApply,
      const CMPICount PropertiesToApplySize,
      int isPropertiesToApplyPresent,
      char** &CanNotApply,
      CMPICount &CanNotApplySize);

    virtual CMPIUint32 VerifyOKToApplyIncrementalChangeToMSE(
     const CmpiContext& ctx, const CmpiBroker &mbp,
     const Linux_DnsSettingInstanceName&,
      const CIM_ManagedSystemElementInstanceName &MSE,
      int isMSEPresent,
      const CmpiDateTime &TimeToApply,
      int isTimeToApplyPresent,
      const CmpiDateTime &MustBeCompletedBy,
      int isMustBeCompletedByPresent,
      const char** PropertiesToApply,
      const CMPICount PropertiesToApplySize,
      int isPropertiesToApplyPresent);

    virtual CMPIUint32 VerifyOKToApplyToCollection(
     const CmpiContext& ctx, const CmpiBroker &mbp,
     const Linux_DnsSettingInstanceName&,
      const CIM_CollectionOfMSEsInstanceName &Collection,
      int isCollectionPresent,
      const CmpiDateTime &TimeToApply,
      int isTimeToApplyPresent,
      const CmpiDateTime &MustBeCompletedBy,
      int isMustBeCompletedByPresent,
      char** &CanNotApply,
      CMPICount &CanNotApplySize);

    virtual CMPIUint32 VerifyOKToApplyToMSE(
     const CmpiContext& ctx, const CmpiBroker &mbp,
     const Linux_DnsSettingInstanceName&,
      const CIM_ManagedSystemElementInstanceName &MSE,
      int isMSEPresent,
      const CmpiDateTime &TimeToApply,
      int isTimeToApplyPresent,
      const CmpiDateTime &MustBeCompletedBy,
      int isMustBeCompletedByPresent);
	
  };
}
#endif


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

namespace genProvider {
	
  //*********************************************************
  //Linux_DnsSettingInstanceName
  //*********************************************************
  
  //empty constructor
  Linux_DnsSettingInstanceName::
   Linux_DnsSettingInstanceName(){
   	init();  	
  };
  
  
  //copy constructor	
  Linux_DnsSettingInstanceName::
   Linux_DnsSettingInstanceName
   (const Linux_DnsSettingInstanceName& original){
   	init(original);  	
  };
  
  
  //contructor using CmpiObjectPath
  Linux_DnsSettingInstanceName::
   Linux_DnsSettingInstanceName (const CmpiObjectPath& path){
    
    init();
    
    m_CIMClassNameP=path.getClassName().charPtr();
    
    CmpiString namespaceOP;
    namespaceOP=path.getNameSpace();
    setNamespace(namespaceOP.charPtr(),1);
    
    CmpiString Name = path.getKey("Name");
    setName(Name.charPtr());
    
  }
  
  
  //destructor
  Linux_DnsSettingInstanceName::
   ~Linux_DnsSettingInstanceName(){
   	reset();  	  
  };
  
  
  //copy operator
  Linux_DnsSettingInstanceName&
   Linux_DnsSettingInstanceName::operator=
   (const Linux_DnsSettingInstanceName& original){    
    init(original);
   	return *this;    
  }
  
  
  //returns the related CmpiObjectPath
  CmpiObjectPath Linux_DnsSettingInstanceName::
   getObjectPath() const{
   	
   	CmpiObjectPath objectPath(m_namespace, m_CIMClassNameP);

  	objectPath.setKey("Name",CmpiData(m_Name));
  	
  	return objectPath;
  	
  }
  
  
  //adds the related CmpiObjectPath to an existing cmpiInstance
  void Linux_DnsSettingInstanceName::fillKeys(CmpiInstance& cmpiInstance) const{
  	

  	if(isSet.Name){
  	  cmpiInstance.setProperty("Name",CmpiData(m_Name));
  	}
  }
  
  
  //NameSpace related methods
  unsigned int Linux_DnsSettingInstanceName::
   isNameSpaceSet() const{
  	return isSet.m_namespace;
  }
  
  const char * Linux_DnsSettingInstanceName::
   getNamespace() const {
    if(!isSet.m_namespace)
   	  throw CmpiErrorFormater::getErrorException(
   	   CmpiErrorFormater::NOT_SET,
   	   "NameSpace not set in Linux_DnsSetting instanceName");
  	return m_namespace;
  }

  void Linux_DnsSettingInstanceName::
   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;
  }
       
  //Name related methods
  unsigned int Linux_DnsSettingInstanceName::isNameSet() const{
    return isSet.Name;
  }
  void  Linux_DnsSettingInstanceName::
   setName(const char* val, int makeCopy){
    if (isSet.Name) {
      delete []m_Name;
    }
    if (makeCopy&&val) {
      char* tmpval = new char[strlen(val)+1];
      strcpy(tmpval,val);
      m_Name = tmpval;
    } else {
      m_Name = val;
    }
    isSet.Name=1;
  }       
  const char* Linux_DnsSettingInstanceName::
   getName() const{
    
    if(!isSet.Name)
   	  throw CmpiErrorFormater::getErrorException(
   	   CmpiErrorFormater::NOT_SET,
   	   "Name not set");
   	   	
    return m_Name;
  }

  
  //set isSet variables to FALSE
  void Linux_DnsSettingInstanceName::init(){
  	
  	m_CIMClassNameP="Linux_DnsSetting";
  	isSet.m_namespace=0;    	
    isSet.Name=0;
  }
  
  
  //copies another instance properties in this
  void Linux_DnsSettingInstanceName::init
   (const Linux_DnsSettingInstanceName& original){
   	init();
   	   	
    m_CIMClassNameP=original.m_CIMClassNameP;
    if(original.isNameSpaceSet()){
      setNamespace(original.getNamespace(),1);
    }   	
    if(original.isNameSet()){
      const char* NameOriginal=original.getName();
      setName(NameOriginal, 1);
    }    
  }
  
  //reset the instanceName data
  void Linux_DnsSettingInstanceName::reset(){   	
  	if (isSet.m_namespace)
  	  delete(m_namespace);

  	if (isSet.Name)
  	  delete(m_Name);  	  
  };
  
  
  
  
  //*********************************************************
  //Linux_DnsSettingInstanceNameEnumerationElement	
  //*********************************************************
  
  Linux_DnsSettingInstanceNameEnumerationElement::
   Linux_DnsSettingInstanceNameEnumerationElement(){
   	
  	m_elementP=0;
  	m_nextP=0;
  	  
  };
  
  
  Linux_DnsSettingInstanceNameEnumerationElement::
   ~Linux_DnsSettingInstanceNameEnumerationElement(){
   	
  	if (m_elementP!=0)
  	  delete(m_elementP);
  	if (m_nextP!=0)
  	  delete(m_nextP);
  	  
  };

  
  //*********************************************************
  //Linux_DnsSettingInstanceNameEnumeration
  //*********************************************************
  
  Linux_DnsSettingInstanceNameEnumeration::
   Linux_DnsSettingInstanceNameEnumeration(){
   	
  	 firstElementP=0;
     currentElementP=0;
     endElementP=0;
  };
  
  Linux_DnsSettingInstanceNameEnumeration::
   Linux_DnsSettingInstanceNameEnumeration(const CmpiArray& arr){
  	
  	firstElementP=0;
    currentElementP=0;
    endElementP=0;
    
    int size = arr.size();
    for (int i=0; i < size; i++) {
     addElement(Linux_DnsSettingInstanceName(arr[i]));
    }
  }
  
  Linux_DnsSettingInstanceNameEnumeration::
   Linux_DnsSettingInstanceNameEnumeration(
   const Linux_DnsSettingInstanceNameEnumeration& original){
   	
     firstElementP=0;
     currentElementP=0;
     endElementP=0;
  	 
     int size=original.getSize();
     for(int i=0;i<size;i++)
       addElement(original.getElement(i));           
  };
  
  	  
  Linux_DnsSettingInstanceNameEnumeration::
   ~Linux_DnsSettingInstanceNameEnumeration(){
   	
  	if (firstElementP!=0)
  	  delete(firstElementP);
  	  	
  };
  
  	  
  void Linux_DnsSettingInstanceNameEnumeration::reset(){
  	
  	currentElementP=firstElementP;
  };
  
  	  
  bool Linux_DnsSettingInstanceNameEnumeration::hasNext() const{
  	
  	return (currentElementP!=0);
  
  };
  
  int Linux_DnsSettingInstanceNameEnumeration::getSize() const{
  	
    int size=0;
    Linux_DnsSettingInstanceNameEnumerationElement* followingP=firstElementP;
  	
  	while(followingP!=0){
        followingP=followingP->m_nextP;
        size++;
    }
  	
    return size;
  };
  
  const Linux_DnsSettingInstanceName&  
   Linux_DnsSettingInstanceNameEnumeration::getElement(int pos) const{
   
    Linux_DnsSettingInstanceNameEnumerationElement* followingP=firstElementP;
   
    int i=0;
    while((followingP!=0)&&(i<pos)){
        followingP=followingP->m_nextP;
        i++;
    }
    
    return *(followingP->m_elementP);
  };
  
  	  
  const Linux_DnsSettingInstanceName&
   Linux_DnsSettingInstanceNameEnumeration::getNext() {
   	
  	 Linux_DnsSettingInstanceNameEnumerationElement* currentP=
  	  currentElementP;
  	 currentElementP=currentElementP->m_nextP;
  	 
  	 return *(currentP->m_elementP);
  };
  	  
  void Linux_DnsSettingInstanceNameEnumeration::addElement
   (const Linux_DnsSettingInstanceName& elementP){
   	
  	if(firstElementP==0){
  	  firstElementP=new Linux_DnsSettingInstanceNameEnumerationElement();
  	  firstElementP->m_elementP=new Linux_DnsSettingInstanceName(elementP);
  	  endElementP=firstElementP;
  	  currentElementP=firstElementP;
  	}else{
  	  endElementP->m_nextP=new Linux_DnsSettingInstanceNameEnumerationElement();
  	  endElementP=endElementP->m_nextP;
  	  endElementP->m_elementP=new Linux_DnsSettingInstanceName(elementP);
  	}
  };
  
  Linux_DnsSettingInstanceNameEnumeration::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_DnsSettingDefaultImplementation.cpp ---
 /**
 * Linux_DnsSettingDefaultImplementation.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_DnsSettingDefaultImplementation.h"
#include <iostream>

using namespace std;

namespace genProvider {

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

    CMPIUint32 Linux_DnsSettingDefaultImplementation::ApplyIncrementalChangeToCollection(
     const CmpiContext& ctx, const CmpiBroker &mbp,
     const Linux_DnsSettingInstanceName&,
      const CIM_CollectionOfMSEsInstanceName &Collection,
      int isCollectionPresent,
      const CmpiDateTime &TimeToApply,
      int isTimeToApplyPresent,
      const CMPIBoolean &ContinueOnError,
      int isContinueOnErrorPresent,
      const CmpiDateTime &MustBeCompletedBy,
      int isMustBeCompletedByPresent,
      const char** PropertiesToApply,
      const CMPICount PropertiesToApplySize,
      int isPropertiesToApplyPresent,
      char** &CanNotApply,
      CMPICount &CanNotApplySize){
      cout<<"ApplyIncrementalChangeToCollection() not supported in Linux_DnsSetting"<<endl;
   	  throw CmpiErrorFormater::getErrorException(
   	   CmpiErrorFormater::NOT_IMPLEMENTED,
   	   "ApplyIncrementalChangeToCollection() not implemented in Linux_DnsSetting");
    };

    CMPIUint32 Linux_DnsSettingDefaultImplementation::ApplyIncrementalChangeToMSE(
     const CmpiContext& ctx, const CmpiBroker &mbp,
     const Linux_DnsSettingInstanceName&,
      const CIM_ManagedSystemElementInstanceName &MSE,
      int isMSEPresent,
      const CmpiDateTime &TimeToApply,
      int isTimeToApplyPresent,
      const CmpiDateTime &MustBeCompletedBy,
      int isMustBeCompletedByPresent,
      const char** PropertiesToApply,
      const CMPICount PropertiesToApplySize,
      int isPropertiesToApplyPresent){
      cout<<"ApplyIncrementalChangeToMSE() not supported in Linux_DnsSetting"<<endl;
   	  throw CmpiErrorFormater::getErrorException(
   	   CmpiErrorFormater::NOT_IMPLEMENTED,
   	   "ApplyIncrementalChangeToMSE() not implemented in Linux_DnsSetting");
    };

    CMPIUint32 Linux_DnsSettingDefaultImplementation::ApplyToCollection(
     const CmpiContext& ctx, const CmpiBroker &mbp,
     const Linux_DnsSettingInstanceName&,
      const CIM_CollectionOfMSEsInstanceName &Collection,
      int isCollectionPresent,
      const CmpiDateTime &TimeToApply,
      int isTimeToApplyPresent,
      const CMPIBoolean &ContinueOnError,
      int isContinueOnErrorPresent,
      const CmpiDateTime &MustBeCompletedBy,
      int isMustBeCompletedByPresent,
      char** &CanNotApply,
      CMPICount &CanNotApplySize){
      cout<<"ApplyToCollection() not supported in Linux_DnsSetting"<<endl;
   	  throw CmpiErrorFormater::getErrorException(
   	   CmpiErrorFormater::NOT_IMPLEMENTED,
   	   "ApplyToCollection() not implemented in Linux_DnsSetting");
    };

    CMPIUint32 Linux_DnsSettingDefaultImplementation::ApplyToMSE(
     const CmpiContext& ctx, const CmpiBroker &mbp,
     const Linux_DnsSettingInstanceName&,
      const CIM_ManagedSystemElementInstanceName &MSE,
      int isMSEPresent,
      const CmpiDateTime &TimeToApply,
      int isTimeToApplyPresent,
      const CmpiDateTime &MustBeCompletedBy,
      int isMustBeCompletedByPresent){
      cout<<"ApplyToMSE() not supported in Linux_DnsSetting"<<endl;
   	  throw CmpiErrorFormater::getErrorException(
   	   CmpiErrorFormater::NOT_IMPLEMENTED,
   	   "ApplyToMSE() not implemented in Linux_DnsSetting");
    };

    CMPIUint32 Linux_DnsSettingDefaultImplementation::VerifyOKToApplyIncrementalChangeToCollection(
     const CmpiContext& ctx, const CmpiBroker &mbp,
     const Linux_DnsSettingInstanceName&,
      const CIM_CollectionOfMSEsInstanceName &Collection,
      int isCollectionPresent,
      const CmpiDateTime &TimeToApply,
      int isTimeToApplyPresent,
      const CmpiDateTime &MustBeCompletedBy,
      int isMustBeCompletedByPresent,
      const char** PropertiesToApply,
      const CMPICount PropertiesToApplySize,
      int isPropertiesToApplyPresent,
      char** &CanNotApply,
      CMPICount &CanNotApplySize){
      cout<<"VerifyOKToApplyIncrementalChangeToCollection() not supported in Linux_DnsSetting"<<endl;
   	  throw CmpiErrorFormater::getErrorException(
   	   CmpiErrorFormater::NOT_IMPLEMENTED,
   	   "VerifyOKToApplyIncrementalChangeToCollection() not implemented in Linux_DnsSetting");
    };

    CMPIUint32 Linux_DnsSettingDefaultImplementation::VerifyOKToApplyIncrementalChangeToMSE(
     const CmpiContext& ctx, const CmpiBroker &mbp,
     const Linux_DnsSettingInstanceName&,
      const CIM_ManagedSystemElementInstanceName &MSE,
      int isMSEPresent,
      const CmpiDateTime &TimeToApply,
      int isTimeToApplyPresent,
      const CmpiDateTime &MustBeCompletedBy,
      int isMustBeCompletedByPresent,
      const char** PropertiesToApply,
      const CMPICount PropertiesToApplySize,
      int isPropertiesToApplyPresent){
      cout<<"VerifyOKToApplyIncrementalChangeToMSE() not supported in Linux_DnsSetting"<<endl;
   	  throw CmpiErrorFormater::getErrorException(
   	   CmpiErrorFormater::NOT_IMPLEMENTED,
   	   "VerifyOKToApplyIncrementalChangeToMSE() not implemented in Linux_DnsSetting");
    };

    CMPIUint32 Linux_DnsSettingDefaultImplementation::VerifyOKToApplyToCollection(
     const CmpiContext& ctx, const CmpiBroker &mbp,
     const Linux_DnsSettingInstanceName&,
      const CIM_CollectionOfMSEsInstanceName &Collection,
      int isCollectionPresent,
      const CmpiDateTime &TimeToApply,
      int isTimeToApplyPresent,
      const CmpiDateTime &MustBeCompletedBy,
      int isMustBeCompletedByPresent,
      char** &CanNotApply,
      CMPICount &CanNotApplySize){
      cout<<"VerifyOKToApplyToCollection() not supported in Linux_DnsSetting"<<endl;
   	  throw CmpiErrorFormater::getErrorException(
   	   CmpiErrorFormater::NOT_IMPLEMENTED,
   	   "VerifyOKToApplyToCollection() not implemented in Linux_DnsSetting");
    };

    CMPIUint32 Linux_DnsSettingDefaultImplementation::VerifyOKToApplyToMSE(
     const CmpiContext& ctx, const CmpiBroker &mbp,
     const Linux_DnsSettingInstanceName&,
      const CIM_ManagedSystemElementInstanceName &MSE,
      int isMSEPresent,
      const CmpiDateTime &TimeToApply,
      int isTimeToApplyPresent,
      const CmpiDateTime &MustBeCompletedBy,
      int isMustBeCompletedByPresent){
      cout<<"VerifyOKToApplyToMSE() not supported in Linux_DnsSetting"<<endl;
   	  throw CmpiErrorFormater::getErrorException(
   	   CmpiErrorFormater::NOT_IMPLEMENTED,
   	   "VerifyOKToApplyToMSE() not implemented in Linux_DnsSetting");
    };
	
}


--- NEW FILE: Linux_DnsSettingRepositoryExternal.h ---
 /**
 * Linux_DnsSettingRepositoryExternal.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_DnsSettingRepositoryExternal_h
#define Linux_DnsSettingRepositoryExternal_h

#include "Linux_DnsSettingInstanceName.h"
#include "Linux_DnsSettingRepositoryInstance.h"
#include "CmpiBroker.h"

namespace genProvider {

  class Linux_DnsSettingRepositoryExternal {
  	
    public:
    Linux_DnsSettingRepositoryExternal(
     const CmpiBroker& brkr,
     const CmpiContext& ctx);
    virtual ~Linux_DnsSettingRepositoryExternal();
    
    virtual void enumInstanceNames(
     Linux_DnsSettingInstanceNameEnumeration&);
     
    virtual void enumInstances(
     const char* *properties,
     Linux_DnsSettingRepositoryInstanceEnumeration&);
     
    virtual Linux_DnsSettingRepositoryInstance getInstance(
     const char* *properties,
     const Linux_DnsSettingInstanceName&);
     
    virtual void setInstance(
     const char* *properties,
     const Linux_DnsSettingRepositoryInstance&);
     
    virtual void createInstance(
     const Linux_DnsSettingRepositoryInstance&);
     
    virtual void deleteInstance(
     const Linux_DnsSettingInstanceName&);
     
    private:
    CmpiBroker  broker;
    CmpiContext context;
    const static char *nsp;
  };
}
#endif

--- NEW FILE: Linux_DnsSettingResourceAccess.cpp ---
 /**
 * Linux_DnsSettingResourceAccess.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 <iostream>

using namespace std;

#include "Linux_DnsSettingResourceAccess.h"

#include "defaultvalues.h"

namespace genProvider {
  
    //Linux_DnsSettingResourceAccess::Linux_DnsSettingResourceAccess();
    Linux_DnsSettingResourceAccess::~Linux_DnsSettingResourceAccess() { };
    
    /* intrinsic methods */
    
    void Linux_DnsSettingResourceAccess::enumInstanceNames(
     const CmpiContext& ctx, const CmpiBroker &mbp, const char *nsp,
     Linux_DnsSettingInstanceNameEnumeration& instnames){
	
	Linux_DnsSettingInstanceName instanceName;

        instanceName.setNamespace(nsp);
        instanceName.setName(DEFAULT_SERVICE_NAME);

        instnames.addElement(instanceName);
    }
    
  	
    void Linux_DnsSettingResourceAccess::enumInstances(
     const CmpiContext& ctx,
     const CmpiBroker &mbp,
     const char *nsp,
     const char* *properties,
  	 Linux_DnsSettingManualInstanceEnumeration& instances){

	Linux_DnsSettingManualInstance aManualInstance;
	Linux_DnsSettingInstanceName instanceName;

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

        BINDOPTS *bopts = ReadOptions();

	char *forward = getOption(bopts,"forward");
        if ( forward )
        {
		if ( strcmp( forward, "first" ) )
                	aManualInstance.setForward( DNS_FORWARD_FIRST  );

		if ( strcmp( forward, "only" ) )
                        aManualInstance.setForward( DNS_FORWARD_ONLY );

                free( forward );
        }

	char* forwarders = getOption( bopts, "forwarders" );
        if ( forwarders )
        {
        	DnsArray da = DnsArray( forwarders );
                aManualInstance.setForwarders( da.toArray(), da.size() );
		free( forwarders );
        }

        char *directory = getOption(bopts,"directory");
        if ( directory )
        {
                aManualInstance.setConfigurationDirectory( directory );
                free( directory );
        }

        char *port = getOption(bopts,"port");
        if ( port )
        {
                aManualInstance.setPortNumber( atoi( port ) );
                free( port );
        }

        char *tsig = getOption(bopts,"TSIG");
        if ( tsig )
        {
                aManualInstance.setTSIG( atoi( tsig ) );
                free( tsig );
        }

        char *ttl = getOption(bopts,"TTL");
        if ( ttl )
        {
                aManualInstance.setTTL( atoi( ttl ) );
                free( ttl );
        }
	
	instances.addElement(aManualInstance);
    };
  
  	
    Linux_DnsSettingManualInstance 
     Linux_DnsSettingResourceAccess::getInstance(
     const CmpiContext& ctx,
     const CmpiBroker &mbp,
     const char* *properties,
     const Linux_DnsSettingInstanceName& instance){

	Linux_DnsSettingManualInstance aManualInstance;
        aManualInstance.setInstanceName(instance);
	
	BINDOPTS *bopts = ReadOptions();

	char *directory = getOption(bopts,"directory");
	if ( directory != NULL ) 
	{	
		aManualInstance.setConfigurationDirectory( directory );
		free( directory );
	}

        char *forward = getOption(bopts,"forward");
        if ( forward )
        {
                if ( strcmp( forward, "first" ) )
                        aManualInstance.setForward( DNS_FORWARD_FIRST  );

                if ( strcmp( forward, "only" ) )
                        aManualInstance.setForward( DNS_FORWARD_ONLY );

                free( forward );
        }

        char* forwarders = getOption( bopts, "forwarders" );
        if ( forwarders )
        {
                DnsArray da = DnsArray( forwarders );
                aManualInstance.setForwarders( da.toArray(), da.size() );
                free( forwarders );
        }

	char *port = getOption(bopts,"port");
	if ( port != NULL ) 
	{
        	aManualInstance.setPortNumber( atoi( port ) );
		free( port );
        }
	
	char *tsig = getOption(bopts,"TSIG");
	if ( tsig != NULL )
	{
		aManualInstance.setTSIG( atoi( tsig ) );
		free( tsig );
	} 

	char *ttl = getOption(bopts,"TTL");	
	if ( ttl != NULL )
	{
        	aManualInstance.setTTL( atoi( ttl ) );
        	free( ttl );
	}
	return aManualInstance; 
    }
  	
  	
    void Linux_DnsSettingResourceAccess::setInstance(
     const CmpiContext& ctx,
     const CmpiBroker &mbp,
     const char* *properties,
     const Linux_DnsSettingManualInstance& newInstance){
	BINDOPTS *bopt = ReadOptions();

	if ( newInstance.isConfigurationDirectorySet() )
		setOption(bopt, "directory", newInstance.getConfigurationDirectory() );

        if ( newInstance.isForwardSet() )
        {
                if ( newInstance.getForward() == DNS_FORWARD_ONLY )
                	setOption(bopt, "forward", strdup( "only" ) );

                if ( newInstance.getForward() == DNS_FORWARD_FIRST )
                	setOption(bopt, "forward", strdup( "first" ) );
        }

        unsigned int size = 0;
        if ( newInstance.isForwardersSet() )
        {
                const char **forwardersList = newInstance.getForwarders( size );
                DnsArray value_list;

                for (unsigned int i = 0; i < size; i++)
                if (! value_list.isPresent( string( forwardersList[i]) ) )
                        value_list.add( forwardersList[i] );

                setOption( bopt, "forwarders", strdup ( value_list.toString().c_str() ) );
        }

	if ( newInstance.isPortNumberSet() )
	{
		char *port = (char *) malloc(6*sizeof(char));
		sprintf( port, "%lu", newInstance.getPortNumber() );
		setOption(bopt, "port", port ); 
		free(port);
	}
	if ( newInstance.isTSIGSet() )
	{
		char *tsig = (char *) malloc(6*sizeof(char));
                sprintf( tsig, "%d", newInstance.getTSIG() );
        	setOption(bopt, "TSIG", tsig );
		free(tsig);	
	}
        if ( newInstance.isTTLSet() )
	{
                char *ttl = (char *) malloc(20*sizeof(char));
                sprintf( ttl, "%lu", newInstance.getTTL() );
                setOption(bopt, "TTL", ttl );
		free(ttl);
	}
    };
  	
  	/*
    void Linux_DnsSettingResourceAccess::createInstance(
     const CmpiContext& ctx, const CmpiBroker &mbp,
     const Linux_DnsSettingManualInstance&){};
  	*/
  	/*
    void Linux_DnsSettingResourceAccess::deleteInstance(
     const CmpiContext& ctx, const CmpiBroker &mbp,
     const Linux_DnsSettingInstanceName&){};
	*/
    
    /* extrinsic methods */
    /*
    virtual CMPIUint32 Linux_DnsSettingResourceAccess::ApplyIncrementalChangeToCollection(
     const CmpiContext& ctx, const CmpiBroker &mbp,
     const Linux_DnsSettingInstanceName&,
      const CIM_CollectionOfMSEsInstanceName &Collection,
      int isCollectionPresent,
      const CmpiDateTime &TimeToApply,
      int isTimeToApplyPresent,
      const CMPIBoolean &ContinueOnError,
      int isContinueOnErrorPresent,
      const CmpiDateTime &MustBeCompletedBy,
      int isMustBeCompletedByPresent,
      const char** PropertiesToApply,
      const CMPICount PropertiesToApplySize,
      int isPropertiesToApplyPresent,
      char** &CanNotApply,
      CMPICount &CanNotApplySize) { };
    */
    /*
    virtual CMPIUint32 Linux_DnsSettingResourceAccess::ApplyIncrementalChangeToMSE(
     const CmpiContext& ctx, const CmpiBroker &mbp,
     const Linux_DnsSettingInstanceName&,
      const CIM_ManagedSystemElementInstanceName &MSE,
      int isMSEPresent,
      const CmpiDateTime &TimeToApply,
      int isTimeToApplyPresent,
      const CmpiDateTime &MustBeCompletedBy,
      int isMustBeCompletedByPresent,
      const char** PropertiesToApply,
      const CMPICount PropertiesToApplySize,
      int isPropertiesToApplyPresent) { };
    */
    /*
    virtual CMPIUint32 Linux_DnsSettingResourceAccess::ApplyToCollection(
     const CmpiContext& ctx, const CmpiBroker &mbp,
     const Linux_DnsSettingInstanceName&,
      const CIM_CollectionOfMSEsInstanceName &Collection,
      int isCollectionPresent,
      const CmpiDateTime &TimeToApply,
      int isTimeToApplyPresent,
      const CMPIBoolean &ContinueOnError,
      int isContinueOnErrorPresent,
      const CmpiDateTime &MustBeCompletedBy,
      int isMustBeCompletedByPresent,
      char** &CanNotApply,
      CMPICount &CanNotApplySize) { };
    */
    /*
    virtual CMPIUint32 Linux_DnsSettingResourceAccess::ApplyToMSE(
     const CmpiContext& ctx, const CmpiBroker &mbp,
     const Linux_DnsSettingInstanceName&,
      const CIM_ManagedSystemElementInstanceName &MSE,
      int isMSEPresent,
      const CmpiDateTime &TimeToApply,
      int isTimeToApplyPresent,
      const CmpiDateTime &MustBeCompletedBy,
      int isMustBeCompletedByPresent) { };
    */
    /*
    virtual CMPIUint32 Linux_DnsSettingResourceAccess::VerifyOKToApplyIncrementalChangeToCollection(
     const CmpiContext& ctx, const CmpiBroker &mbp,
     const Linux_DnsSettingInstanceName&,
      const CIM_CollectionOfMSEsInstanceName &Collection,
      int isCollectionPresent,
      const CmpiDateTime &TimeToApply,
      int isTimeToApplyPresent,
      const CmpiDateTime &MustBeCompletedBy,
      int isMustBeCompletedByPresent,
      const char** PropertiesToApply,
      const CMPICount PropertiesToApplySize,
      int isPropertiesToApplyPresent,
      char** &CanNotApply,
      CMPICount &CanNotApplySize) { };
    */
    /*
    virtual CMPIUint32 Linux_DnsSettingResourceAccess::VerifyOKToApplyIncrementalChangeToMSE(
     const CmpiContext& ctx, const CmpiBroker &mbp,
     const Linux_DnsSettingInstanceName&,
      const CIM_ManagedSystemElementInstanceName &MSE,
      int isMSEPresent,
      const CmpiDateTime &TimeToApply,
      int isTimeToApplyPresent,
      const CmpiDateTime &MustBeCompletedBy,
      int isMustBeCompletedByPresent,
      const char** PropertiesToApply,
      const CMPICount PropertiesToApplySize,
      int isPropertiesToApplyPresent) { };
    */
    /*
    virtual CMPIUint32 Linux_DnsSettingResourceAccess::VerifyOKToApplyToCollection(
     const CmpiContext& ctx, const CmpiBroker &mbp,
     const Linux_DnsSettingInstanceName&,
      const CIM_CollectionOfMSEsInstanceName &Collection,
      int isCollectionPresent,
      const CmpiDateTime &TimeToApply,
      int isTimeToApplyPresent,
      const CmpiDateTime &MustBeCompletedBy,
      int isMustBeCompletedByPresent,
      char** &CanNotApply,
      CMPICount &CanNotApplySize) { };
    */
    /*
    virtual CMPIUint32 Linux_DnsSettingResourceAccess::VerifyOKToApplyToMSE(
     const CmpiContext& ctx, const CmpiBroker &mbp,
     const Linux_DnsSettingInstanceName&,
      const CIM_ManagedSystemElementInstanceName &MSE,
      int isMSEPresent,
      const CmpiDateTime &TimeToApply,
      int isTimeToApplyPresent,
      const CmpiDateTime &MustBeCompletedBy,
      int isMustBeCompletedByPresent) { };
    */
	
}



--- NEW FILE: CmpiLinux_DnsSettingProvider.h ---
 /**
 * CmpiLinux_DnsSettingProvider.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 CmpiLinux_DnsSettingProvider_h
#define CmpiLinux_DnsSettingProvider_h

#include "CmpiInstanceMI.h"
#include "CmpiMethodMI.h"
#include "Linux_DnsSettingFactory.h"

 namespace genProvider{

  class CmpiLinux_DnsSettingProvider : public CmpiInstanceMI,
   public CmpiMethodMI{	
	
	private:

	Linux_DnsSettingInterface* interfaceP;
	const static char * shadowNameSpaceP;
	CmpiBroker cppBroker;
	    
    void completeInstance (
     const Linux_DnsSettingInstanceName& intanceNameP,
     CmpiInstance& target, const CmpiContext& ctx);
	
    void copyShadowData (
     const CmpiInstance* source, CmpiInstance* target);
	
    CmpiInstance* getShadowInstance (
     const CmpiInstance& original,
     const Linux_DnsSettingInstanceName& intanceName);
	
    void removeDanglingShadowInstances (
     const Linux_DnsSettingInstanceNameEnumeration& dinInsNames);

	  
	public:

    CmpiLinux_DnsSettingProvider (
     const CmpiBroker &mbp, const CmpiContext& ctx);

    ~CmpiLinux_DnsSettingProvider ();
	
    int isUnloadable() const;
	
    CmpiStatus enumInstanceNames (
     const CmpiContext& ctx, CmpiResult& rslt,
     const CmpiObjectPath& cop);
     
    CmpiStatus enumInstances (
     const CmpiContext& ctx, CmpiResult& rslt,
     const CmpiObjectPath& cop,
     const char* *properties);
     
    CmpiStatus getInstance (
     const CmpiContext& ctx, CmpiResult& rslt,
     const CmpiObjectPath& cop,
     const char* *properties);
    
    virtual CmpiStatus createInstance (
     const CmpiContext& ctx, CmpiResult& rslt,
     const CmpiObjectPath& cop,
     const CmpiInstance& inst);
    
    virtual CmpiStatus setInstance (
     const CmpiContext& ctx, CmpiResult& rslt,
     const CmpiObjectPath& cop,
     const CmpiInstance& inst,
     const char* *properties);
    
    virtual CmpiStatus deleteInstance (
     const CmpiContext& ctx, CmpiResult& rslt,
     const CmpiObjectPath& cop);
     
    /*
    virtual CmpiStatus execQuery (
     const CmpiContext& ctx, CmpiResult& rslt,
     const CmpiObjectPath& cop,
     const char* language,
     const char* query);
    */  
      
    virtual CmpiStatus invokeMethod (
     const CmpiContext& ctx, CmpiResult& rslt,
     const CmpiObjectPath& ref,
     const char* methodName,
     const CmpiArgs& in,
     CmpiArgs& out);
 
  };
}

#endif

--- NEW FILE: Linux_DnsSettingManualInstance.cpp ---
 /**
 * Linux_DnsSettingManualInstance.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_DnsSettingManualInstance.h"
#include "CmpiData.h"
#include "CmpiString.h"
#include "CmpiArray.h"
#include <stri...
 
[truncated message content]