[Sblim-commit] cmpi-dns/provider/Linux_DnsMasterZone Linux_DnsMasterZoneRepositoryExternal.cpp,NONE,1.1 setting.provider,NONE,1.1 Linux_DnsMasterZoneInstanceName.h,NONE,1.1 Linux_DnsMasterZoneRepositoryInstance.h,NONE,1.1 makefile,NONE,1.1 Linux_DnsMasterZoneDefaultImplementation.h,NONE,1.1 Linux_DnsMasterZoneInstanceName.cpp,NONE,1.1 Linux_DnsMasterZoneInstance.cpp,NONE,1.1 Linux_DnsMasterZoneInstance.h,NONE,1.1 Linux_DnsMasterZoneExternal.cpp,NONE,1.1 Linux_DnsMasterZoneFactory.h,NONE,1.1 Linux_DnsMasterZoneResourceAccess.cpp,NONE,1.1 Linux_DnsMasterZoneDefaultImplementation.cpp,NONE,1.1 Linux_DnsMasterZoneManualInstance.cpp,NONE,1.1 Linux_DnsMasterZoneFactory.cpp,NONE,1.1 CmpiLinux_DnsMasterZoneProvider.h,NONE,1.1 Linux_DnsMasterZoneResourceAccess.h,NONE,1.1 Linux_DnsMasterZoneManualInstance.h,NONE,1.1 CmpiLinux_DnsMasterZoneProvider.cpp,NONE,1.1 Linux_DnsMasterZoneFakeFactory.cpp,NONE,1.1 Linux_DnsMasterZoneRepositoryExternal.h,NONE,1.1 Linux_DnsMasterZoneInterface.h,NONE,1.1 Linux_DnsMasterZoneExternal.h,NONE,1.1 Linux_DnsMasterZoneRepositoryInstance.cpp,NONE,1.1

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

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

