[Sblim-commit] cmpi-dns/provider/Linux_DnsAllowTransferACLForZone Linux_DnsAllowTransferACLForZoneExternal.h,NONE,1.1 Linux_DnsAllowTransferACLForZoneRepositoryExternal.cpp,NONE,1.1 Linux_DnsAllowTransferACLForZoneDefaultImplementation.cpp,NONE,1.1 Linux_DnsAllowTransferACLForZoneDefaultImplementation.h,NONE,1.1 Linux_DnsAllowTransferACLForZoneInstance.h,NONE,1.1 Linux_DnsAllowTransferACLForZoneFactory.h,NONE,1.1 Linux_DnsAllowTransferACLForZoneFactory.cpp,NONE,1.1 Linux_DnsAllowTransferACLForZoneRepositoryExternal.h,NONE,1.1 Linux_DnsAllowTransferACLForZoneResourceAccess.h,NONE,1.1 Linux_DnsAllowTransferACLForZoneRepositoryInstance.h,NONE,1.1 setting.provider,NONE,1.1 makefile,NONE,1.1 Linux_DnsAllowTransferACLForZoneResourceAccess.cpp,NONE,1.1 CmpiLinux_DnsAllowTransferACLForZoneProvider.h,NONE,1.1 Linux_DnsAllowTransferACLForZoneInterface.h,NONE,1.1 Linux_DnsAllowTransferACLForZoneManualInstance.cpp,NONE,1.1 Linux_DnsAllowTransferACLForZoneFakeFactory.cpp,NONE,1.1 Linux_DnsAllowTransferACLForZoneExternal.cpp,NONE,1.1 Linux_DnsAllowTransferACLForZoneInstanceName.h,NONE,1.1 Linux_DnsAllowTransferACLForZoneInstance.cpp,NONE,1.1 Linux_DnsAllowTransferACLForZoneInstanceName.cpp,NONE,1.1 CmpiLinux_DnsAllowTransferACLForZoneProvider.cpp,NONE,1.1 Linux_DnsAllowTransferACLForZoneManualInstance.h,NONE,1.1 Linux_DnsAllowTransferACLForZoneRepositoryInstance.cpp,NONE,1.1

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

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

