Thread: [Sblim-commit] cmpi-dns/provider/Linux_DnsSetting Linux_DnsSettingExternal.cpp,NONE,1.1 Linux_DnsSet

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

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);
    }    
  }

  //r...

[truncated message content]

Thread: [Sblim-commit] cmpi-dns/provider/Linux_DnsSetting Linux_DnsSettingExternal.cpp,NONE,1.1 Linux_DnsSet

sblim-commit