Added Files:
	Linux_DnsMasterZoneRepositoryExternal.cpp setting.provider 
	Linux_DnsMasterZoneInstanceName.h 
	Linux_DnsMasterZoneRepositoryInstance.h makefile 
	Linux_DnsMasterZoneDefaultImplementation.h 
	Linux_DnsMasterZoneInstanceName.cpp 
	Linux_DnsMasterZoneInstance.cpp Linux_DnsMasterZoneInstance.h 
	Linux_DnsMasterZoneExternal.cpp Linux_DnsMasterZoneFactory.h 
	Linux_DnsMasterZoneResourceAccess.cpp 
	Linux_DnsMasterZoneDefaultImplementation.cpp 
	Linux_DnsMasterZoneManualInstance.cpp 
	Linux_DnsMasterZoneFactory.cpp 
	CmpiLinux_DnsMasterZoneProvider.h 
	Linux_DnsMasterZoneResourceAccess.h 
	Linux_DnsMasterZoneManualInstance.h 
	CmpiLinux_DnsMasterZoneProvider.cpp 
	Linux_DnsMasterZoneFakeFactory.cpp 
	Linux_DnsMasterZoneRepositoryExternal.h 
	Linux_DnsMasterZoneInterface.h Linux_DnsMasterZoneExternal.h 
	Linux_DnsMasterZoneRepositoryInstance.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_DnsMasterZoneInstance.cpp ---
 /**
 * Linux_DnsMasterZoneInstance.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_DnsMasterZoneInstance.h"
#include "CmpiData.h"
#include "CmpiString.h"
#include "CmpiArray.h"
#include <string>

namespace genProvider {

  //*********************************************************
  //Linux_DnsMasterZoneInstance
  //*********************************************************

  //empty constructor
  Linux_DnsMasterZoneInstance::
   Linux_DnsMasterZoneInstance(){   	
   	init();  	   	
  };
  
  
  //copy constructor	
  Linux_DnsMasterZoneInstance::
   Linux_DnsMasterZoneInstance
   (const Linux_DnsMasterZoneInstance& original){   	
   	init(original);  	   	
  };
  
  
  //constructor using CmpiInstance
  Linux_DnsMasterZoneInstance::
   Linux_DnsMasterZoneInstance (const CmpiInstance& inst, const char* instanceNamespace){
    CmpiData cmpiData;
    init(); 
    
    CmpiObjectPath cop=inst.getObjectPath();
    cop.setNameSpace(instanceNamespace);
    setInstanceName(Linux_DnsMasterZoneInstanceName(cop));
    
    cmpiData = inst.getProperty("Caption");
    if(!cmpiData.isNullValue()){
      CmpiString Caption = cmpiData;
      setCaption(Caption.charPtr());
    }
    
    cmpiData = inst.getProperty("Contact");
    if(!cmpiData.isNullValue()){
      CmpiString Contact = cmpiData;
      setContact(Contact.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("Expire");
    if(!cmpiData.isNullValue()){
      CMPIUint32 Expire = cmpiData;
      setExpire(Expire);
    }
    
    cmpiData = inst.getProperty("Forward");
    if(!cmpiData.isNullValue()){
      CMPIUint16 Forward = cmpiData;
      setForward(Forward);
    }
    
    cmpiData = inst.getProperty("Forwarders");
    if(!cmpiData.isNullValue()){
      CmpiArray Forwarders = cmpiData;
      unsigned int ForwardersSize;
      const char** ForwardersArray;
      ArrayConverter::makeArray(Forwarders, (char***)&ForwardersArray, ForwardersSize);
      setForwarders(ForwardersArray, ForwardersSize, 0);
    }
    
    cmpiData = inst.getProperty("NegativeCachingTTL");
    if(!cmpiData.isNullValue()){
      CMPIUint32 NegativeCachingTTL = cmpiData;
      setNegativeCachingTTL(NegativeCachingTTL);
    }
    
    cmpiData = inst.getProperty("Refresh");
    if(!cmpiData.isNullValue()){
      CMPIUint32 Refresh = cmpiData;
      setRefresh(Refresh);
    }
    
    cmpiData = inst.getProperty("ResourceRecordFile");
    if(!cmpiData.isNullValue()){
      CmpiString ResourceRecordFile = cmpiData;
      setResourceRecordFile(ResourceRecordFile.charPtr());
    }
    
    cmpiData = inst.getProperty("Retry");
    if(!cmpiData.isNullValue()){
      CMPIUint32 Retry = cmpiData;
      setRetry(Retry);
    }
    
    cmpiData = inst.getProperty("SerialNumber");
    if(!cmpiData.isNullValue()){
      CmpiString SerialNumber = cmpiData;
      setSerialNumber(SerialNumber.charPtr());
    }
    
    cmpiData = inst.getProperty("Server");
    if(!cmpiData.isNullValue()){
      CmpiString Server = cmpiData;
      setServer(Server.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_DnsMasterZoneInstance::
   ~Linux_DnsMasterZoneInstance(){
   	reset();  	  
  };
  
  
  //copy operator
  Linux_DnsMasterZoneInstance&
   Linux_DnsMasterZoneInstance::operator=
   (const Linux_DnsMasterZoneInstance& original){   	
   	init(original);
   	return *this;
  };
  
  
  //converts to CmpiInstance
  CmpiInstance Linux_DnsMasterZoneInstance::
   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.Contact){
  	  cmpiInstance.setProperty("Contact",CmpiData(m_Contact));
  	}

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

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

  	if(isSet.Expire){
  	  cmpiInstance.setProperty("Expire",CmpiData(m_Expire));
  	}

  	if(isSet.Forward){
  	  cmpiInstance.setProperty("Forward",CmpiData(m_Forward));
  	}

  	if(isSet.Forwarders){
  	  unsigned int ForwardersSize;
      const char** arrayForwarders=getForwarders(ForwardersSize);
      CmpiArray arrayCmpiForwarders=CmpiArray(ForwardersSize,CMPI_chars);
      for(unsigned int i=0;i<ForwardersSize;i++)
        arrayCmpiForwarders[i]=CmpiData(arrayForwarders[i]);
  	cmpiInstance.setProperty("Forwarders",CmpiData(arrayCmpiForwarders));
  	}

  	if(isSet.NegativeCachingTTL){
  	  cmpiInstance.setProperty("NegativeCachingTTL",CmpiData(m_NegativeCachingTTL));
  	}

  	if(isSet.Refresh){
  	  cmpiInstance.setProperty("Refresh",CmpiData(m_Refresh));
  	}

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

  	if(isSet.Retry){
  	  cmpiInstance.setProperty("Retry",CmpiData(m_Retry));
  	}

  	if(isSet.SerialNumber){
  	  cmpiInstance.setProperty("SerialNumber",CmpiData(m_SerialNumber));
  	}

  	if(isSet.Server){
  	  cmpiInstance.setProperty("Server",CmpiData(m_Server));
  	}

  	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_DnsMasterZoneInstance::
   isInstanceNameSet() const{
  	return isSet.instanceName;
  }
  
  const Linux_DnsMasterZoneInstanceName&
    Linux_DnsMasterZoneInstance::getInstanceName() const{

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

  void Linux_DnsMasterZoneInstance::setInstanceName(
   const Linux_DnsMasterZoneInstanceName& val){
    m_instanceName = val;
    isSet.instanceName=1;
  }
       
  //Caption related methods
  unsigned int Linux_DnsMasterZoneInstance::isCaptionSet() const{
    return isSet.Caption;
  }
  void  Linux_DnsMasterZoneInstance::
   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_DnsMasterZoneInstance::
   getCaption() const{
    
    if(!isSet.Caption)
   	  throw CmpiErrorFormater::getErrorException(
   	   CmpiErrorFormater::NOT_SET,
   	   "Caption not set");
   	   	
    return m_Caption;
  }
       
  //Contact related methods
  unsigned int Linux_DnsMasterZoneInstance::isContactSet() const{
    return isSet.Contact;
  }
  void  Linux_DnsMasterZoneInstance::
   setContact(const char* val, int makeCopy){
    if (isSet.Contact) {
      delete []m_Contact;
    }
    if (makeCopy&&val) {
      char* tmpval = new char[strlen(val)+1];
      strcpy(tmpval,val);
      m_Contact = tmpval;
    } else {
      m_Contact = val;
    }
    isSet.Contact=1;
  }       
  const char* Linux_DnsMasterZoneInstance::
   getContact() const{
    
    if(!isSet.Contact)
   	  throw CmpiErrorFormater::getErrorException(
   	   CmpiErrorFormater::NOT_SET,
   	   "Contact not set");
   	   	
    return m_Contact;
  }
       
  //Description related methods
  unsigned int Linux_DnsMasterZoneInstance::isDescriptionSet() const{
    return isSet.Description;
  }
  void  Linux_DnsMasterZoneInstance::
   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_DnsMasterZoneInstance::
   getDescription() const{
    
    if(!isSet.Description)
   	  throw CmpiErrorFormater::getErrorException(
   	   CmpiErrorFormater::NOT_SET,
   	   "Description not set");
   	   	
    return m_Description;
  }
       
  //ElementName related methods
  unsigned int Linux_DnsMasterZoneInstance::isElementNameSet() const{
    return isSet.ElementName;
  }
  void  Linux_DnsMasterZoneInstance::
   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_DnsMasterZoneInstance::
   getElementName() const{
    
    if(!isSet.ElementName)
   	  throw CmpiErrorFormater::getErrorException(
   	   CmpiErrorFormater::NOT_SET,
   	   "ElementName not set");
   	   	
    return m_ElementName;
  }
       
  //Expire related methods
  unsigned int Linux_DnsMasterZoneInstance::isExpireSet() const{
    return isSet.Expire;
  }
  void Linux_DnsMasterZoneInstance::
   setExpire(const CMPIUint32 val){
    m_Expire = val;
    isSet.Expire=1;
  }       
  const CMPIUint32 Linux_DnsMasterZoneInstance::
   getExpire() const{
    
    if(!isSet.Expire)
   	  throw CmpiErrorFormater::getErrorException(
   	   CmpiErrorFormater::NOT_SET,
   	   "Expire not set");
   	   	
    return m_Expire;
  }
       
  //Forward related methods
  unsigned int Linux_DnsMasterZoneInstance::isForwardSet() const{
    return isSet.Forward;
  }
  void Linux_DnsMasterZoneInstance::
   setForward(const CMPIUint16 val){
    m_Forward = val;
    isSet.Forward=1;
  }       
  const CMPIUint16 Linux_DnsMasterZoneInstance::
   getForward() const{
    
    if(!isSet.Forward)
   	  throw CmpiErrorFormater::getErrorException(
   	   CmpiErrorFormater::NOT_SET,
   	   "Forward not set");
   	   	
    return m_Forward;
  }
       
  //Forwarders related methods
  unsigned int Linux_DnsMasterZoneInstance::isForwardersSet() const{
    return isSet.Forwarders;
  }
  void  Linux_DnsMasterZoneInstance::
   setForwarders(const char** val, const unsigned int size, int makeCopy){
    ForwardersArraySize=size;
    if (isSet.Forwarders) {
      delete m_Forwarders;
    }
    if (makeCopy&&val) {
      m_Forwarders = new const char*[size];
      for(unsigned int i=0;i<size;i++){
        char* aString = new char[strlen(val[i])+1];
        strcpy(aString,val[i]);
        m_Forwarders[i]=aString;
      }      
    } else {
      m_Forwarders = val;
    }
    isSet.Forwarders=1;
  }       
  const char** Linux_DnsMasterZoneInstance::
   getForwarders(unsigned int& size) const{
    
    if(!isSet.Forwarders)
   	  throw CmpiErrorFormater::getErrorException(
   	   CmpiErrorFormater::NOT_SET,
   	   "Forwarders not set");
   	   	
    size=ForwardersArraySize;
    return m_Forwarders;
  }
       
  //NegativeCachingTTL related methods
  unsigned int Linux_DnsMasterZoneInstance::isNegativeCachingTTLSet() const{
    return isSet.NegativeCachingTTL;
  }
  void Linux_DnsMasterZoneInstance::
   setNegativeCachingTTL(const CMPIUint32 val){
    m_NegativeCachingTTL = val;
    isSet.NegativeCachingTTL=1;
  }       
  const CMPIUint32 Linux_DnsMasterZoneInstance::
   getNegativeCachingTTL() const{
    
    if(!isSet.NegativeCachingTTL)
   	  throw CmpiErrorFormater::getErrorException(
   	   CmpiErrorFormater::NOT_SET,
   	   "NegativeCachingTTL not set");
   	   	
    return m_NegativeCachingTTL;
  }
       
  //Refresh related methods
  unsigned int Linux_DnsMasterZoneInstance::isRefreshSet() const{
    return isSet.Refresh;
  }
  void Linux_DnsMasterZoneInstance::
   setRefresh(const CMPIUint32 val){
    m_Refresh = val;
    isSet.Refresh=1;
  }       
  const CMPIUint32 Linux_DnsMasterZoneInstance::
   getRefresh() const{
    
    if(!isSet.Refresh)
   	  throw CmpiErrorFormater::getErrorException(
   	   CmpiErrorFormater::NOT_SET,
   	   "Refresh not set");
   	   	
    return m_Refresh;
  }
       
  //ResourceRecordFile related methods
  unsigned int Linux_DnsMasterZoneInstance::isResourceRecordFileSet() const{
    return isSet.ResourceRecordFile;
  }
  void  Linux_DnsMasterZoneInstance::
   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_DnsMasterZoneInstance::
   getResourceRecordFile() const{
    
    if(!isSet.ResourceRecordFile)
   	  throw CmpiErrorFormater::getErrorException(
   	   CmpiErrorFormater::NOT_SET,
   	   "ResourceRecordFile not set");
   	   	
    return m_ResourceRecordFile;
  }
       
  //Retry related methods
  unsigned int Linux_DnsMasterZoneInstance::isRetrySet() const{
    return isSet.Retry;
  }
  void Linux_DnsMasterZoneInstance::
   setRetry(const CMPIUint32 val){
    m_Retry = val;
    isSet.Retry=1;
  }       
  const CMPIUint32 Linux_DnsMasterZoneInstance::
   getRetry() const{
    
    if(!isSet.Retry)
   	  throw CmpiErrorFormater::getErrorException(
   	   CmpiErrorFormater::NOT_SET,
   	   "Retry not set");
   	   	
    return m_Retry;
  }
       
  //SerialNumber related methods
  unsigned int Linux_DnsMasterZoneInstance::isSerialNumberSet() const{
    return isSet.SerialNumber;
  }
  void  Linux_DnsMasterZoneInstance::
   setSerialNumber(const char* val, int makeCopy){
    if (isSet.SerialNumber) {
      delete []m_SerialNumber;
    }
    if (makeCopy&&val) {
      char* tmpval = new char[strlen(val)+1];
      strcpy(tmpval,val);
      m_SerialNumber = tmpval;
    } else {
      m_SerialNumber = val;
    }
    isSet.SerialNumber=1;
  }       
  const char* Linux_DnsMasterZoneInstance::
   getSerialNumber() const{
    
    if(!isSet.SerialNumber)
   	  throw CmpiErrorFormater::getErrorException(
   	   CmpiErrorFormater::NOT_SET,
   	   "SerialNumber not set");
   	   	
    return m_SerialNumber;
  }
       
  //Server related methods
  unsigned int Linux_DnsMasterZoneInstance::isServerSet() const{
    return isSet.Server;
  }
  void  Linux_DnsMasterZoneInstance::
   setServer(const char* val, int makeCopy){
    if (isSet.Server) {
      delete []m_Server;
    }
    if (makeCopy&&val) {
      char* tmpval = new char[strlen(val)+1];
      strcpy(tmpval,val);
      m_Server = tmpval;
    } else {
      m_Server = val;
    }
    isSet.Server=1;
  }       
  const char* Linux_DnsMasterZoneInstance::
   getServer() const{
    
    if(!isSet.Server)
   	  throw CmpiErrorFormater::getErrorException(
   	   CmpiErrorFormater::NOT_SET,
   	   "Server not set");
   	   	
    return m_Server;
  }
       
  //SettingID related methods
  unsigned int Linux_DnsMasterZoneInstance::isSettingIDSet() const{
    return isSet.SettingID;
  }
  void  Linux_DnsMasterZoneInstance::
   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_DnsMasterZoneInstance::
   getSettingID() const{
    
    if(!isSet.SettingID)
   	  throw CmpiErrorFormater::getErrorException(
   	   CmpiErrorFormater::NOT_SET,
   	   "SettingID not set");
   	   	
    return m_SettingID;
  }
       
  //Type related methods
  unsigned int Linux_DnsMasterZoneInstance::isTypeSet() const{
    return isSet.Type;
  }
  void Linux_DnsMasterZoneInstance::
   setType(const CMPIUint16 val){
    m_Type = val;
    isSet.Type=1;
  }       
  const CMPIUint16 Linux_DnsMasterZoneInstance::
   getType() const{
    
    if(!isSet.Type)
   	  throw CmpiErrorFormater::getErrorException(
   	   CmpiErrorFormater::NOT_SET,
   	   "Type not set");
   	   	
    return m_Type;
  }


  
  //set isSet attributes to FALSE
  void Linux_DnsMasterZoneInstance::init(){
   	isSet.instanceName=0;
   	   	
    isSet.Caption=0;   	
    isSet.Contact=0;   	
    isSet.Description=0;   	
    isSet.ElementName=0;   	
    isSet.Expire=0;   	
    isSet.Forward=0;   	
    isSet.Forwarders=0;   	
    ForwardersArraySize=0;   	
    isSet.NegativeCachingTTL=0;   	
    isSet.Refresh=0;   	
    isSet.ResourceRecordFile=0;   	
    isSet.Retry=0;   	
    isSet.SerialNumber=0;   	
    isSet.Server=0;   	
    isSet.SettingID=0;   	
    isSet.Type=0;  	
  };
  
  
  //copies another instance properties in this
  void Linux_DnsMasterZoneInstance::init
   (const Linux_DnsMasterZoneInstance& original){   	
   	init();
   	   	
    if(original.isInstanceNameSet()){
      setInstanceName(original.getInstanceName());
    }   	
    if(original.isCaptionSet()){
      const char* CaptionOriginal=original.getCaption();
      setCaption(CaptionOriginal, 1);
    }   	
    if(original.isContactSet()){
      const char* ContactOriginal=original.getContact();
      setContact(ContactOriginal, 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.isExpireSet()){
      const CMPIUint32 ExpireOriginal=original.getExpire();
      setExpire(ExpireOriginal);
    }   	
    if(original.isForwardSet()){
      const CMPIUint16 ForwardOriginal=original.getForward();
      setForward(ForwardOriginal);
    }   	
    if(original.isForwardersSet()){
      unsigned int sizeForwarders;
    const char** ForwardersOriginal=original.getForwarders(sizeForwarders);
      setForwarders(ForwardersOriginal, sizeForwarders, 1);
    }   	
    if(original.isNegativeCachingTTLSet()){
      const CMPIUint32 NegativeCachingTTLOriginal=original.getNegativeCachingTTL();
      setNegativeCachingTTL(NegativeCachingTTLOriginal);
    }   	
    if(original.isRefreshSet()){
      const CMPIUint32 RefreshOriginal=original.getRefresh();
      setRefresh(RefreshOriginal);
    }   	
    if(original.isResourceRecordFileSet()){
      const char* ResourceRecordFileOriginal=original.getResourceRecordFile();
      setResourceRecordFile(ResourceRecordFileOriginal, 1);
    }   	
    if(original.isRetrySet()){
      const CMPIUint32 RetryOriginal=original.getRetry();
      setRetry(RetryOriginal);
    }   	
    if(original.isSerialNumberSet()){
      const char* SerialNumberOriginal=original.getSerialNumber();
      setSerialNumber(SerialNumberOriginal, 1);
    }   	
    if(original.isServerSet()){
      const char* ServerOriginal=original.getServer();
      setServer(ServerOriginal, 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_DnsMasterZoneInstance::reset(){
   	

  	if (isSet.Caption)
  	  delete(m_Caption);

  	if (isSet.Contact)
  	  delete(m_Contact);

  	if (isSet.Description)
  	  delete(m_Description);

  	if (isSet.ElementName)
  	  delete(m_ElementName);

  	if (isSet.Forwarders){
  	  ArrayConverter::destructArray((char**)(char**)m_Forwarders,ForwardersArraySize);
  	}

  	if (isSet.ResourceRecordFile)
  	  delete(m_ResourceRecordFile);

  	if (isSet.SerialNumber)
  	  delete(m_SerialNumber);

  	if (isSet.Server)
  	  delete(m_Server);

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

  
  //*********************************************************
  //Linux_DnsMasterZoneInstanceNameEnumeration
  //*********************************************************

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

--- NEW FILE: Linux_DnsMasterZoneResourceAccess.cpp ---
 /**
 * Linux_DnsMasterZoneResourceAccess.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:      Tony Gargya <ga...@de...>
 * 		Murillo Bernardes <ber...@br...>
 *
 * Contributors:
 *
 */