Added Files:
	Linux_DnsAllowTransferACLForZoneExternal.h 
	Linux_DnsAllowTransferACLForZoneRepositoryExternal.cpp 
	Linux_DnsAllowTransferACLForZoneDefaultImplementation.cpp 
	Linux_DnsAllowTransferACLForZoneDefaultImplementation.h 
	Linux_DnsAllowTransferACLForZoneInstance.h 
	Linux_DnsAllowTransferACLForZoneFactory.h 
	Linux_DnsAllowTransferACLForZoneFactory.cpp 
	Linux_DnsAllowTransferACLForZoneRepositoryExternal.h 
	Linux_DnsAllowTransferACLForZoneResourceAccess.h 
	Linux_DnsAllowTransferACLForZoneRepositoryInstance.h 
	setting.provider makefile 
	Linux_DnsAllowTransferACLForZoneResourceAccess.cpp 
	CmpiLinux_DnsAllowTransferACLForZoneProvider.h 
	Linux_DnsAllowTransferACLForZoneInterface.h 
	Linux_DnsAllowTransferACLForZoneManualInstance.cpp 
	Linux_DnsAllowTransferACLForZoneFakeFactory.cpp 
	Linux_DnsAllowTransferACLForZoneExternal.cpp 
	Linux_DnsAllowTransferACLForZoneInstanceName.h 
	Linux_DnsAllowTransferACLForZoneInstance.cpp 
	Linux_DnsAllowTransferACLForZoneInstanceName.cpp 
	CmpiLinux_DnsAllowTransferACLForZoneProvider.cpp 
	Linux_DnsAllowTransferACLForZoneManualInstance.h 
	Linux_DnsAllowTransferACLForZoneRepositoryInstance.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


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

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

  	objectPath.setKey("Element",CmpiData(m_Element.getObjectPath()));

  	objectPath.setKey("Setting",CmpiData(m_Setting.getObjectPath()));
  	
  	return objectPath;
  	
  }
  
  
  //adds the related CmpiObjectPath to an existing cmpiInstance
  void Linux_DnsAllowTransferACLForZoneInstanceName::fillKeys(CmpiInstance& cmpiInstance) const{
  	

  	if(isSet.Element){
  	  cmpiInstance.setProperty("Element",CmpiData(m_Element.getObjectPath()));
  	}

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

  void Linux_DnsAllowTransferACLForZoneInstanceName::
   setNamespace(const char* val, int makeCopy){
    if (isSet.m_namespace) {
      delete m_namespace;
    }
    if (makeCopy&&val) {
      char* tmpval = new char[strlen(val)+1];
      strcpy(tmpval,val);
      m_namespace = tmpval;
    } else {
      m_namespace = val;
    }
    isSet.m_namespace=1;
  }
       
  //Element related methods
  unsigned int Linux_DnsAllowTransferACLForZoneInstanceName::isElementSet() const{
    return isSet.Element;
  }
  void Linux_DnsAllowTransferACLForZoneInstanceName::
   setElement(const Linux_DnsZoneInstanceName& val){
    m_Element = val;
    isSet.Element=1;
  }       
  const Linux_DnsZoneInstanceName& Linux_DnsAllowTransferACLForZoneInstanceName::
   getElement() const{
    
    if(!isSet.Element)
   	  throw CmpiErrorFormater::getErrorException(
   	   CmpiErrorFormater::NOT_SET,
   	   "Element not set");
   	   	
    return m_Element;
  }
       
  //Setting related methods
  unsigned int Linux_DnsAllowTransferACLForZoneInstanceName::isSettingSet() const{
    return isSet.Setting;
  }
  void Linux_DnsAllowTransferACLForZoneInstanceName::
   setSetting(const Linux_DnsAddressMatchListInstanceName& val){
    m_Setting = val;
    isSet.Setting=1;
  }       
  const Linux_DnsAddressMatchListInstanceName& Linux_DnsAllowTransferACLForZoneInstanceName::
   getSetting() const{
    
    if(!isSet.Setting)
   	  throw CmpiErrorFormater::getErrorException(
   	   CmpiErrorFormater::NOT_SET,
   	   "Setting not set");
   	   	
    return m_Setting;
  }

  
  //set isSet variables to FALSE
  void Linux_DnsAllowTransferACLForZoneInstanceName::init(){
  	
  	m_CIMClassNameP="Linux_DnsAllowTransferACLForZone";
  	isSet.m_namespace=0;    	
    isSet.Element=0;   	
    isSet.Setting=0;
  }
  
  
  //copies another instance properties in this
  void Linux_DnsAllowTransferACLForZoneInstanceName::init
   (const Linux_DnsAllowTransferACLForZoneInstanceName& original){
   	init();
   	   	
    m_CIMClassNameP=original.m_CIMClassNameP;
    if(original.isNameSpaceSet()){
      setNamespace(original.getNamespace(),1);
    }   	
    if(original.isElementSet()){
      const Linux_DnsZoneInstanceName& ElementOriginal=original.getElement();
      setElement(ElementOriginal);
    }   	
    if(original.isSettingSet()){
      const Linux_DnsAddressMatchListInstanceName& SettingOriginal=original.getSetting();
      setSetting(SettingOriginal);
    }    
  }
  
  //reset the instanceName data
  void Linux_DnsAllowTransferACLForZoneInstanceName::reset(){   	
  	if (isSet.m_namespace)
  	  delete(m_namespace);  	  
  };
  
  
  
  
  //*********************************************************
  //Linux_DnsAllowTransferACLForZoneInstanceNameEnumerationElement	
  //*********************************************************
  
  Linux_DnsAllowTransferACLForZoneInstanceNameEnumerationElement::
   Linux_DnsAllowTransferACLForZoneInstanceNameEnumerationElement(){
   	
  	m_elementP=0;
  	m_nextP=0;
  	  
  };
  
  
  Linux_DnsAllowTransferACLForZoneInstanceNameEnumerationElement::
   ~Linux_DnsAllowTransferACLForZoneInstanceNameEnumerationElement(){
   	
  	if (m_elementP!=0)
  	  delete(m_elementP);
  	if (m_nextP!=0)
  	  delete(m_nextP);
  	  
  };

  
  //*********************************************************
  //Linux_DnsAllowTransferACLForZoneInstanceNameEnumeration
  //*********************************************************
  
  Linux_DnsAllowTransferACLForZoneInstanceNameEnumeration::
   Linux_DnsAllowTransferACLForZoneInstanceNameEnumeration(){
   	
  	 firstElementP=0;
     currentElementP=0;
     endElementP=0;
  };
  
  Linux_DnsAllowTransferACLForZoneInstanceNameEnumeration::
   Linux_DnsAllowTransferACLForZoneInstanceNameEnumeration(const CmpiArray& arr){
  	
  	firstElementP=0;
    currentElementP=0;
    endElementP=0;
    
    int size = arr.size();
    for (int i=0; i < size; i++) {
     addElement(Linux_DnsAllowTransferACLForZoneInstanceName(arr[i]));
    }
  }
  
  Linux_DnsAllowTransferACLForZoneInstanceNameEnumeration::
   Linux_DnsAllowTransferACLForZoneInstanceNameEnumeration(
   const Linux_DnsAllowTransferACLForZoneInstanceNameEnumeration& original){
   	
     firstElementP=0;
     currentElementP=0;
     endElementP=0;
  	 
     int size=original.getSize();
     for(int i=0;i<size;i++)
       addElement(original.getElement(i));           
  };
  
  	  
  Linux_DnsAllowTransferACLForZoneInstanceNameEnumeration::
   ~Linux_DnsAllowTransferACLForZoneInstanceNameEnumeration(){
   	
  	if (firstElementP!=0)
  	  delete(firstElementP);
  	  	
  };
  
  	  
  void Linux_DnsAllowTransferACLForZoneInstanceNameEnumeration::reset(){
  	
  	currentElementP=firstElementP;
  };
  
  	  
  bool Linux_DnsAllowTransferACLForZoneInstanceNameEnumeration::hasNext() const{
  	
  	return (currentElementP!=0);
  
  };
  
  int Linux_DnsAllowTransferACLForZoneInstanceNameEnumeration::getSize() const{
  	
    int size=0;
    Linux_DnsAllowTransferACLForZoneInstanceNameEnumerationElement* followingP=firstElementP;
  	
  	while(followingP!=0){
        followingP=followingP->m_nextP;
        size++;
    }
  	
    return size;
  };
  
  const Linux_DnsAllowTransferACLForZoneInstanceName&  
   Linux_DnsAllowTransferACLForZoneInstanceNameEnumeration::getElement(int pos) const{
   
    Linux_DnsAllowTransferACLForZoneInstanceNameEnumerationElement* followingP=firstElementP;
   
    int i=0;
    while((followingP!=0)&&(i<pos)){
        followingP=followingP->m_nextP;
        i++;
    }
    
    return *(followingP->m_elementP);
  };
  
  	  
  const Linux_DnsAllowTransferACLForZoneInstanceName&
   Linux_DnsAllowTransferACLForZoneInstanceNameEnumeration::getNext() {
   	
  	 Linux_DnsAllowTransferACLForZoneInstanceNameEnumerationElement* currentP=
  	  currentElementP;
  	 currentElementP=currentElementP->m_nextP;
  	 
  	 return *(currentP->m_elementP);
  };
  	  
  void Linux_DnsAllowTransferACLForZoneInstanceNameEnumeration::addElement
   (const Linux_DnsAllowTransferACLForZoneInstanceName& elementP){
   	
  	if(firstElementP==0){
  	  firstElementP=new Linux_DnsAllowTransferACLForZoneInstanceNameEnumerationElement();
  	  firstElementP->m_elementP=new Linux_DnsAllowTransferACLForZoneInstanceName(elementP);
  	  endElementP=firstElementP;
  	  currentElementP=firstElementP;
  	}else{
  	  endElementP->m_nextP=new Linux_DnsAllowTransferACLForZoneInstanceNameEnumerationElement();
  	  endElementP=endElementP->m_nextP;
  	  endElementP->m_elementP=new Linux_DnsAllowTransferACLForZoneInstanceName(elementP);
  	}
  };
  
  Linux_DnsAllowTransferACLForZoneInstanceNameEnumeration::operator CmpiArray() const{
  	int size=getSize();
   	CmpiArray arr=CmpiArray(size,CMPI_instance);
   	for(int i=0;i<size;i++){
   	  arr[i]=getElement(i).getObjectPath();
   	}
   	return arr;
  };  
}
 

