[Sblim-commit] cmpi-dns/provider/Linux_DnsHintZone makefile,NONE,1.1 Linux_DnsHintZoneManualInstance.cpp,NONE,1.1 Linux_DnsHintZoneInstance.h,NONE,1.1 Linux_DnsHintZoneRepositoryInstance.h,NONE,1.1 Linux_DnsHintZoneFactory.h,NONE,1.1 Linux_DnsHintZoneDefaultImplementation.cpp,NONE,1.1 Linux_DnsHintZoneRepositoryExternal.h,NONE,1.1 Linux_DnsHintZoneResourceAccess.cpp,NONE,1.1 CmpiLinux_DnsHintZoneProvider.cpp,NONE,1.1 setting.provider,NONE,1.1 Linux_DnsHintZoneRepositoryExternal.cpp,NONE,1.1 Linux_DnsHintZoneInstance.cpp,NONE,1.1 Linux_DnsHintZoneInterface.h,NONE,1.1 Linux_DnsHintZoneInstanceName.cpp,NONE,1.1 CmpiLinux_DnsHintZoneProvider.h,NONE,1.1 Linux_DnsHintZoneManualInstance.h,NONE,1.1 Linux_DnsHintZoneExternal.h,NONE,1.1 Linux_DnsHintZoneDefaultImplementation.h,NONE,1.1 Linux_DnsHintZoneInstanceName.h,NONE,1.1 Linux_DnsHintZoneFactory.cpp,NONE,1.1 Linux_DnsHintZoneFakeFactory.cpp,NONE,1.1 Linux_DnsHintZoneResourceAccess.h,NONE,1.1 Linux_DnsHintZoneExternal.cpp,NONE,1.1 Linux_DnsHintZoneRepositoryInstance.cpp,NONE,1.1

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

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