#include <string>
#include <iostream>

using namespace std;

#include "Linux_DnsMasterZoneResourceAccess.h"

namespace genProvider {

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

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

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



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

	//ZONEOPTS* zoneOpts;
	ZONEOPTS * forward = findOptsInZone( zone, "forward" );
	if ( forward )
	{
		if ( strcmp( forward->value, "first" ) )
			aManualInstance.setForward( DNS_FORWARD_FIRST );
		
		if ( strcmp( forward->value, "only" ) )
                        aManualInstance.setForward( DNS_FORWARD_ONLY );
	}	

	ZONEOPTS * forwarders = findOptsInZone( zone, "forwarders" );
	DnsArray da;

	if ( forwarders && forwarders->value )
	{
		da.populate( forwarders->value ); 
		aManualInstance.setForwarders( da.toArray(), da.size() );
	}
        aManualInstance.setInstanceName(anInstanceName);

        aManualInstance.setType(DNS_ZONETYPE_MASTER);

	aManualInstance.setResourceRecordFile(zone->zoneFileName);
	
	aManualInstance.setContact(zone->soaContact);

	char *val = (char *) malloc( 12*sizeof(char) );
	sprintf(val,"%lld", zone->soaSerialNumber );
	aManualInstance.setSerialNumber( val );
	free(val);