--- NEW FILE: Linux_DnsAllowTransferACLForZoneResourceAccess.h ---
 /**
 * Linux_DnsAllowTransferACLForZoneResourceAccess.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_DnsAllowTransferACLForZoneResourceAccess_h
#define Linux_DnsAllowTransferACLForZoneResourceAccess_h

#include "Linux_DnsAllowTransferACLForZoneInstanceName.h"
#include "Linux_DnsAllowTransferACLForZoneManualInstance.h"
#include "CmpiObjectPath.h"
#include "CmpiInstance.h"
#include "CmpiDateTime.h"
#include "CmpiBroker.h"
#include "Linux_DnsZoneInstance.h"
#include "Linux_DnsAddressMatchListInstance.h"
#include "Linux_DnsZoneExternal.h"
#include "Linux_DnsAddressMatchListExternal.h"
#include "Linux_DnsAllowTransferACLForZoneDefaultImplementation.h"

#include <string>
#include <list>

using namespace std;

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

namespace genProvider {

  class Linux_DnsAllowTransferACLForZoneResourceAccess:
   public Linux_DnsAllowTransferACLForZoneDefaultImplementation {
  	
    public:
    /*Linux_DnsAllowTransferACLForZoneResourceAccess();*/    
    virtual ~Linux_DnsAllowTransferACLForZoneResourceAccess() ;
    
    /* intrinsic methods */
    virtual void enumInstanceNames(
     const CmpiContext& ctx,
     const CmpiBroker &mbp,
     const char *nsp,
     Linux_DnsAllowTransferACLForZoneInstanceNameEnumeration& instnames);
  	
    virtual void enumInstances(
     const CmpiContext& ctx,
     const CmpiBroker &mbp,
     const char *nsp,
     const char* *properties,
  	 Linux_DnsAllowTransferACLForZoneManualInstanceEnumeration& instances);
  	
    virtual Linux_DnsAllowTransferACLForZoneManualInstance getInstance(
     const CmpiContext& ctx,
     const CmpiBroker &mbp,
     const char* *properties,
     const Linux_DnsAllowTransferACLForZoneInstanceName&);
  	
    /*virtual void setInstance(
     const CmpiContext& ctx,
     const CmpiBroker &mbp,
     const char* *properties,
     const Linux_DnsAllowTransferACLForZoneManualInstance&);*/
  	
    virtual void createInstance(
     const CmpiContext& ctx,
     const CmpiBroker &mbp,
     const Linux_DnsAllowTransferACLForZoneManualInstance&);
  	
    virtual void deleteInstance(
     const CmpiContext& ctx,
     const CmpiBroker &mbp,
     const Linux_DnsAllowTransferACLForZoneInstanceName&);
	
    
    /* Association Interface */

    virtual void referencesElement( 
     const CmpiContext& ctx,  
     const CmpiBroker &mbp,
     const char *nsp,
     const char** properties,
     const Linux_DnsAddressMatchListInstanceName& sourceInst,
     Linux_DnsAllowTransferACLForZoneManualInstanceEnumeration& instances);

    virtual void referencesSetting( 
     const CmpiContext& ctx,  
     const CmpiBroker &mbp,
     const char *nsp,
     const char** properties,
     const Linux_DnsZoneInstanceName& sourceInst,
     Linux_DnsAllowTransferACLForZoneManualInstanceEnumeration& instances);

    virtual void associatorsElement( 
     const CmpiContext& ctx,  
     const CmpiBroker &mbp,
     const char *nsp,
     const char** properties,
     const Linux_DnsAddressMatchListInstanceName& sourceInst,
     Linux_DnsZoneInstanceEnumeration& instances);

    virtual void associatorsSetting( 
     const CmpiContext& ctx,  
     const CmpiBroker &mbp,
     const char *nsp,
     const char** properties,
     const Linux_DnsZoneInstanceName& sourceInst,
     Linux_DnsAddressMatchListInstanceEnumeration& instances);

   
    /* extrinsic methods */
	
  };
}
#endif