Added Files:
	makefile Linux_DnsHintZoneManualInstance.cpp 
	Linux_DnsHintZoneInstance.h 
	Linux_DnsHintZoneRepositoryInstance.h 
	Linux_DnsHintZoneFactory.h 
	Linux_DnsHintZoneDefaultImplementation.cpp 
	Linux_DnsHintZoneRepositoryExternal.h 
	Linux_DnsHintZoneResourceAccess.cpp 
	CmpiLinux_DnsHintZoneProvider.cpp setting.provider 
	Linux_DnsHintZoneRepositoryExternal.cpp 
	Linux_DnsHintZoneInstance.cpp Linux_DnsHintZoneInterface.h 
	Linux_DnsHintZoneInstanceName.cpp 
	CmpiLinux_DnsHintZoneProvider.h 
	Linux_DnsHintZoneManualInstance.h Linux_DnsHintZoneExternal.h 
	Linux_DnsHintZoneDefaultImplementation.h 
	Linux_DnsHintZoneInstanceName.h Linux_DnsHintZoneFactory.cpp 
	Linux_DnsHintZoneFakeFactory.cpp 
	Linux_DnsHintZoneResourceAccess.h 
	Linux_DnsHintZoneExternal.cpp 
	Linux_DnsHintZoneRepositoryInstance.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_DnsHintZoneExternal.h ---
 /**
 * Linux_DnsHintZoneExternal.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_DnsHintZoneExternal_h
#define Linux_DnsHintZoneExternal_h

#include "Linux_DnsHintZoneInstance.h"
#include "CmpiBroker.h"

namespace genProvider {

  class Linux_DnsHintZoneExternal {
  	
    public:
    Linux_DnsHintZoneExternal(
     const CmpiBroker& brkr, const CmpiContext& ctx);
    virtual ~Linux_DnsHintZoneExternal();
    
    virtual void enumInstanceNames(
     const char *nsp,
     Linux_DnsHintZoneInstanceNameEnumeration&);
     
    virtual void enumInstances(
     const char *nsp,
     const char* *properties,
     Linux_DnsHintZoneInstanceEnumeration&);
     
    virtual Linux_DnsHintZoneInstance getInstance(
     const char* *properties,
     const Linux_DnsHintZoneInstanceName&);
     
    virtual void setInstance(
     const char* *properties,
     const Linux_DnsHintZoneInstance&);
     
    virtual void createInstance(
     const Linux_DnsHintZoneInstance&);
     
    virtual void deleteInstance(
     const Linux_DnsHintZoneInstanceName&);
     
    private:
    CmpiBroker  broker;
    CmpiContext context;
  };
}
#endif

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

namespace genProvider {

  //*********************************************************
  //Linux_DnsHintZoneInstance
  //*********************************************************

  //empty constructor
  Linux_DnsHintZoneInstance::
   Linux_DnsHintZoneInstance(){   	
   	init();  	   	
  };
  
  
  //copy constructor	
  Linux_DnsHintZoneInstance::
   Linux_DnsHintZoneInstance
   (const Linux_DnsHintZoneInstance& original){   	
   	init(original);  	   	
  };
  
  
  //constructor using CmpiInstance
  Linux_DnsHintZoneInstance::
   Linux_DnsHintZoneInstance (const CmpiInstance& inst, const char* instanceNamespace){
    CmpiData cmpiData;
    init(); 
    
    CmpiObjectPath cop=inst.getObjectPath();
    cop.setNameSpace(instanceNamespace);
    setInstanceName(Linux_DnsHintZoneInstanceName(cop));
    
    cmpiData = inst.getProperty("Caption");
    if(!cmpiData.isNullValue()){
      CmpiString Caption = cmpiData;
      setCaption(Caption.charPtr());
    }
    
    cmpiData = inst.getProperty("Description");
    if(!cmpiData.isNullValue()){
      CmpiString Description = cmpiData;
      setDescription(Description.charPtr());
    }
    
    cmpiData = inst.getProperty("ElementName");
    if(!cmpiData.isNullValue()){
      CmpiString ElementName = cmpiData;
      setElementName(ElementName.charPtr());
    }
   
    cmpiData = inst.getProperty("Enabled");
    if(!cmpiData.isNullValue()){
      CMPIBoolean Enabled = cmpiData;
      setEnabled(Enabled);
    }
 
    cmpiData = inst.getProperty("ResourceRecordFile");
    if(!cmpiData.isNullValue()){
      CmpiString ResourceRecordFile = cmpiData;
      setResourceRecordFile(ResourceRecordFile.charPtr());
    }
    
    cmpiData = inst.getProperty("SettingID");
    if(!cmpiData.isNullValue()){
      CmpiString SettingID = cmpiData;
      setSettingID(SettingID.charPtr());
    }
    
    cmpiData = inst.getProperty("Type");
    if(!cmpiData.isNullValue()){
      CMPIUint16 Type = cmpiData;
      setType(Type);
    }
    
  }
  
  
  //Destructor
  Linux_DnsHintZoneInstance::
   ~Linux_DnsHintZoneInstance(){
   	reset();  	  
  };
  
  
  //copy operator
  Linux_DnsHintZoneInstance&
   Linux_DnsHintZoneInstance::operator=
   (const Linux_DnsHintZoneInstance& original){   	
   	init(original);
   	return *this;
  };
  
  
  //converts to CmpiInstance
  CmpiInstance Linux_DnsHintZoneInstance::
   getCmpiInstance(const char** properties) const{
   	
   	CmpiObjectPath objectPath=getInstanceName().getObjectPath();      
    CmpiInstance cmpiInstance(objectPath);    
    getInstanceName().fillKeys(cmpiInstance);
    
    if (properties) {
	  cmpiInstance.setPropertyFilter(properties,0);
    }

  	if(isSet.Caption){
  	  cmpiInstance.setProperty("Caption",CmpiData(m_Caption));
  	}

  	if(isSet.Description){
  	  cmpiInstance.setProperty("Description",CmpiData(m_Description));
  	}

  	if(isSet.ElementName){
  	  cmpiInstance.setProperty("ElementName",CmpiData(m_ElementName));
  	}

        if(isSet.Enabled){
         cmpiInstance.setProperty("Enabled",CmpiBooleanData(m_Enabled));
        }

  	if(isSet.ResourceRecordFile){
  	  cmpiInstance.setProperty("ResourceRecordFile",CmpiData(m_ResourceRecordFile));
  	}

  	if(isSet.SettingID){
  	  cmpiInstance.setProperty("SettingID",CmpiData(m_SettingID));
  	}

  	if(isSet.Type){
  	  cmpiInstance.setProperty("Type",CmpiData(m_Type));
  	}
  	
  	return cmpiInstance;
  	
  }
  
  
  //InstanceName related methods
  unsigned int Linux_DnsHintZoneInstance::
   isInstanceNameSet() const{
  	return isSet.instanceName;
  }
  
  const Linux_DnsHintZoneInstanceName&
    Linux_DnsHintZoneInstance::getInstanceName() const{

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

  void Linux_DnsHintZoneInstance::setInstanceName(
   const Linux_DnsHintZoneInstanceName& val){
    m_instanceName = val;
    isSet.instanceName=1;
  }
       
  //Caption related methods
  unsigned int Linux_DnsHintZoneInstance::isCaptionSet() const{
    return isSet.Caption;
  }
  void  Linux_DnsHintZoneInstance::
   setCaption(const char* val, int makeCopy){
    if (isSet.Caption) {
      delete []m_Caption;
    }
    if (makeCopy&&val) {
      char* tmpval = new char[strlen(val)+1];
      strcpy(tmpval,val);
      m_Caption = tmpval;
    } else {
      m_Caption = val;
    }
    isSet.Caption=1;
  }       
  const char* Linux_DnsHintZoneInstance::
   getCaption() const{
    
    if(!isSet.Caption)
   	  throw CmpiErrorFormater::getErrorException(
   	   CmpiErrorFormater::NOT_SET,
   	   "Caption not set");
   	   	
    return m_Caption;
  }
       
  //Description related methods
  unsigned int Linux_DnsHintZoneInstance::isDescriptionSet() const{
    return isSet.Description;
  }
  void  Linux_DnsHintZoneInstance::
   setDescription(const char* val, int makeCopy){
    if (isSet.Description) {
      delete []m_Description;
    }
    if (makeCopy&&val) {
      char* tmpval = new char[strlen(val)+1];
      strcpy(tmpval,val);
      m_Description = tmpval;
    } else {
      m_Description = val;
    }
    isSet.Description=1;
  }       
  const char* Linux_DnsHintZoneInstance::
   getDescription() const{
    
    if(!isSet.Description)
   	  throw CmpiErrorFormater::getErrorException(
   	   CmpiErrorFormater::NOT_SET,
   	   "Description not set");
   	   	
    return m_Description;
  }
       
  //ElementName related methods
  unsigned int Linux_DnsHintZoneInstance::isElementNameSet() const{
    return isSet.ElementName;
  }
  void  Linux_DnsHintZoneInstance::
   setElementName(const char* val, int makeCopy){
    if (isSet.ElementName) {
      delete []m_ElementName;
    }
    if (makeCopy&&val) {
      char* tmpval = new char[strlen(val)+1];
      strcpy(tmpval,val);
      m_ElementName = tmpval;
    } else {
      m_ElementName = val;
    }
    isSet.ElementName=1;
  }       
  const char* Linux_DnsHintZoneInstance::
   getElementName() const{
    
    if(!isSet.ElementName)
   	  throw CmpiErrorFormater::getErrorException(
   	   CmpiErrorFormater::NOT_SET,
   	   "ElementName not set");
   	   	
    return m_ElementName;
  }
      
  //Enabled related methods
  unsigned int Linux_DnsHintZoneInstance::isEnabledSet() const{
    return isSet.Enabled;
  }
  void Linux_DnsHintZoneInstance::
   setEnabled(const CMPIBoolean val){
    m_Enabled = val;
    isSet.Enabled=1;
  }
  const CMPIBoolean Linux_DnsHintZoneInstance::
   getEnabled() const{

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

    return m_Enabled;
  }
 
  //ResourceRecordFile related methods
  unsigned int Linux_DnsHintZoneInstance::isResourceRecordFileSet() const{
    return isSet.ResourceRecordFile;
  }
  void  Linux_DnsHintZoneInstance::
   setResourceRecordFile(const char* val, int makeCopy){
    if (isSet.ResourceRecordFile) {
      delete []m_ResourceRecordFile;
    }
    if (makeCopy&&val) {
      char* tmpval = new char[strlen(val)+1];
      strcpy(tmpval,val);
      m_ResourceRecordFile = tmpval;
    } else {
      m_ResourceRecordFile = val;
    }
    isSet.ResourceRecordFile=1;
  }       
  const char* Linux_DnsHintZoneInstance::
   getResourceRecordFile() const{
    
    if(!isSet.ResourceRecordFile)
   	  throw CmpiErrorFormater::getErrorException(
   	   CmpiErrorFormater::NOT_SET,
   	   "ResourceRecordFile not set");
   	   	
    return m_ResourceRecordFile;
  }
       
  //SettingID related methods
  unsigned int Linux_DnsHintZoneInstance::isSettingIDSet() const{
    return isSet.SettingID;
  }
  void  Linux_DnsHintZoneInstance::
   setSettingID(const char* val, int makeCopy){
    if (isSet.SettingID) {
      delete []m_SettingID;
    }
    if (makeCopy&&val) {
      char* tmpval = new char[strlen(val)+1];
      strcpy(tmpval,val);
      m_SettingID = tmpval;
    } else {
      m_SettingID = val;
    }
    isSet.SettingID=1;
  }       
  const char* Linux_DnsHintZoneInstance::
   getSettingID() const{
    
    if(!isSet.SettingID)
   	  throw CmpiErrorFormater::getErrorException(
   	   CmpiErrorFormater::NOT_SET,
   	   "SettingID not set");
   	   	
    return m_SettingID;
  }
       
  //Type related methods
  unsigned int Linux_DnsHintZoneInstance::isTypeSet() const{
    return isSet.Type;
  }
  void Linux_DnsHintZoneInstance::
   setType(const CMPIUint16 val){
    m_Type = val;
    isSet.Type=1;
  }       
  const CMPIUint16 Linux_DnsHintZoneInstance::
   getType() const{
    
    if(!isSet.Type)
   	  throw CmpiErrorFormater::getErrorException(
   	   CmpiErrorFormater::NOT_SET,
   	   "Type not set");
   	   	
    return m_Type;
  }


  
  //set isSet attributes to FALSE
  void Linux_DnsHintZoneInstance::init(){
   	isSet.instanceName=0;
   	   	
    isSet.Caption=0;   	
    isSet.Description=0;   	
    isSet.ElementName=0;   	
    isSet.Enabled=0;
    isSet.ResourceRecordFile=0;   	
    isSet.SettingID=0;   	
    isSet.Type=0;  	
  };
  
  
  //copies another instance properties in this
  void Linux_DnsHintZoneInstance::init
   (const Linux_DnsHintZoneInstance& original){   	
   	init();
   	   	
    if(original.isInstanceNameSet()){
      setInstanceName(original.getInstanceName());
    }   	
    if(original.isCaptionSet()){
      const char* CaptionOriginal=original.getCaption();
      setCaption(CaptionOriginal, 1);
    }   	
    if(original.isDescriptionSet()){
      const char* DescriptionOriginal=original.getDescription();
      setDescription(DescriptionOriginal, 1);
    }   	
    if(original.isElementNameSet()){
      const char* ElementNameOriginal=original.getElementName();
      setElementName(ElementNameOriginal, 1);
    } 
    if(original.isEnabledSet()){
      const CMPIBoolean EnabledOriginal=original.getEnabled();
      setEnabled(EnabledOriginal);
    }
    if(original.isResourceRecordFileSet()){
      const char* ResourceRecordFileOriginal=original.getResourceRecordFile();
      setResourceRecordFile(ResourceRecordFileOriginal, 1);
    }   	
    if(original.isSettingIDSet()){
      const char* SettingIDOriginal=original.getSettingID();
      setSettingID(SettingIDOriginal, 1);
    }   	
    if(original.isTypeSet()){
      const CMPIUint16 TypeOriginal=original.getType();
      setType(TypeOriginal);
    }    
   }
  
  
  //reset the instance data
  void Linux_DnsHintZoneInstance::reset(){
   	

  	if (isSet.Caption)
  	  delete(m_Caption);

  	if (isSet.Description)
  	  delete(m_Description);

  	if (isSet.ElementName)
  	  delete(m_ElementName);

  	if (isSet.ResourceRecordFile)
  	  delete(m_ResourceRecordFile);

  	if (isSet.SettingID)
  	  delete(m_SettingID);
  	  
  };
  
  
  //*********************************************************
  //Linux_DnsHintZoneInstanceEnumerationElement	
  //*********************************************************
  
  Linux_DnsHintZoneInstanceEnumerationElement::
   Linux_DnsHintZoneInstanceEnumerationElement(){
   	
  	m_elementP=0;
  	m_nextP=0;
  	  
  };
  
  
  Linux_DnsHintZoneInstanceEnumerationElement::
   ~Linux_DnsHintZoneInstanceEnumerationElement(){
   	
  	if (m_elementP!=0)
  	  delete(m_elementP);
  	if (m_nextP!=0)
  	  delete(m_nextP);
  	  
  };

  
  //*********************************************************
  //Linux_DnsHintZoneInstanceNameEnumeration
  //*********************************************************

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

--- NEW FILE: Linux_DnsHintZoneFakeFactory.cpp ---
 /**
 * Linux_DnsHintZoneFakeFactory.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>
#include <strings.h>

#include "Linux_DnsHintZoneFactory.h"

using namespace std;

namespace genProvider{
	
	Linux_DnsHintZoneInterface* 
	  Linux_DnsHintZoneFactory::getImplementation(){
	  	
	  	cout<<"ERROR: incomplete support library is being used"<<endl;
	  	cout<<"       in provider from class Linux_DnsHintZone"<<endl;
	  	cout<<"       Use the link-install options for the makefile"<<endl;
	  	return 0;
	  };
}

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

namespace genProvider {

  //*********************************************************
  //Linux_DnsHintZoneRepositoryInstance
  //*********************************************************

  //empty constructor
  Linux_DnsHintZoneRepositoryInstance::
   Linux_DnsHintZoneRepositoryInstance(){   	
   	init();  	   	
  };
  
  
  //copy constructor	
  Linux_DnsHintZoneRepositoryInstance::
   Linux_DnsHintZoneRepositoryInstance
   (const Linux_DnsHintZoneRepositoryInstance& original){   	
   	init(original);  	   	
  };
  
  
  //constructor using CmpiInstance
  Linux_DnsHintZoneRepositoryInstance::
   Linux_DnsHintZoneRepositoryInstance (const CmpiInstance& inst, const char* instanceNamespace){
    CmpiData cmpiData;
    init(); 
    
    CmpiObjectPath cop=inst.getObjectPath();
    cop.setNameSpace(instanceNamespace);
    setInstanceName(Linux_DnsHintZoneInstanceName(cop));
    
  }
  
  
  //Destructor
  Linux_DnsHintZoneRepositoryInstance::
   ~Linux_DnsHintZoneRepositoryInstance(){
   	reset();  	  
  };
  
  
  //copy operator
  Linux_DnsHintZoneRepositoryInstance&
   Linux_DnsHintZoneRepositoryInstance::operator=
   (const Linux_DnsHintZoneRepositoryInstance& original){   	
   	init(original);
   	return *this;
  };
  
  
  //converts to CmpiInstance
  CmpiInstance Linux_DnsHintZoneRepositoryInstance::
   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_DnsHintZoneRepositoryInstance::
   isInstanceNameSet() const{
  	return isSet.instanceName;
  }
  
  const Linux_DnsHintZoneInstanceName&
    Linux_DnsHintZoneRepositoryInstance::getInstanceName() const{

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

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


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

  
  //*********************************************************
  //Linux_DnsHintZoneRepositoryInstanceNameEnumeration
  //*********************************************************

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

--- NEW FILE: Linux_DnsHintZoneResourceAccess.cpp ---
 /**
 * Linux_DnsHintZoneResourceAccess.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 <string>
#include <iostream>

using namespace std;

#include "Linux_DnsHintZoneResourceAccess.h"

namespace genProvider {
    //------------------------------------------------------------------------------------
    // Linux_DnsMasterZoneResourceAccess::setInstanceNameProperties()
    //------------------------------------------------------------------------------------
    void
    Linux_DnsHintZoneResourceAccess::setInstanceNameProperties(const CmpiContext& ctx,
                                                           const CmpiBroker& mbp,
                                                           const char* nsp,
                                                           DNSZONE * zone,
                                                           Linux_DnsHintZoneInstanceName& anInstanceName)
    {
        cout << "--- setInstanceNameProperties() called" << endl;
        anInstanceName.setNamespace(nsp);
        anInstanceName.setName(zone->zoneName);

        cout << "--- setInstanceNameProperties() exited" << endl;
    }

    //------------------------------------------------------------------------------------
    // Linux_DnsMasterZoneResourceAccess::setInstanceProperties()
    //------------------------------------------------------------------------------------



    void
    Linux_DnsHintZoneResourceAccess::setInstanceProperties(const CmpiContext& ctx,
                                                       const CmpiBroker& mbp,
                                                       DNSZONE * zone,
                                                       const Linux_DnsHintZoneInstanceName& anInstanceName,
                                                       Linux_DnsHintZoneManualInstance& aManualInstance)
    {
        cout<<"--- setInstanceProperties() called"<<endl;

        aManualInstance.setInstanceName(anInstanceName);
        aManualInstance.setType(DNS_ZONETYPE_HINT);
	aManualInstance.setResourceRecordFile(zone->zoneFileName);
       
        cout << "--- setInstanceProperties() exited" << endl;
    }  
    //Linux_DnsHintZoneResourceAccess::Linux_DnsHintZoneResourceAccess();
    Linux_DnsHintZoneResourceAccess::~Linux_DnsHintZoneResourceAccess() { };
    
    /* intrinsic methods */
    
    void Linux_DnsHintZoneResourceAccess::enumInstanceNames(
     const CmpiContext& ctx, const CmpiBroker &mbp, const char *nsp,
     Linux_DnsHintZoneInstanceNameEnumeration& instnames){
	cout << "Linux_DnsHintZoneResourceAccess::enumInstanceNames()" << endl;	
	DNSZONE * zones, *all_zones;

        cout << "--- enumInstanceNames() called" << endl; 
        cout << "---- calling getZones() " << endl;
        zones = getZones();	//getZonesByType("hint");
	all_zones = zones;
        if (zones)
        {
            for (; zones->zoneName != NULL ; zones++)
            {	
                if ( strcmp(zones->zoneType, "hint") )
                        continue;

                Linux_DnsHintZoneInstanceName instanceName;

                cout << "--- Calling setInstanceNameProperties()" << endl; 

                printf ("Zone Name is %s \n", zones->zoneName);

                setInstanceNameProperties(ctx, mbp, nsp,
                                          zones, instanceName);

                instnames.addElement(instanceName);

                cout << "--- Added to enumeration"  << endl; 

            }
	    freeZones( all_zones );
            cout << "--- enumInstanceNames () exited"  << endl; 
        } 
    }
    
  	
    void Linux_DnsHintZoneResourceAccess::enumInstances(
     const CmpiContext& ctx,
     const CmpiBroker &mbp,
     const char *nsp,
     const char* *properties,
  	 Linux_DnsHintZoneManualInstanceEnumeration& instances){
	cout << "Linux_DnsHintZoneResourceAccess::enumInstances()" << endl;
	cout << "--- enumInstances() called" << endl;

        DNSZONE * zones = NULL, *all_zones;

        cout << "---- calling getZones() " << endl;

        zones = getZones();	//getZonesByType("hint");
	all_zones = zones;

        if (zones)
        {
            for (; zones->zoneName != NULL ; zones++)
            {	    
                if ( strcmp(zones->zoneType, "hint") )
                        continue;

                Linux_DnsHintZoneManualInstance instance;
                Linux_DnsHintZoneInstanceName instanceName;

                cout << "--- Calling setInstanceNameProperties() for zone" << endl;

                printf (" -----%s \n", zones->zoneName);

                setInstanceNameProperties(ctx, mbp, nsp,
                                          zones, instanceName);

                cout << "--- Calling setInstanceProperties()" << endl;

                setInstanceProperties(ctx, mbp, zones,
                                      instanceName, instance);

                instances.addElement(instance);
                
		cout << "--- Added to enumeration"  << endl;
            }
	    freeZones( all_zones );
        }
        else
        {
            cout << "--- No Zones Found"  << endl;
        }

        cout << "--- enumInstances() exited"  << endl;
    }
  	
	
    Linux_DnsHintZoneManualInstance 
     Linux_DnsHintZoneResourceAccess::getInstance(
     const CmpiContext& ctx,
     const CmpiBroker &mbp,
     const char* *properties,
     const Linux_DnsHintZoneInstanceName& anInstanceName){
	cout << "--- getInstance() called" << endl; 

        DNSZONE * zones, *all_zones;
	Linux_DnsHintZoneManualInstance instance;

        cout << "---- calling getZones() " << endl;

        zones = getZones();	//getZonesByType("hint");
	all_zones = zones;
        if (zones)
        {
            for (; zones->zoneName != NULL ; zones++)
            {
                if ( strcmp(zones->zoneType, "hint") )
                        continue;

                cout << "--- zones->zoneName is "  << endl;
                printf ("%s \n", zones->zoneName);

                cout << "--- Name of Instance is "  << endl;
                printf ("%s \n", anInstanceName.getName());

                if ((strcmp(zones->zoneName, anInstanceName.getName())) == 0)
                {
                    cout << "--- Calling setInstanceProperties()" << endl; 
                    setInstanceProperties(ctx, mbp, zones,
                                          anInstanceName, instance);

                    cout << "--- getInstance() exited "  << endl; 

                    return instance; 
                }
            } // end for
	    freeZones( all_zones );
        }  // end if             
    }
  	
  	
    void Linux_DnsHintZoneResourceAccess::setInstance(
     const CmpiContext& ctx,
     const CmpiBroker &mbp,
     const char* *properties,
     const Linux_DnsHintZoneManualInstance& newInstance){

	cout << "--- setInstance() called" << endl;

        DNSZONE *zones, *myZone;

        zones = getZones();
        myZone = findZone(zones, newInstance.getInstanceName().getName());

        if ( ! myZone )
                throw CmpiStatus(CMPI_RC_ERR_NOT_FOUND,"Zone does not exist");

        if ( strcmp(myZone->zoneType,"forward") != 0 )
                throw CmpiStatus(CMPI_RC_ERR_NOT_FOUND,"Zone does not exist");

        if ( newInstance.isResourceRecordFileSet() ) {
                free(myZone->zoneFileName);
                myZone->zoneFileName = strdup(newInstance.getResourceRecordFile());
        }
        updateZones(zones);
	freeZones( zones );
    };
  	
  	
    void Linux_DnsHintZoneResourceAccess::createInstance(
     const CmpiContext& ctx, const CmpiBroker &mbp,
     const Linux_DnsHintZoneManualInstance& aManualInstance){
	
	cout << "--- createInstance() called" << endl;

	DNSZONE * newZone = NULL;
	Linux_DnsHintZoneInstanceName anInstanceName = aManualInstance.getInstanceName();
	
	if (((anInstanceName.getName()) == NULL) || ((anInstanceName.getName()) == "" ) || ((anInstanceName.getName()) =="") ) 
        {
            // throw exception that invalid key
            cout << "---- Zonename is invalid" << endl;
            throw CmpiStatus(CMPI_RC_ERR_INVALID_PARAMETER,"Zonename is invalid");

        }

        DNSZONE * all_zones = getZones();
        if ( findZone(all_zones,anInstanceName.getName()) )
        {
                freeZones(all_zones);
                throw CmpiStatus(CMPI_RC_ERR_INVALID_PARAMETER,"The zone already exist");
        }
        freeZones(all_zones);

	newZone = (DNSZONE *)calloc(1+1,sizeof(DNSZONE));
	if (newZone)
        {
		newZone->zoneName = (char *)anInstanceName.getName();

		newZone->zoneType = "hint"; 

            	cout << "---- newZone->zoneType is "<<  newZone->zoneType << endl;

            	if (aManualInstance.isResourceRecordFileSet()) {
                	newZone->zoneFileName = strdup(aManualInstance.getResourceRecordFile());
            	}
            	else {
                	char * buffer;
                	buffer = (char *)calloc((strlen(newZone->zoneType)+strlen(newZone->zoneName)+2),sizeof(char));
                	strcat(buffer, newZone->zoneType);
                	strcat(buffer, "/");
                	strcat(buffer, newZone->zoneName);
                	newZone->zoneFileName = buffer;
            	}

            	newZone->records = NULL;

		cout << "---- calling addZones() " << endl;
	
        	DNSZONE * returnedZones = NULL;

           	returnedZones = addZone(newZone, NULL);
            	if (!returnedZones)
            	{
                	cout <<"---- addZone() failed " << endl;
                	cout <<"---- createInstance Zone exited " << endl;
                	throw CmpiStatus(CMPI_RC_ERROR,"addZone() failed");
            	}
		freeZones( returnedZones );
            	cout <<"---- createInstance Zone exited " << endl;

	}
    };
  	
  	
    void Linux_DnsHintZoneResourceAccess::deleteInstance(
     const CmpiContext& ctx, const CmpiBroker &mbp,
     const Linux_DnsHintZoneInstanceName& inst){

        deleteZone( inst.getName() );

    };
	
    
    /* extrinsic methods */
    /*
    virtual CMPIUint32 Linux_DnsHintZoneResourceAccess::ApplyIncrementalChangeToCollection(
     const CmpiContext& ctx, const CmpiBroker &mbp,
     const Linux_DnsHintZoneInstanceName&,
      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_DnsHintZoneResourceAccess::ApplyIncrementalChangeToMSE(
     const CmpiContext& ctx, const CmpiBroker &mbp,
     const Linux_DnsHintZoneInstanceName&,
      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_DnsHintZoneResourceAccess::ApplyToCollection(
     const CmpiContext& ctx, const CmpiBroker &mbp,
     const Linux_DnsHintZoneInstanceName&,
      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_DnsHintZoneResourceAccess::ApplyToMSE(
     const CmpiContext& ctx, const CmpiBroker &mbp,
     const Linux_DnsHintZoneInstanceName&,
      const CIM_ManagedSystemElementInstanceName &MSE,
      int isMSEPresent,
      const CmpiDateTime &TimeToApply,
      int isTimeToApplyPresent,
      const CmpiDateTime &MustBeCompletedBy,
      int isMustBeCompletedByPresent) { };
    */
    /*
    virtual CMPIUint32 Linux_DnsHintZoneResourceAccess::VerifyOKToApplyIncrementalChangeToCollection(
     const CmpiContext& ctx, const CmpiBroker &mbp,
     const Linux_DnsHintZoneInstanceName&,
      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_DnsHintZoneResourceAccess::VerifyOKToApplyIncrementalChangeToMSE(
     const CmpiContext& ctx, const CmpiBroker &mbp,
     const Linux_DnsHintZoneInstanceName&,
      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_DnsHintZoneResourceAccess::VerifyOKToApplyToCollection(
     const CmpiContext& ctx, const CmpiBroker &mbp,
     const Linux_DnsHintZoneInstanceName&,
      const CIM_CollectionOfMSEsInstanceName &Collection,
      int isCollectionPresent,
      const CmpiDateTime &TimeToApply,
      int isTimeToApplyPresent,
      const CmpiDateTime &MustBeCompletedBy,
      int isMustBeCompletedByPresent,
      char** &CanNotApply,
      CMPICount &CanNotApplySize) { };
    */
    /*
    virtual CMPIUint32 Linux_DnsHintZoneResourceAccess::VerifyOKToApplyToMSE(
     const CmpiContext& ctx, const CmpiBroker &mbp,
     const Linux_DnsHintZoneInstanceName&,
      const CIM_ManagedSystemElementInstanceName &MSE,
      int isMSEPresent,
      const CmpiDateTime &TimeToApply,
      int isTimeToApplyPresent,
      const CmpiDateTime &MustBeCompletedBy,
      int isMustBeCompletedByPresent) { };
    */
    
    CMPIUint32 Linux_DnsHintZoneResourceAccess::disable(
     const CmpiContext& ctx, const CmpiBroker &mbp,
     const Linux_DnsHintZoneInstanceName& inst) {

        if ( inst.getName() == NULL )
                return 3;

        disableZone( inst.getName() );
    };
    
    
    CMPIUint32 Linux_DnsHintZoneResourceAccess::enable(
     const CmpiContext& ctx, const CmpiBroker &mbp,
     const Linux_DnsHintZoneInstanceName& inst) {

        if ( inst.getName() == NULL )
                return 3;

        enableZone( inst.getName() );

     };
    
	
}