        aManualInstance.setRefresh( zone->soaRefresh );
        aManualInstance.setRetry( zone->soaRetry );
        aManualInstance.setExpire( zone->soaExpire );
	aManualInstance.setServer( zone->soaServer );
        aManualInstance.setNegativeCachingTTL( zone->soaNegativCachingTTL );
        
        cout << "--- setInstanceProperties() exited" << endl;
    }
 
    //Linux_DnsMasterZoneResourceAccess::Linux_DnsMasterZoneResourceAccess();
    Linux_DnsMasterZoneResourceAccess::~Linux_DnsMasterZoneResourceAccess() { };
    
    /* intrinsic methods */
    
    void Linux_DnsMasterZoneResourceAccess::enumInstanceNames(
     const CmpiContext& ctx, const CmpiBroker &mbp, const char *nsp,
     Linux_DnsMasterZoneInstanceNameEnumeration& instnames)
     {
        DNSZONE * zones, *all_zones;

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

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

        if (zones)
        {
            for (; zones->zoneName != NULL ; zones++)
            {  
		if ( strcmp(zones->zoneType, "master") )
			continue;
 
                //Linux_DnsZoneManualInstance instance;
                Linux_DnsMasterZoneInstanceName 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_DnsMasterZoneResourceAccess::enumInstances(
     const CmpiContext& ctx,
     const CmpiBroker &mbp,
     const char *nsp,
     const char* *properties,
  	 Linux_DnsMasterZoneManualInstanceEnumeration& instances) 
    {
	cout << "Linux_DnsMasterZoneResourceAccess::enumInstances()" << endl;
        cout << "--- enumInstances() called" << endl;

        DNSZONE * zones = NULL, *all_zones;

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

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

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

                Linux_DnsMasterZoneManualInstance instance;
                Linux_DnsMasterZoneInstanceName 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_DnsMasterZoneManualInstance 
     Linux_DnsMasterZoneResourceAccess::getInstance(
     const CmpiContext& ctx,
     const CmpiBroker &mbp,
     const char* *properties,
     const Linux_DnsMasterZoneInstanceName& anInstanceName){
	
	cout << "--- getInstance() called" << endl; 

        DNSZONE *zones, *myZone;

	Linux_DnsMasterZoneManualInstance instance;

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

        zones = getZones();
	myZone = findZone(zones,anInstanceName.getName());

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

        setInstanceProperties(ctx, mbp, myZone, anInstanceName, instance);
        
	cout << "--- getInstance() exited "  << endl; 

	freeZones( zones );
        return instance;
    }
  	
  	
    void Linux_DnsMasterZoneResourceAccess::setInstance(
     const CmpiContext& ctx,
     const CmpiBroker &mbp,
     const char* *properties,
     const Linux_DnsMasterZoneManualInstance& newInstance){
	cout << "Linux_DnsMasterZoneResourceAccess::setInstance()" << endl;
	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,"master") != 0 )
		throw CmpiStatus(CMPI_RC_ERR_NOT_FOUND,"Zone does not exist");
	
	if ( newInstance.isResourceRecordFileSet() ) {
		free(myZone->zoneFileName);
		myZone->zoneFileName = strdup(newInstance.getResourceRecordFile());
	}
            
	if (newInstance.isContactSet())
	{
		free(myZone->soaContact);
            	myZone->soaContact = strdup( newInstance.getContact() );
	}

        if ( newInstance.isForwardSet() )
        {
		ZONEOPTS *zopts = findOptsInZone( myZone, "forward" );

		if ( zopts )
		{
			free( zopts->value );
        		if ( newInstance.getForward() == DNS_FORWARD_ONLY )
                        	zopts->value = strdup( "only" );

                	if ( newInstance.getForward() == DNS_FORWARD_FIRST )
                        	zopts->value = strdup( "first" );

		} 
		else
		{
        		if ( newInstance.getForward() == DNS_FORWARD_ONLY )
                        	addOptsToZone( myZone, "forward", "only" );

                	if ( newInstance.getForward() == DNS_FORWARD_FIRST )
                        	addOptsToZone( myZone, "forward", "first" );
		}
		
        }

        unsigned int size = 0;
        if ( newInstance.isForwardersSet() )
        {
		ZONEOPTS *zopts = findOptsInZone( myZone, "forwarders" );

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

		if ( zopts )
		{
			free( zopts->value );
			zopts->value = strdup ( value_list.toString().c_str() );
		}
		else
                	addOptsToZone( myZone,"forwarders", strdup( value_list.toString().c_str() ) );
        }
	    
	    // SerialNumber
	if (newInstance.isSerialNumberSet())
		myZone->soaSerialNumber = atoi(newInstance.getSerialNumber());
	
	    // Refresh
	if (newInstance.isRefreshSet())
	    	myZone->soaRefresh = newInstance.getRefresh();

	    // Retry	
	if (newInstance.isRetrySet())
		myZone->soaRetry = newInstance.getRetry();
	
	    // Expire
        if (newInstance.isExpireSet())
                myZone->soaExpire = newInstance.getExpire();
	    
	    // NegativeCachingTTL
        if (newInstance.isNegativeCachingTTLSet())
                myZone->soaNegativCachingTTL = newInstance.getNegativeCachingTTL();

	if (newInstance.isServerSet())
                myZone->soaServer = strdup( newInstance.getServer() );


	updateZones(zones);
	freeZones( zones );
	
	cout << "--- setInstance() exited "  << endl; 
    };
  	
  	
    void Linux_DnsMasterZoneResourceAccess::createInstance(
     const CmpiContext& ctx, const CmpiBroker &mbp,
     const Linux_DnsMasterZoneManualInstance& aManualInstance)
     {
     	cout << "--- createInstance() called" << endl; 

        DNSZONE * newZone = NULL;
        Linux_DnsMasterZoneInstanceName 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)
        {
            // Take in value specified only at Dialog ??//

            newZone->zoneName = (char *)anInstanceName.getName();

            newZone->zoneType = "master";
	    
            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;
	    }
            printf("---- zoneFileName  is %s \n", newZone->zoneFileName);
            
	    // Contact  
	    if (aManualInstance.isContactSet())
            	newZone->soaContact = (char *)aManualInstance.getContact();
	    else
		newZone->soaContact = "root";

            // if not at dialog then use following default required values (dnssupport.h) for a Zone 
            // may need to get them from default section in Service 
	    
	    // SerialNumber
	    if (aManualInstance.isSerialNumberSet())
	    	newZone->soaSerialNumber = atoi(aManualInstance.getSerialNumber());
	    else
            	newZone->soaSerialNumber = 2005040000;
	
	    // Refresh
	    if (aManualInstance.isRefreshSet())
	    	newZone->soaRefresh = aManualInstance.getRefresh();
	    else
	        newZone->soaRefresh = 60*60;

	    // Retry	
	    if (aManualInstance.isRetrySet())
		newZone->soaRetry = aManualInstance.getRetry();
	    else
	    	newZone->soaRetry = 3*60*60;
	
	    // Expire
            if (aManualInstance.isExpireSet())
                newZone->soaExpire = aManualInstance.getExpire();
            else
    	        newZone->soaExpire = 2*60*60;
	   
	    if ( aManualInstance.isForwardSet() )
            {
		if ( aManualInstance.getForward() == DNS_FORWARD_ONLY )
			addOptsToZone( newZone, "forward", "only" );
		
		if ( aManualInstance.getForward() == DNS_FORWARD_FIRST )
                        addOptsToZone( newZone, "forward", "first" );

	    }
 
	    unsigned int size = 0;
	    if ( aManualInstance.isForwardersSet() )
            {
                const char **forwardersList = aManualInstance.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] );

                addOptsToZone( newZone,"forwarders", strdup( value_list.toString().c_str() ) );
            }

	    // NegativeCachingTTL
            if (aManualInstance.isNegativeCachingTTLSet())
                newZone->soaNegativCachingTTL = aManualInstance.getNegativeCachingTTL();
            else
    	        newZone->soaNegativCachingTTL = 0;

	    if (aManualInstance.isServerSet())
                newZone->soaServer = strdup( aManualInstance.getServer() );
	    else
	    	newZone->soaServer = "@";

            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_DnsMasterZoneResourceAccess::deleteInstance(
     const CmpiContext& ctx, const CmpiBroker &mbp,
     const Linux_DnsMasterZoneInstanceName& inst){

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

    
    CMPIUint32 Linux_DnsMasterZoneResourceAccess::disable(
     const CmpiContext& ctx, const CmpiBroker &mbp,
     const Linux_DnsMasterZoneInstanceName& inst) { 
	
	if ( inst.getName() == NULL )
		return 3;	
	return disableZone(inst.getName());
    };
    
    
    CMPIUint32 Linux_DnsMasterZoneResourceAccess::enable(
     const CmpiContext& ctx, const CmpiBroker &mbp,
     const Linux_DnsMasterZoneInstanceName& inst) { 
   
	if ( inst.getName() == NULL )
                return 3;
	
	return enableZone(inst.getName());
    };
    
	
}



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

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

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