--- NEW FILE: Linux_DnsAllowTransferACLForZoneRepositoryExternal.h ---
 /**
 * Linux_DnsAllowTransferACLForZoneRepositoryExternal.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_DnsAllowTransferACLForZoneRepositoryExternal_h
#define Linux_DnsAllowTransferACLForZoneRepositoryExternal_h

#include "Linux_DnsAllowTransferACLForZoneInstanceName.h"
#include "Linux_DnsAllowTransferACLForZoneRepositoryInstance.h"
#include "CmpiBroker.h"

namespace genProvider {

  class Linux_DnsAllowTransferACLForZoneRepositoryExternal {
  	
    public:
    Linux_DnsAllowTransferACLForZoneRepositoryExternal(
     const CmpiBroker& brkr,
     const CmpiContext& ctx);
    virtual ~Linux_DnsAllowTransferACLForZoneRepositoryExternal();
    
    virtual void enumInstanceNames(
     Linux_DnsAllowTransferACLForZoneInstanceNameEnumeration&);
     
    virtual void enumInstances(
     const char* *properties,
     Linux_DnsAllowTransferACLForZoneRepositoryInstanceEnumeration&);
     
    virtual Linux_DnsAllowTransferACLForZoneRepositoryInstance getInstance(
     const char* *properties,
     const Linux_DnsAllowTransferACLForZoneInstanceName&);
     
    virtual void setInstance(
     const char* *properties,
     const Linux_DnsAllowTransferACLForZoneRepositoryInstance&);
     
    virtual void createInstance(
     const Linux_DnsAllowTransferACLForZoneRepositoryInstance&);
     
    virtual void deleteInstance(
     const Linux_DnsAllowTransferACLForZoneInstanceName&);
     
    private:
    CmpiBroker  broker;
    CmpiContext context;
    const static char *nsp;
  };
}
#endif

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

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

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

--- NEW FILE: Linux_DnsAllowTransferACLForZoneInstanceName.h ---
 /**
 * Linux_DnsAllowTransferACLForZoneInstanceName.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_DnsAllowTransferACLForZoneInstanceName_h
#define Linux_DnsAllowTransferACLForZoneInstanceName_h

#include "cmpidt.h"
#include "CmpiObjectPath.h"
#include "CmpiInstance.h"
#include "CmpiBooleanData.h"
#include "CmpiCharData.h"
#include "CmpiDateTime.h"
#include "ArrayConverter.h"
#include "CmpiErrorFormater.h"
#include "Linux_DnsZoneInstanceName.h"
#include "Linux_DnsAddressMatchListInstanceName.h"

namespace genProvider {

  class Linux_DnsAllowTransferACLForZoneInstanceName {
  public:
       Linux_DnsAllowTransferACLForZoneInstanceName();
  	
       Linux_DnsAllowTransferACLForZoneInstanceName
  	    (const Linux_DnsAllowTransferACLForZoneInstanceName& original);
  	   
       Linux_DnsAllowTransferACLForZoneInstanceName
        (const CmpiObjectPath& path);
  	 
       ~Linux_DnsAllowTransferACLForZoneInstanceName();
       
       Linux_DnsAllowTransferACLForZoneInstanceName& operator=
  	    (const Linux_DnsAllowTransferACLForZoneInstanceName& original);
       
       CmpiObjectPath getObjectPath() const;
       
       void fillKeys(CmpiInstance& cmpiInstance) const;
       
       unsigned int isNameSpaceSet() const;
       void setNamespace(const char * val, int makeCopy = 1);
       const char * getNamespace() const;

       unsigned int isElementSet() const;
       void setElement(const Linux_DnsZoneInstanceName& val);
       const Linux_DnsZoneInstanceName& getElement() const;

       unsigned int isSettingSet() const;
       void setSetting(const Linux_DnsAddressMatchListInstanceName& val);
       const Linux_DnsAddressMatchListInstanceName& getSetting() const;
       
  private:
       void init();
       void init(const Linux_DnsAllowTransferACLForZoneInstanceName& original);
       void reset();
       
       const char* m_CIMClassNameP;
       const char* m_namespace;
       Linux_DnsZoneInstanceName m_Element;
       Linux_DnsAddressMatchListInstanceName m_Setting;
       
       struct isSetType{
       	 unsigned int m_namespace:1;
         unsigned int Element:1;
         unsigned int Setting:1;
       } isSet;
  };
  
  
  struct Linux_DnsAllowTransferACLForZoneInstanceNameEnumerationElement{
  	Linux_DnsAllowTransferACLForZoneInstanceName* m_elementP;
  	Linux_DnsAllowTransferACLForZoneInstanceNameEnumerationElement* m_nextP;
  	
  	Linux_DnsAllowTransferACLForZoneInstanceNameEnumerationElement();
  	~Linux_DnsAllowTransferACLForZoneInstanceNameEnumerationElement();  	
  };
  

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


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

using namespace std;

namespace genProvider {

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

    void Linux_DnsAllowTransferACLForZoneDefaultImplementation::
     referencesElement( 
     const CmpiContext& ctx,  
     const CmpiBroker &mbp,
     const char *nsp,
     const char** properties,
     const Linux_DnsAddressMatchListInstanceName& sourceInst,
     Linux_DnsAllowTransferACLForZoneManualInstanceEnumeration& instances){
      throw CmpiErrorFormater::getErrorException(
   	   CmpiErrorFormater::NOT_IMPLEMENTED,
   	   "getElementReferences between Linux_DnsZone and Linux_DnsAddressMatchList not implemented for Linux_DnsAllowTransferACLForZone");
    }

    void Linux_DnsAllowTransferACLForZoneDefaultImplementation::
     referencesSetting( 
     const CmpiContext& ctx,  
     const CmpiBroker &mbp,
     const char *nsp,
     const char** properties,
     const Linux_DnsZoneInstanceName& sourceInst,
     Linux_DnsAllowTransferACLForZoneManualInstanceEnumeration& instances){
      throw CmpiErrorFormater::getErrorException(
   	   CmpiErrorFormater::NOT_IMPLEMENTED,
   	   "getSettingReferences between Linux_DnsZone and Linux_DnsAddressMatchList not implemented for Linux_DnsAllowTransferACLForZone");
    }

    void Linux_DnsAllowTransferACLForZoneDefaultImplementation::
     associatorsElement( 
     const CmpiContext& ctx,  
     const CmpiBroker &mbp,
     const char *nsp,
     const char** properties,
     const Linux_DnsAddressMatchListInstanceName& sourceInst,
     Linux_DnsZoneInstanceEnumeration& instances){
      
      std::cout<<"Linux_DnsAllowTransferACLForZone : associatorsLinux_DnsZone() ... returns one instance"<<std::endl;
      
      Linux_DnsAllowTransferACLForZoneManualInstanceEnumeration enumeration;
      
      referencesElement(ctx, mbp, sourceInst.getNamespace(), 
       properties, sourceInst, enumeration);

      Linux_DnsZoneExternal external(mbp, ctx);

      while(enumeration.hasNext()) {
        const Linux_DnsAllowTransferACLForZoneManualInstance instance =
	     enumeration.getNext();
	     
        const Linux_DnsAllowTransferACLForZoneInstanceName instanceName = 
         instance.getInstanceName();
         
        const Linux_DnsZoneInstanceName Element = 
         instanceName.getElement();
         
        Linux_DnsZoneInstance inst = external.getInstance(properties,Element);
        
        instances.addElement(inst);
      }
    }

    void Linux_DnsAllowTransferACLForZoneDefaultImplementation::
     associatorsSetting( 
     const CmpiContext& ctx,  
     const CmpiBroker &mbp,
     const char *nsp,
     const char** properties,
     const Linux_DnsZoneInstanceName& sourceInst,
     Linux_DnsAddressMatchListInstanceEnumeration& instances){
     
      std::cout<<"Linux_DnsAllowTransferACLForZone : associatorsLinux_DnsAddressMatchList() ... returns one instance"<<std::endl;
      
      Linux_DnsAllowTransferACLForZoneManualInstanceEnumeration enumeration;
      
      referencesSetting(ctx, mbp, sourceInst.getNamespace(), 
       properties, sourceInst, enumeration);

      Linux_DnsAddressMatchListExternal external(mbp, ctx);

      while(enumeration.hasNext()) {
        const Linux_DnsAllowTransferACLForZoneManualInstance instance =
	     enumeration.getNext();
	     
        const Linux_DnsAllowTransferACLForZoneInstanceName instanceName = 
         instance.getInstanceName();
         
        const Linux_DnsAddressMatchListInstanceName Setting = 
         instanceName.getSetting();
         
        Linux_DnsAddressMatchListInstance inst = external.getInstance(properties,Setting);
        
        instances.addElement(inst);
      }
    }

   
  /* extrinsic methods */
	
}