--- NEW FILE: CmpiLinux_DnsHintZoneProvider.cpp ---
 /**
 * CmpiLinux_DnsHintZoneProvider.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 "CmpiLinux_DnsHintZoneProvider.h"
#include "ArrayConverter.h"
#include "Linux_DnsHintZoneManualInstance.h"
#include "Linux_DnsHintZoneRepositoryInstance.h"

#include <iostream>
#include <strings.h>

using namespace std;

namespace genProvider {

  CmpiLinux_DnsHintZoneProvider::
   CmpiLinux_DnsHintZoneProvider (
   const CmpiBroker &mbp, const CmpiContext& ctx):
    CmpiBaseMI(mbp, ctx), CmpiInstanceMI(mbp,ctx),
    CmpiMethodMI(mbp,ctx), cppBroker(mbp) {
      
      interfaceP=Linux_DnsHintZoneFactory::getImplementation();           
      cout<<"Provider was constructed"<<endl;
  };
    
        
  const char * CmpiLinux_DnsHintZoneProvider::
   shadowNameSpaceP="IBMShadow/cimv2";
        
  CmpiLinux_DnsHintZoneProvider::
   ~CmpiLinux_DnsHintZoneProvider(){
	  delete interfaceP;
  };
  
  int CmpiLinux_DnsHintZoneProvider::isUnloadable() const{
    return 0;
  }
	
  /* -----------------------------------------------------------------------*/
  /*                       Adding shadow properties                         */
  /* -----------------------------------------------------------------------*/

  void CmpiLinux_DnsHintZoneProvider::completeInstance(
   const Linux_DnsHintZoneInstanceName& instanceName,
   CmpiInstance& target, const CmpiContext& ctx){
	  	
    Linux_DnsHintZoneInstanceName shadowInstanceName(instanceName);
    shadowInstanceName.setNamespace(shadowNameSpaceP);
    CmpiObjectPath cmpiObjectPath=shadowInstanceName.getObjectPath();
	  
    try{
      const char* propertiesP=0;
      CmpiInstance shadowInstance=cppBroker.getInstance (
       ctx, cmpiObjectPath,&propertiesP);
      copyShadowData(&shadowInstance,&target);
    }catch(const CmpiStatus& rc){};                             
  };
	
	
  void CmpiLinux_DnsHintZoneProvider::copyShadowData (
   const CmpiInstance* source, CmpiInstance* target){
    
	  
  };
    
  /* -----------------------------------------------------------------------*/
  /*                       Extracting shadow instance                         */
  /* -----------------------------------------------------------------------*/

  CmpiInstance* CmpiLinux_DnsHintZoneProvider::
   getShadowInstance (const CmpiInstance& original,
   const Linux_DnsHintZoneInstanceName& instanceName){
     
    Linux_DnsHintZoneInstanceName shadowInstanceName(instanceName);
    shadowInstanceName.setNamespace(shadowNameSpaceP);
    CmpiObjectPath cmpiObjectPath=shadowInstanceName.getObjectPath();
      
    CmpiInstance* targetP=new CmpiInstance(cmpiObjectPath);
      
    copyShadowData(&original,targetP);
      
    if(targetP->getPropertyCount()==0)
      return 0;
    else
      return targetP;
  }

  /* -----------------------------------------------------------------------*/
  /*                          House keeping                              */
  /* -----------------------------------------------------------------------*/

  void CmpiLinux_DnsHintZoneProvider::removeDanglingShadowInstances (
   const Linux_DnsHintZoneInstanceNameEnumeration& dinInsNames){
	
    //TODO: enumerate shadow instance names and remove those not included
	// in dinInsNames
	
  };	 	
	
  /* -----------------------------------------------------------------------*/
  /*                          Provider Factory                              */
  /* -----------------------------------------------------------------------*/

  CMProviderBase(CmpiLinux_DnsHintZoneProvider);

  CMInstanceMIFactory(
   CmpiLinux_DnsHintZoneProvider, CmpiLinux_DnsHintZoneProvider);

  CMMethodMIFactory(
   CmpiLinux_DnsHintZoneProvider, CmpiLinux_DnsHintZoneProvider);

	
	
  /* -----------------------------------------------------------------------*/
  /*                      Instance Provider Interface                       */
  /* -----------------------------------------------------------------------*/

  //enumInstanceNames
	
  CmpiStatus CmpiLinux_DnsHintZoneProvider::enumInstanceNames (
   const CmpiContext& ctx, CmpiResult& rslt,
   const CmpiObjectPath& cop){
      
    cout<<"enumerating instanceNames"<<endl;
    CmpiString nameSpace=cop.getNameSpace();
    const char* nameSpaceP=nameSpace.charPtr();

    Linux_DnsHintZoneInstanceNameEnumeration enumeration;
    interfaceP->enumInstanceNames(ctx, cppBroker, nameSpaceP, enumeration);
                   
    while ( enumeration.hasNext() ){
      const Linux_DnsHintZoneInstanceName& instanceName=
      enumeration.getNext();
        
      CmpiObjectPath objectPath=instanceName.getObjectPath();
        
      rslt.returnData(objectPath);
    }
      
    //we make housekeeping
    removeDanglingShadowInstances(enumeration);
      
    rslt.returnDone();
    return CmpiStatus(CMPI_RC_OK);
  };
     
     
  //enumInstances
     
  CmpiStatus CmpiLinux_DnsHintZoneProvider::enumInstances (
   const CmpiContext& ctx, CmpiResult& rslt,
   const CmpiObjectPath& cop, const char* *properties){
     
    cout<<"enumerating instances"<<endl;
    CmpiString nameSpace=cop.getNameSpace();
    const char* nameSpaceP=nameSpace.charPtr();
      
    Linux_DnsHintZoneManualInstanceEnumeration enumeration;
    interfaceP->enumInstances(ctx, cppBroker, nameSpaceP, properties, enumeration);
      
    cout<<"enumerated"<<endl;
      
    while ( enumeration.hasNext() ){
      	
   	  const Linux_DnsHintZoneManualInstance& instance=
       enumeration.getNext();
      	
      cout<<"enumerating getNext"<<endl;
      	
      CmpiInstance cmpiInstance=instance.getCmpiInstance(properties);
      cout<<"transformed"<<endl;
      	
      //add the static data
      completeInstance(instance.getInstanceName(),cmpiInstance,ctx);
      	
      rslt.returnData(cmpiInstance);
    }
      
    rslt.returnDone();
    return CmpiStatus(CMPI_RC_OK);
  };
    
    
  //getInstance
    
  CmpiStatus CmpiLinux_DnsHintZoneProvider::getInstance (
   const CmpiContext& ctx, CmpiResult& rslt,
   const CmpiObjectPath& cop, const char* *properties){
     	
    //covert to instanceName
    Linux_DnsHintZoneInstanceName instanceName(cop);
      
    //get instance for instanceName
    Linux_DnsHintZoneManualInstance instance;
    instance=interfaceP->getInstance(ctx, cppBroker, properties, instanceName);
      
    //we convert the instance in a cmpiInstance
    CmpiInstance cmpiInstance=instance.getCmpiInstance(properties);
      
    //add the static data
    completeInstance(instance.getInstanceName(), cmpiInstance, ctx);
      
    rslt.returnData(cmpiInstance);
      
    rslt.returnDone();
    return CmpiStatus(CMPI_RC_OK);
  };
    
    
  CmpiStatus CmpiLinux_DnsHintZoneProvider::createInstance (
   const CmpiContext& ctx, CmpiResult& rslt,
   const CmpiObjectPath& cop,const CmpiInstance& inst){
   	
   	Linux_DnsHintZoneManualInstance instance (
     inst,cop.getNameSpace().charPtr());
    
    //REPOSITORY DATA    
    CmpiInstance* backupShadowInstance=0;
   	CmpiInstance shadowInstance=
     Linux_DnsHintZoneRepositoryInstance(inst,shadowNameSpaceP)
     .getCmpiInstance(0);     
     
   	//We keep a backup of the existing data for recovering previous
   	//state if the resource access raise an exception
   	CmpiObjectPath shadowOp=shadowInstance.getObjectPath();
    try{
   	  backupShadowInstance=new CmpiInstance(
   	   cppBroker.getInstance (ctx, shadowOp,0));
   	  //if the shadow instance exist we delete it
   	  cppBroker.deleteInstance(ctx, shadowOp);   	    
   	}catch(CmpiStatus& rc){};
    
    cppBroker.createInstance(ctx, shadowOp,shadowInstance);     
         	
    
    //RESOURCE ACCESS DATA   
    try{
      interfaceP->createInstance(ctx, cppBroker, instance);
    }catch(CmpiStatus& rc){
      //If something went wrong we recover the previous state
      cppBroker.deleteInstance(ctx, shadowOp);
      if(backupShadowInstance){
        cppBroker.createInstance(ctx, shadowOp,*backupShadowInstance);
      }
    }

    // ---- temp fix ?? for problem: ecute creteInstance does not return op
/*
    const char * nsp="root/cimv2";
    CmpiObjectPath op(nsp,"Linux_DnsHintZone");
    op.setKey("Name","r1company");
    rslt.returnData(op);
*/

    rslt.returnData( instance.getInstanceName().getObjectPath() );
    //
 
    if(backupShadowInstance)
      delete(backupShadowInstance);
    
    rslt.returnDone();
    return CmpiStatus(CMPI_RC_OK);
  };
    
    
  CmpiStatus CmpiLinux_DnsHintZoneProvider::setInstance (
   const CmpiContext& ctx, CmpiResult& rslt,
   const CmpiObjectPath& cop, const CmpiInstance& inst,
   const char* *properties){
   	
   	Linux_DnsHintZoneManualInstance instance (
     inst,cop.getNameSpace().charPtr());
    
    //REPOSITORY DATA    
    CmpiInstance* backupShadowInstance=0;
    CmpiInstance shadowInstance=
     Linux_DnsHintZoneRepositoryInstance(inst,shadowNameSpaceP)
     .getCmpiInstance(0);     
     
   	//We keep a backup of the existing data for recovering previous
   	//state if the resource access raise an exception
   	CmpiObjectPath shadowOp=shadowInstance.getObjectPath();
    try{
   	  backupShadowInstance=new CmpiInstance(
   	   cppBroker.getInstance (ctx, shadowOp,0));
   	}catch(CmpiStatus& rc){
	      throw rc;
        };   	
    
    //if the instance existed before we delete it
    //(setInstance is buggy in Pegasus)
    if(backupShadowInstance)
      cppBroker.setInstance(ctx, shadowOp,shadowInstance,properties);
    else
      cppBroker.createInstance(ctx, shadowOp,shadowInstance);      
    
    
    //RESOURCE ACCESS DATA   
    try{
      interfaceP->setInstance(ctx, cppBroker, properties, instance);
    }catch(CmpiStatus& rc){
      //If something went wrong we recover the previous state
      cppBroker.deleteInstance(ctx, shadowOp);
      if(backupShadowInstance){
        cppBroker.createInstance(ctx, shadowOp,*backupShadowInstance);
      }
    };
      
    if(backupShadowInstance)
      delete(backupShadowInstance);
        
    rslt.returnDone();
    return CmpiStatus(CMPI_RC_OK);
  };
    
    
  CmpiStatus CmpiLinux_DnsHintZoneProvider::deleteInstance (
   const CmpiContext& ctx, CmpiResult& rslt,
   const CmpiObjectPath& cop){
      
    Linux_DnsHintZoneInstanceName instanceName=
     Linux_DnsHintZoneInstanceName(cop);
    interfaceP->deleteInstance(ctx, cppBroker, instanceName);

    instanceName.setNamespace(shadowNameSpaceP);
    CmpiObjectPath op=instanceName.getObjectPath();
      
    try{  //The instance could not have static data
      cppBroker.deleteInstance(ctx, op);
    }catch(CmpiStatus& rc){
      throw rc;
    };
      
    rslt.returnDone();
    return CmpiStatus(CMPI_RC_OK);
  };
    
    
  CmpiStatus CmpiLinux_DnsHintZoneProvider::invokeMethod (
   const CmpiContext& ctx, CmpiResult& rslt,
   const CmpiObjectPath& ref, const char* methodName,
   const CmpiArgs& in, CmpiArgs& out){
     	
    Linux_DnsHintZoneInstanceName instanceName=
     Linux_DnsHintZoneInstanceName(ref);
     
    if (strcasecmp(methodName,"ApplyIncrementalChangeToCollection")==0){
        cout<<"executing method ApplyIncrementalChangeToCollection"<<endl;
        
        int isCollectionPresent=0;
        CIM_CollectionOfMSEsInstanceName  Collection;
        try{
        CmpiData CollectionCmpiData=in.getArg("Collection");
        isCollectionPresent=!CollectionCmpiData.isNullValue();
        CmpiObjectPath CollectionCmpi=CollectionCmpiData;
        Collection=CIM_CollectionOfMSEsInstanceName(CollectionCmpi);
        }catch(const CmpiStatus& rc){
        //parameter not present
          
        };
        int isTimeToApplyPresent=0;
        CmpiDateTime TimeToApply;
        try{
        CmpiData TimeToApplyCmpiData=in.getArg("TimeToApply");
        isTimeToApplyPresent=!TimeToApplyCmpiData.isNullValue();
         TimeToApply=TimeToApplyCmpiData;
        }catch(const CmpiStatus& rc){
        //parameter not present
          
        };
        int isContinueOnErrorPresent=0;
        CMPIBoolean ContinueOnError;
        try{
        CmpiData ContinueOnErrorCmpiData=in.getArg("ContinueOnError");
        isContinueOnErrorPresent=!ContinueOnErrorCmpiData.isNullValue();
         ContinueOnError=ContinueOnErrorCmpiData;
        }catch(const CmpiStatus& rc){
        //parameter not present
          
        };
        int isMustBeCompletedByPresent=0;
        CmpiDateTime MustBeCompletedBy;
        try{
        CmpiData MustBeCompletedByCmpiData=in.getArg("MustBeCompletedBy");
        isMustBeCompletedByPresent=!MustBeCompletedByCmpiData.isNullValue();
         MustBeCompletedBy=MustBeCompletedByCmpiData;
        }catch(const CmpiStatus& rc){
        //parameter not present
          
        };
        int isPropertiesToApplyPresent=0;
        char** PropertiesToApply=0;
        CMPICount PropertiesToApplySize;
        try{
        CmpiData PropertiesToApplyCmpiData=in.getArg("PropertiesToApply");
        isPropertiesToApplyPresent=!PropertiesToApplyCmpiData.isNullValue();
        CmpiArray PropertiesToApplyCmpi=PropertiesToApplyCmpiData;
        PropertiesToApplySize=PropertiesToApplyCmpi.size();
        ArrayConverter::makeArray(PropertiesToApplyCmpi,
         &PropertiesToApply, PropertiesToApplySize);
        }catch(const CmpiStatus& rc){
        //parameter not present
          
        };char** CanNotApply;
        CMPICount CanNotApplySize;
                
        rslt.returnData(CmpiData(interfaceP->ApplyIncrementalChangeToCollection(
         ctx,
         cppBroker,
         instanceName,
         Collection,
         isCollectionPresent,
         TimeToApply,
         isTimeToApplyPresent,
         ContinueOnError,
         isContinueOnErrorPresent,
         MustBeCompletedBy,
         isMustBeCompletedByPresent,
         (const char**) PropertiesToApply,
         PropertiesToApplySize,
         isPropertiesToApplyPresent,
         CanNotApply,
         CanNotApplySize)));
        out.setArg("CanNotApply", CmpiData(ArrayConverter::makeCmpiArray((const char**) CanNotApply, CanNotApplySize)));
        if(PropertiesToApply)
          ArrayConverter::destructArray(PropertiesToApply, PropertiesToApplySize);
        if(CanNotApply)
          ArrayConverter::destructArray(CanNotApply, CanNotApplySize);
        cout<<"end of method ApplyIncrementalChangeToCollection"<<endl;     
      }else if (strcasecmp(methodName,"ApplyIncrementalChangeToMSE")==0){
        cout<<"executing method ApplyIncrementalChangeToMSE"<<endl;
        
        int isMSEPresent=0;
        CIM_ManagedSystemElementInstanceName  MSE;
        try{
        CmpiData MSECmpiData=in.getArg("MSE");
        isMSEPresent=!MSECmpiData.isNullValue();
        CmpiObjectPath MSECmpi=MSECmpiData;
        MSE=CIM_ManagedSystemElementInstanceName(MSECmpi);
        }catch(const CmpiStatus& rc){
        //parameter not present
          
        };
        int isTimeToApplyPresent=0;
        CmpiDateTime TimeToApply;
        try{
        CmpiData TimeToApplyCmpiData=in.getArg("TimeToApply");
        isTimeToApplyPresent=!TimeToApplyCmpiData.isNullValue();
         TimeToApply=TimeToApplyCmpiData;
        }catch(const CmpiStatus& rc){
        //parameter not present
          
        };
        int isMustBeCompletedByPresent=0;
        CmpiDateTime MustBeCompletedBy;
        try{
        CmpiData MustBeCompletedByCmpiData=in.getArg("MustBeCompletedBy");
        isMustBeCompletedByPresent=!MustBeCompletedByCmpiData.isNullValue();
         MustBeCompletedBy=MustBeCompletedByCmpiData;
        }catch(const CmpiStatus& rc){
        //parameter not present
          
        };
        int isPropertiesToApplyPresent=0;
        char** PropertiesToApply=0;
        CMPICount PropertiesToApplySize;
        try{
        CmpiData PropertiesToApplyCmpiData=in.getArg("PropertiesToApply");
        isPropertiesToApplyPresent=!PropertiesToApplyCmpiData.isNullValue();
        CmpiArray PropertiesToApplyCmpi=PropertiesToApplyCmpiData;
        PropertiesToApplySize=PropertiesToApplyCmpi.size();
        ArrayConverter::makeArray(PropertiesToApplyCmpi,
         &PropertiesToApply, PropertiesToApplySize);
        }catch(const CmpiStatus& rc){
        //parameter not present
          
        };        
        rslt.returnData(CmpiData(interfaceP->ApplyIncrementalChangeToMSE(
         ctx,
         cppBroker,
         instanceName,
         MSE,
         isMSEPresent,
         TimeToApply,
         isTimeToApplyPresent,
         MustBeCompletedBy,
         isMustBeCompletedByPresent,
         (const char**) PropertiesToApply,
         PropertiesToApplySize,
         isPropertiesToApplyPresent)));
        if(PropertiesToApply)
          ArrayConverter::destructArray(PropertiesToApply, PropertiesToApplySize);
        cout<<"end of method ApplyIncrementalChangeToMSE"<<endl;     
      }else if (strcasecmp(methodName,"ApplyToCollection")==0){
        cout<<"executing method ApplyToCollection"<<endl;
        
        int isCollectionPresent=0;
        CIM_CollectionOfMSEsInstanceName  Collection;
        try{
        CmpiData CollectionCmpiData=in.getArg("Collection");
        isCollectionPresent=!CollectionCmpiData.isNullValue();
        CmpiObjectPath CollectionCmpi=CollectionCmpiData;
        Collection=CIM_CollectionOfMSEsInstanceName(CollectionCmpi);
        }catch(const CmpiStatus& rc){
        //parameter not present
          
        };
        int isTimeToApplyPresent=0;
        CmpiDateTime TimeToApply;
        try{
        CmpiData TimeToApplyCmpiData=in.getArg("TimeToApply");
        isTimeToApplyPresent=!TimeToApplyCmpiData.isNullValue();
         TimeToApply=TimeToApplyCmpiData;
        }catch(const CmpiStatus& rc){
        //parameter not present
          
        };
        int isContinueOnErrorPresent=0;
        CMPIBoolean ContinueOnError;
        try{
        CmpiData ContinueOnErrorCmpiData=in.getArg("ContinueOnError");
        isContinueOnErrorPresent=!ContinueOnErrorCmpiData.isNullValue();
         ContinueOnError=ContinueOnErrorCmpiData;
        }catch(const CmpiStatus& rc){
        //parameter not present
          
        };
        int isMustBeCompletedByPresent=0;
        CmpiDateTime MustBeCompletedBy;
        try{
        CmpiData MustBeCompletedByCmpiData=in.getArg("MustBeCompletedBy");
        isMustBeCompletedByPresent=!MustBeCompletedByCmpiData.isNullValue();
         MustBeCompletedBy=MustBeCompletedByCmpiData;
        }catch(const CmpiStatus& rc){
        //parameter not present
          
        };char** CanNotApply;
        CMPICount CanNotApplySize;
                
        rslt.returnData(CmpiData(interfaceP->ApplyToCollection(
         ctx,
         cppBroker,
         instanceName,
         Collection,
         isCollectionPresent,
         TimeToApply,
         isTimeToApplyPresent,
         ContinueOnError,
         isContinueOnErrorPresent,
         MustBeCompletedBy,
         isMustBeCompletedByPresent,
         CanNotApply,
         CanNotApplySize)));
        out.setArg("CanNotApply", CmpiData(ArrayConverter::makeCmpiArray((const char**) CanNotApply, CanNotApplySize)));
        if(CanNotApply)
          ArrayConverter::destructArray(CanNotApply, CanNotApplySize);
        cout<<"end of method ApplyToCollection"<<endl;     
      }else if (strcasecmp(methodName,"ApplyToMSE")==0){
        cout<<"executing method ApplyToMSE"<<endl;
        
        int isMSEPresent=0;
        CIM_ManagedSystemElementInstanceName  MSE;
        try{
        CmpiData MSECmpiData=in.getArg("MSE");
        isMSEPresent=!MSECmpiData.isNullValue();
        CmpiObjectPath MSECmpi=MSECmpiData;
        MSE=CIM_ManagedSystemElementInstanceName(MSECmpi);
        }catch(const CmpiStatus& rc...
 
[truncated message content]