--- NEW FILE: Linux_DnsMasterZoneResourceAccess.h ---
 /**
 * Linux_DnsMasterZoneResourceAccess.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_DnsMasterZoneResourceAccess_h
#define Linux_DnsMasterZoneResourceAccess_h

#include "Linux_DnsMasterZoneInstanceName.h"
#include "Linux_DnsMasterZoneManualInstance.h"
#include "CmpiObjectPath.h"
#include "CmpiInstance.h"
#include "CmpiDateTime.h"
#include "CmpiBroker.h"
#include "CIM_CollectionOfMSEsInstanceName.h"
#include "CIM_ManagedSystemElementInstanceName.h"
#include "Linux_DnsMasterZoneDefaultImplementation.h"

#include <string>
#include <list>

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

namespace genProvider {

  class Linux_DnsMasterZoneResourceAccess:
   public Linux_DnsMasterZoneDefaultImplementation {

    private:

    virtual void setInstanceProperties(
        const CmpiContext& ctx,
        const CmpiBroker &mbp,
        DNSZONE * zone,
        const Linux_DnsMasterZoneInstanceName& anInstanceName,
        Linux_DnsMasterZoneManualInstance& aManualInstance);

    virtual void setInstanceNameProperties(
        const CmpiContext& ctx,
        const CmpiBroker& mbp,
        const char *nsp,
        DNSZONE * zone,
        Linux_DnsMasterZoneInstanceName& anInstanceName);
  
	
    public:
    /*Linux_DnsMasterZoneResourceAccess();*/    
    virtual ~Linux_DnsMasterZoneResourceAccess() ;
    
    /* intrinsic methods */
    virtual void enumInstanceNames(
     const CmpiContext& ctx,
     const CmpiBroker &mbp,
     const char *nsp,
     Linux_DnsMasterZoneInstanceNameEnumeration& instnames);
  	
    virtual void enumInstances(
     const CmpiContext& ctx,
     const CmpiBroker &mbp,
     const char *nsp,
     const char* *properties,
  	 Linux_DnsMasterZoneManualInstanceEnumeration& instances);
  	
    virtual Linux_DnsMasterZoneManualInstance getInstance(
     const CmpiContext& ctx,
     const CmpiBroker &mbp,
     const char* *properties,
     const Linux_DnsMasterZoneInstanceName&);
  	
    virtual void setInstance(
     const CmpiContext& ctx,
     const CmpiBroker &mbp,
     const char* *properties,
     const Linux_DnsMasterZoneManualInstance&); 
       	
    virtual void createInstance(
     const CmpiContext& ctx,
     const CmpiBroker &mbp,
     const Linux_DnsMasterZoneManualInstance&);
  	
    virtual void deleteInstance(
     const CmpiContext& ctx,
     const CmpiBroker &mbp,
     const Linux_DnsMasterZoneInstanceName&);
	
    
    /* extrinsic methods */

    /*virtual CMPIUint32 ApplyIncrementalChangeToCollection(
     const CmpiContext& ctx, const CmpiBroker &mbp,
     const Linux_DnsMasterZoneInstanceName&,
      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_DnsMasterZoneInstanceName&,
      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_DnsMasterZoneInstanceName&,
      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_DnsMasterZoneInstanceName&,
      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_DnsMasterZoneInstanceName&,
      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_DnsMasterZoneInstanceName&,
      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_DnsMasterZoneInstanceName&,
      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_DnsMasterZoneInstanceName&,
      const CIM_ManagedSystemElementInstanceName &MSE,
      int isMSEPresent,
      const CmpiDateTime &TimeToApply,
      int isTimeToApplyPresent,
      const CmpiDateTime &MustBeCompletedBy,
      int isMustBeCompletedByPresent);*/

    virtual CMPIUint32 disable(
     const CmpiContext& ctx, const CmpiBroker &mbp,
     const Linux_DnsMasterZoneInstanceName&);

    virtual CMPIUint32 enable(
     const CmpiContext& ctx, const CmpiBroker &mbp,
     const Linux_DnsMasterZoneInstanceName&);	
  };
}
#endif