--- NEW FILE: Linux_DnsAllowTransferACLForZoneFactory.h ---
 /**
 * Linux_DnsAllowTransferACLForZoneFactory.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_DnsAllowTransferACLForZoneFactory_h
#define Linux_DnsAllowTransferACLForZoneFactory_h


#include "Linux_DnsAllowTransferACLForZoneInterface.h"

namespace genProvider{
	
class Linux_DnsAllowTransferACLForZoneFactory{
public:

	Linux_DnsAllowTransferACLForZoneFactory(){};
	~Linux_DnsAllowTransferACLForZoneFactory(){};
	
	static Linux_DnsAllowTransferACLForZoneInterface* getImplementation();
};
}
#endif
 

--- NEW FILE: Linux_DnsAllowTransferACLForZoneFactory.cpp ---
 /**
 * Linux_DnsAllowTransferACLForZoneFactory.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_DnsAllowTransferACLForZoneFactory.h"
#include "Linux_DnsAllowTransferACLForZoneResourceAccess.h"

namespace genProvider{
	
	Linux_DnsAllowTransferACLForZoneInterface* 
	  Linux_DnsAllowTransferACLForZoneFactory::getImplementation(){
	  	
	  	return (new Linux_DnsAllowTransferACLForZoneResourceAccess());
	  };
}
 

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

using namespace std;

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

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

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

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

OBJECTS=Linux_DnsAllowTransferACLForZoneInstanceName.o \
        Linux_DnsAllowTransferACLForZoneInstance.o \
        Linux_DnsAllowTransferACLForZoneExternal.o \
        Linux_DnsAllowTransferACLForZoneRepositoryInstance.o \
        Linux_DnsAllowTransferACLForZoneRepositoryExternal.o \
        Linux_DnsAllowTransferACLForZoneManualInstance.o \
        Linux_DnsAllowTransferACLForZoneDefaultImplementation.o

FAKEFACTORY= Linux_DnsAllowTransferACLForZoneFakeFactory.o

NORMALFACTORY= Linux_DnsAllowTransferACLForZoneFactory.o

RESOURCEOBJECT= Linux_DnsAllowTransferACLForZoneResourceAccess.o

PROVIDEROBJECT=CmpiLinux_DnsAllowTransferACLForZoneProvider.o 

all: testfiles preinstall install

buildall: clean all

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

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

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

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

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

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

deleteFakeLib:
	$(RM) *.so

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

preinstall: prelink
	install libLinux_DnsAllowTransferACLForZoneSupport.so $(COMMONLIB_OUT)

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

install: link
	install libLinux_DnsAllowTransferACLForZoneSupport.so $(COMMONLIB_OUT)	
	install libLinux_DnsAllowTransferACLForZone.so $(CIMOMLIB_OUT)
#	install -m 644 Linux_DnsAllowTransferACLForZone*.h $(COMMONINC)
	$(MAKE) -C mof -f $(MOFMAKEFILE) install

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

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

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

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

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

uninstall: 
	$(MAKE) -C mof -f $(MOFMAKEFILE) uninstall;
#	$(RM) $(COMMONINC)/Linux_DnsAllowTransferACLForZone*.h \
	$(RM) $(COMMONLIB)/libLinux_DnsAllowTransferACLForZoneSupport.so \
	$(RM) $(CIMOMLIB)/libLinux_DnsAllowTransferACLForZone.so

--- NEW FILE: CmpiLinux_DnsAllowTransferACLForZoneProvider.h ---
 /**
 * CmpiLinux_DnsAllowTransferACLForZoneProvider.h
 *
 * (C) Copyright IBM Corp. 2005
 *
 * THIS FILE IS PROVIDED UNDER THE TERMS OF THE COMMON PUBLIC LICENSE
 * ("AGREEMENT"). ANY USE, REPRODUCTION OR DISTRIBUTION OF THIS FILE
 * CONSTITUTES RECIPIENTS ACCEPTANCE OF THE AGREEMENT.
 *
 * You can obtain a current copy of the Common Public License from
 * http://www.opensource.org/licenses/cpl1.0.php
 *
 * author:     Murillo Bernardes <ber...@br...>
 *
 * Contributors:
 *
 */
#ifndef CmpiLinux_DnsAllowTransferACLForZoneProvider_h
#define CmpiLinux_DnsAllowTransferACLForZoneProvider_h

#include "CmpiInstanceMI.h"
#include "CmpiMethodMI.h"
#include "Linux_DnsAllowTransferACLForZoneFactory.h"
#include "CmpiAssociationMI.h"

 namespace genProvider{

  class CmpiLinux_DnsAllowTransferACLForZoneProvider : public CmpiInstanceMI,
   public CmpiMethodMI, public CmpiAssociationMI{	
	
	private:

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

	  
	public:

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

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

    CmpiStatus associationLogic
	  (const CmpiContext& ctx, 
	   CmpiResult& rslt,
	   const CmpiObjectPath& cop,
	   const int instances,
	   const int references,
       const char** properties=0);
	
	CmpiStatus associators (
     const CmpiContext& ctx, CmpiResult& rslt,
     const CmpiObjectPath& cop,
	 const char* assocClass, const char* resultClass,
     const char* role, const char* resultRole,
     const char** properties);
    
    CmpiStatus associatorNames (
     const CmpiContext & ctx, CmpiResult & rslt,
     const CmpiObjectPath & cop,
     const char* assocClass, const char* resultClass,
     const char* role, const char* resultRole);
    
    CmpiStatus references (
     const CmpiContext& ctx, CmpiResult& rslt,
     const CmpiObjectPath& cop,
     const char* assocClass, const char* role,
     const char** properties);
    
    CmpiStatus referenceNames (
     const CmpiContext& ctx, CmpiResult& rslt,
     const CmpiObjectPath& cop, const char* assocClass,
     const char* role); 
  };
}

#endif

--- NEW FILE: Linux_DnsAllowTransferACLForZoneExternal.h ---
 /**
 * Linux_DnsAllowTransferACLForZoneExternal.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_DnsAllowTransferACLForZoneExternal_h
#define Linux_DnsAllowTransferACLForZoneExternal_h

#include "Linux_DnsAllowTransferACLForZoneInstance.h"
#include "Linux_DnsZoneInstance.h"
#include "Linux_DnsAddressMatchListInstance.h"
#include "CmpiBroker.h"

namespace genProvider {

  class Linux_DnsAllowTransferACLForZoneExternal {
  	
    public:
    Linux_DnsAllowTransferACLForZoneExternal(
     const CmpiBroker& brkr, const CmpiContext& ctx);
    virtual ~Linux_DnsAllowTransferACLForZoneExternal();
    
    virtual void enumInstanceNames(
     const char *nsp,
     Linux_DnsAllowTransferACLForZoneInstanceNameEnumeration&);
     
    virtual void enumInstances(
     const char *nsp,
     const char* *properties,
     Linux_DnsAllowTransferACLForZoneInstanceEnumeration&);
     
    virtual Linux_DnsAllowTransferACLForZoneInstance getInstance(
     const char* *properties,
     const Linux_DnsAllowTransferACLForZoneInstanceName&);
     
    virtual void setInstance(
     const char* *properties,
     const Linux_DnsAllowTransferACLForZoneInstance&);
     
    virtual void createInstance(
     const Linux_DnsAllowTransferACLForZoneInstance&);
     
    virtual void deleteInstance(
     const Linux_DnsAllowTransferACLForZoneInstanceName&);
    
    //association calls
    
    void referencesElement( 
     const char *nsp,
     const char** properties,
     const Linux_DnsAddressMatchListInstanceName& sourceInst,
     Linux_DnsAllowTransferACLForZoneInstanceEnumeration& instances);

    void referenceNamesElement( 
     const char *nsp,
     const Linux_DnsAddressMatchListInstanceName& sourceInst,
     Linux_DnsAllowTransferACLForZoneInstanceNameEnumeration& instanceNames);

    void referencesSetting( 
     const char *nsp,
     const char** properties,
     const Linux_DnsZoneInstanceName& sourceInst,
     Linux_DnsAllowTransferACLForZoneInstanceEnumeration& instances);

    void referenceNamesSetting( 
     const char *nsp,
     const Linux_DnsZoneInstanceName& sourceInst,
     Linux_DnsAllowTransferACLForZoneInstanceNameEnumeration& instanceNames);

    void associatorsElement( 
     const char *nsp,
     const char** properties,
     const Linux_DnsAddressMatchListInstanceName& sourceInst,
     Linux_DnsZoneInstanceEnumeration& instances);

    void associatorNamesElement( 
     const char *nsp,
     const Linux_DnsAddressMatchListInstanceName& sourceInst,
     Linux_DnsZoneInstanceNameEnumeration& instanceNames);

    void associatorsSetting( 
     const char *nsp,
     const char** properties,
     const Linux_DnsZoneInstanceName& sourceInst,
     Linux_DnsAddressMatchListInstanceEnumeration& instances);

    void associatorNamesSetting( 
     const char *nsp,
     const Linux_DnsZoneInstanceName& sourceInst,
     Linux_DnsAddressMatchListInstanceNameEnumeration& instanceNames);

     
    private:
    CmpiBroker  broker;
    CmpiContext context;
  };
}
#endif

--- NEW FILE: Linux_DnsAllowTransferACLForZoneDefaultImplementation.h ---
 /**
 * Linux_DnsAllowTransferACLForZoneDefaultImplementation.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_DnsAllowTransferACLForZoneDefaultImplementation_h
#define Linux_DnsAllowTransferACLForZoneDefaultImplementation_h

#include "Linux_DnsAllowTransferACLForZoneInstanceName.h"
#include "Linux_DnsAllowTransferACLForZoneManualInstance.h"
#include "CmpiObjectPath.h"
#include "CmpiInstance.h"
#include "CmpiDateTime.h"
#include "CmpiBroker.h"
#include "Linux_DnsZoneInstance.h"
#include "Linux_DnsAddressMatchListInstance.h"
#include "Linux_DnsZoneExternal.h"
#include "Linux_DnsAddressMatchListExternal.h"
#include "Linux_DnsAllowTransferACLForZoneInterface.h"

namespace genProvider {

  class Linux_DnsAllowTransferACLForZoneDefaultImplementation:
   public Linux_DnsAllowTransferACLForZoneInterface {
  	
    public:    
    virtual ~Linux_DnsAllowTransferACLForZoneDefaultImplementation() { };
    
    /* intrinsic methods */
    virtual void enumInstanceNames(
     const CmpiContext& ctx,
     const CmpiBroker &mbp,
     const char *nsp,
     Linux_DnsAllowTransferACLForZoneInstanceNameEnumeration& instnames);
  	
    virtual void enumInstances(
     const CmpiContext& ctx,
     const CmpiBroker &mbp,
     const char *nsp,
     const char* *properties,
  	 Linux_DnsAllowTransferACLForZoneManualInstanceEnumeration& instances);
  	
    virtual Linux_DnsAllowTransferACLForZoneManualInstance getInstance(
     const CmpiContext& ctx,
     const CmpiBroker &mbp,
     const char* *properties,
     const Linux_DnsAllowTransferACLForZoneInstanceName&);
  	
    virtual void setInstance(
     const CmpiContext& ctx,
     const CmpiBroker &mbp,
     const char* *properties,
     const Linux_DnsAllowTransferACLForZoneManualInstance&);
  	
    virtual void createInstance(
     const CmpiContext& ctx,
     const CmpiBroker &mbp,
     const Linux_DnsAllowTransferACLForZoneManualInstance&);
  	
    virtual void deleteInstance(
     const CmpiContext& ctx,
     const CmpiBroker &mbp,
     const Linux_DnsAllowTransferACLForZoneInstanceName&);
	
    
    /* Association Interface */

    virtual void referencesElement( 
     const CmpiContext& ctx,  
     const CmpiBroker &mbp,
     const char *nsp,
     const char** properties,
     const Linux_DnsAddressMatchListInstanceName& sourceInst,
     Linux_DnsAllowTransferACLForZoneManualInstanceEnumeration& instances);

    virtual void referencesSetting( 
     const CmpiContext& ctx,  
     const CmpiBroker &mbp,
     const char *nsp,
     const char** properties,
     const Linux_DnsZoneInstanceName& sourceInst,
     Linux_DnsAllowTransferACLForZoneManualInstanceEnumeration& instances);

    virtual void associatorsElement( 
     const CmpiContext& ctx,  
     const CmpiBroker &mbp,
     const char *nsp,
     const char** properties,
     const Linux_DnsAddressMatchListInstanceName& sourceInst,
     Linux_DnsZoneInstanceEnumeration& instances);

    virtual void associatorsSetting( 
     const CmpiContext& ctx,  
     const CmpiBroker &mbp,
     const char *nsp,
     const char** properties,
     const Linux_DnsZoneInstanceName& sourceInst,
     Linux_DnsAddressMatchListInstanceEnumeration& instances);

   
    /* extrinsic methods */
	
  };
}
#endif


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