--- NEW FILE: Linux_DnsMasterZoneInterface.h ---
 /**
 * Linux_DnsMasterZoneInterface.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_DnsMasterZoneInterface_h
#define Linux_DnsMasterZoneInterface_h

#include "Linux_DnsMasterZoneInstanceName.h"
#include "Linux_DnsMasterZoneManualInstance.h"
#include "CmpiObjectPath.h"
#include "CmpiInstance.h"
#include "CmpiDateTime.h"
#include "CmpiBroker.h"
#include "CIM_CollectionOfMSEsInstanceName.h"
#include "CIM_ManagedSystemElementInstanceName.h"

namespace genProvider {

  class Linux_DnsMasterZoneInterface {
  	
    public:    
    virtual ~Linux_DnsMasterZoneInterface() { };
    
    /* intrinsic methods */
    virtual void enumInstanceNames(
     const CmpiContext& ctx,
     const CmpiBroker &mbp,
     const char *nsp,
     Linux_DnsMasterZoneInstanceNameEnumeration& instnames) = 0;
  	
    virtual void enumInstances(
     const CmpiContext& ctx,
     const CmpiBroker &mbp,
     const char *nsp,
     const char* *properties,
  	 Linux_DnsMasterZoneManualInstanceEnumeration& instances) = 0;
  	
    virtual Linux_DnsMasterZoneManualInstance getInstance(
     const CmpiContext& ctx,
     const CmpiBroker &mbp,
     const char* *properties,
     const Linux_DnsMasterZoneInstanceName&) = 0;
  	
    virtual void setInstance(
     const CmpiContext& ctx,
     const CmpiBroker &mbp,
     const char* *properties,
     const Linux_DnsMasterZoneManualInstance&) = 0;
  	
    virtual void createInstance(
     const CmpiContext& ctx,
     const CmpiBroker &mbp,
     const Linux_DnsMasterZoneManualInstance&) = 0;
  	
    virtual void deleteInstance(
     const CmpiContext& ctx,
     const CmpiBroker &mbp,
     const Linux_DnsMasterZoneInstanceName&) = 0;
	
    
    /* extrinsic methods */

    virtual CMPIUint32 ApplyIncrementalChangeToCollection(
     const CmpiContext& ctx, const CmpiBroker &mbp,
     const Linux_DnsMasterZoneInstanceName&,
      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) = 0;

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

    virtual CMPIUint32 ApplyToCollection(
     const CmpiContext& ctx, const CmpiBroker &mbp,
     const Linux_DnsMasterZoneInstanceName&,
      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) = 0;

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

    virtual CMPIUint32 VerifyOKToApplyIncrementalChangeToCollection(
     const CmpiContext& ctx, const CmpiBroker &mbp,
     const Linux_DnsMasterZoneInstanceName&,
      const CIM_CollectionOfMSEsInstanceName &Collection,
      int isCollectionPresent,
      const CmpiDateTime &TimeToApply,
      int isTimeToApplyPresent,
      const CmpiDateTime &MustBeCompletedBy,
      int isMustBeCompletedByPresent,
      const char** PropertiesToApply,
      const C...
 
[truncated message content]