#define DNS_ATTR_STR	"allow-transfer"

namespace genProvider {
  
    //Linux_DnsAllowTransferACLForZoneResourceAccess::Linux_DnsAllowTransferACLForZoneResourceAccess();
    Linux_DnsAllowTransferACLForZoneResourceAccess::~Linux_DnsAllowTransferACLForZoneResourceAccess() { };
    
    /* intrinsic methods */
    
    void Linux_DnsAllowTransferACLForZoneResourceAccess::enumInstanceNames(
     const CmpiContext& ctx, const CmpiBroker &mbp, const char *nsp,
     Linux_DnsAllowTransferACLForZoneInstanceNameEnumeration& instnames){
      DNSZONE * zones, * all_zones;

        zones = getZones();
	all_zones = zones;

        if ( ! zones)
		return;
        
        for (; zones->zoneName  ; zones++)
        {
		ZONEOPTS *zopts = findOptsInZone(zones,DNS_ATTR_STR);
		if ( ( ! zopts ) || ( !zopts->value ) )
			continue;

		DnsArray da = DnsArray( zopts->value );
		DnsArrayConstIterator iter;

		for ( iter = da.begin(); iter != da.end(); ++iter)
		{
			Linux_DnsAllowTransferACLForZoneInstanceName AuInst;
			Linux_DnsAddressMatchListInstanceName addrList;
			Linux_DnsZoneInstanceName zoneInst;

			AuInst.setNamespace( nsp );
			zoneInst.setNamespace( nsp );	
			addrList.setNamespace( nsp );
	
			zoneInst.setName( zones->zoneName );
	
			addrList.setName( (*iter).c_str() );
			addrList.setServiceName( DEFAULT_SERVICE_NAME );

			AuInst.setSetting( addrList );
			AuInst.setElement( zoneInst );

			instnames.addElement(AuInst); 
		}
        }
    }
    
  	
    void Linux_DnsAllowTransferACLForZoneResourceAccess::enumInstances(
     const CmpiContext& ctx,
     const CmpiBroker &mbp,
     const char *nsp,
     const char* *properties,
  	 Linux_DnsAllowTransferACLForZoneManualInstanceEnumeration& instances){
	 
	DNSZONE * zones, *all_zones;
	
	zones = getZones();
	all_zones = zones;

        if ( ! zones)
		return;
        
        for (; zones->zoneName  ; zones++)
        {
		ZONEOPTS *zopts = findOptsInZone(zones,DNS_ATTR_STR);
		if ( ( ! zopts ) || ( !zopts->value ) )
			continue;

		DnsArray da = DnsArray( zopts->value );
		DnsArrayConstIterator iter;

		for ( iter = da.begin(); iter != da.end(); ++iter)
		{
			Linux_DnsAllowTransferACLForZoneInstanceName AuInstName;
			Linux_DnsAllowTransferACLForZoneManualInstance AuInst;
			Linux_DnsAddressMatchListInstanceName addrList;
			Linux_DnsZoneInstanceName zoneInst;

			AuInstName.setNamespace( nsp );
			zoneInst.setNamespace( nsp );	
			addrList.setNamespace( nsp );
	
			zoneInst.setName( zones->zoneName );
	
			addrList.setName( (*iter).c_str() );
			addrList.setServiceName( DEFAULT_SERVICE_NAME );

			AuInstName.setSetting( addrList );
			AuInstName.setElement( zoneInst );
			AuInst.setInstanceName( AuInstName );
			
			instances.addElement(AuInst); 
		}
        } 
	freeZones( all_zones ); 
    };
  	
  	
    Linux_DnsAllowTransferACLForZoneManualInstance 
     Linux_DnsAllowTransferACLForZoneResourceAccess::getInstance(
     const CmpiContext& ctx,
     const CmpiBroker &mbp,
     const char* *properties,
     const Linux_DnsAllowTransferACLForZoneInstanceName& instanceName){
      Linux_DnsAllowTransferACLForZoneManualInstance AuInst;
        AuInst.setInstanceName( instanceName );
	return AuInst;
    }
  	
  	/*
    void Linux_DnsAllowTransferACLForZoneResourceAccess::setInstance(
     const CmpiContext& ctx,
     const CmpiBroker &mbp,
     const char* *properties,
     const Linux_DnsAllowTransferACLForZoneManualInstance&){};
  	*/
  	
    void Linux_DnsAllowTransferACLForZoneResourceAccess::createInstance(
     const CmpiContext& ctx, const CmpiBroker &mbp,
     const Linux_DnsAllowTransferACLForZoneManualInstance& anInstance){
     
     	DNSZONE *zones = getZones();
	DNSZONE *zone;

	// Find the requested zone. If that does not exist throw an exception
	zone = findZone(zones, anInstance.getInstanceName().getElement().getName() );
	if ( ! zone )
	{
		throw CmpiStatus(CMPI_RC_ERR_INVALID_PARAMETER,"The indicated Zone does not exist");
	}
	/* Now zone points to the _desired_ zone */
	ZONEOPTS* zopts = findOptsInZone(zone,DNS_ATTR_STR);
	
	DnsArray iplist;
	if (zopts && zopts->value)
	{
		iplist.populate(zopts->value);
		iplist.add( string( anInstance.getInstanceName().getSetting().getName() ) );
		
		free(zopts->value);
		zopts->value = strdup( iplist.toString().c_str() );
	
		updateZones( zones );
		freeZones( zones );
		return;
	}
	
	iplist.add( string(anInstance.getInstanceName().getSetting().getName()) );
	addOptsToZone(zone, DNS_ATTR_STR,  iplist.toString().c_str());
     	updateZones( zones );
	freeZones( zones );
    };
  	
  	
    void Linux_DnsAllowTransferACLForZoneResourceAccess::deleteInstance(
     const CmpiContext& ctx, const CmpiBroker &mbp,
     const Linux_DnsAllowTransferACLForZoneInstanceName& anInstanceName){
	DNSZONE *zones = getZones();
	DNSZONE *zone;

	// Find the requested zone. If that does not exist throw an exception
	zone = findZone(zones, anInstanceName.getElement().getName() );
	if (!zone)
	{
		throw CmpiStatus(CMPI_RC_ERR_INVALID_PARAMETER,"The indicated Zone does not exist");
	}
	/* Now zone points to the _desired_ zone */
	ZONEOPTS* zopts = findOptsInZone(zone,DNS_ATTR_STR);
	
	DnsArray iplist;
	if (zopts && zopts->value)
	{
		iplist.populate(zopts->value);
		
		iplist.remove( string( anInstanceName.getSetting().getName() ) );
		free(zopts->value);
		zopts->value = strdup( iplist.toString().c_str() );
	
		updateZones( zones );
		freeZones( zones );
		return;
	}
   };
	
    
    /* Association Interface */
    
    void Linux_DnsAllowTransferACLForZoneResourceAccess::referencesElement( 
     const CmpiContext& ctx,  
     const CmpiBroker &mbp,
     const char *nsp,
     const char** properties,
     const Linux_DnsAddressMatchListInstanceName& sourceInst,
     Linux_DnsAllowTransferACLForZoneManualInstanceEnumeration& instEnum) {
     
     	cout << "Linux_DnsAllowTransferACLForZoneResourceAccess::referencesElement()" << endl;

	DNSZONE *zones = getZones();
	DNSZONE *all_zones = zones;
	
        if ( ! zones)
		throw CmpiStatus(CMPI_RC_ERR_INVALID_PARAMETER,"The indicated Zone does not exist");
        
        for (; zones->zoneName  ; zones++)
        {
		ZONEOPTS *zopts = findOptsInZone(zones,DNS_ATTR_STR);
		if ( ( ! zopts ) || ( !zopts->value ) )
			continue;

		DnsArray da = DnsArray( zopts->value );
		DnsArrayConstIterator iter;

		for ( iter = da.begin(); iter != da.end(); ++iter)
		{
			if ( strcmp( (*iter).c_str(), sourceInst.getName() ) != 0 )
				continue;
		
			Linux_DnsAllowTransferACLForZoneInstanceName AuInstName;
			Linux_DnsAllowTransferACLForZoneManualInstance AuInst;
			
			// AddressMatchList -> Setting
			/*Linux_DnsAddressMatchListInstance addrList;
			addrList.setInstanceName( sourceInst );
			char *aclValue = getACL(list_acl, (*iter).c_str());
			if ( ! aclValue )
				continue;
				
			DnsArray aclArray = DnsArray( aclValue );
			addrList.setAddressList( aclArray.toArray(), aclArray.size() );*/
			//
			
			// Zone -> Element
			Linux_DnsZoneInstance zoneInst;
			Linux_DnsZoneInstanceName zoneInstName;
			
			zoneInstName.setNamespace( nsp );
                	zoneInstName.setName( zones->zoneName );
			zoneInst.setInstanceName( zoneInstName );
			
			if 	( strcmp(zones->zoneType, "master") == 0 )
				zoneInst.setType( DNS_ZONETYPE_MASTER );
			else if (  strcmp(zones->zoneType, "slave") == 0 )
				zoneInst.setType( DNS_ZONETYPE_SLAVE );
			else if (  strcmp(zones->zoneType, "forward") == 0 )
				zoneInst.setType( DNS_ZONETYPE_FORWARD );
			else if (  strcmp(zones->zoneType, "hint") == 0 )
				zoneInst.setType( DNS_ZONETYPE_HINT );
			else
				zoneInst.setType( DNS_ZONETYPE_UNKNOWN );
				
			zoneInst.setResourceRecordFile( zones->zoneFileName );
			//
			AuInstName.setNamespace( nsp );
			AuInstName.setElement( zoneInstName );
			AuInstName.setSetting( sourceInst );
			AuInst.setInstanceName( AuInstName );
			
			instEnum.addElement( AuInst );
		}
	}
	freeZones( all_zones );
    };
    
    
    void Linux_DnsAllowTransferACLForZoneResourceAccess::referencesSetting( 
     const CmpiContext& ctx,  
     const CmpiBroker &mbp,
     const char *nsp,
     const char** properties,
     const Linux_DnsZoneInstanceName& sourceInst,
     Linux_DnsAllowTransferACLForZoneManualInstanceEnumeration& instEnum) {
     	cout << "Linux_DnsAllowTransferACLForZoneResourceAccess::referencesSetting()" << endl;
	
	DNSZONE *zones = getZones();
	DNSZONE *a...
 
[truncated message content]