[Sblim-commit] cmpi-dns/provider/Linux_DnsManagedSystemElementForSetting Linux_DnsManagedSystemElementForSettingDefaultImplementation.h,NONE,1.1 Linux_DnsManagedSystemElementForSettingExternal.h,NONE,1.1 Linux_DnsManagedSystemElementForSettingRepositoryExternal.cpp,NONE,1.1 Linux_DnsManagedSystemElementForSettingInstance.cpp,NONE,1.1 Linux_DnsManagedSystemElementForSettingResourceAccess.h,NONE,1.1 Linux_DnsManagedSystemElementForSettingFakeFactory.cpp,NONE,1.1 Linux_DnsManagedSystemElementForSettingManualInstance.h,NONE,1.1 Linux_DnsManagedSystemElementForSettingFactory.cpp,NONE,1.1 Linux_DnsManagedSystemElementForSettingRepositoryInstance.cpp,NONE,1.1 Linux_DnsManagedSystemElementForSettingRepositoryExternal.h,NONE,1.1 Linux_DnsManagedSystemElementForSettingManualInstance.cpp,NONE,1.1 Linux_DnsManagedSystemElementForSettingRepositoryInstance.h,NONE,1.1 makefile,NONE,1.1 Linux_DnsManagedSystemElementForSettingResourceAccess.cpp,NONE,1.1 CmpiLinux_DnsManagedSystemElementForSettingProvider.h,NONE,1.1 Linux_DnsManagedSystemElementForSettingInstanceName.h,NONE,1.1 Linux_DnsManagedSystemElementForSettingInstanceName.cpp,NONE,1.1 Linux_DnsManagedSystemElementForSettingDefaultImplementation.cpp,NONE,1.1 Linux_DnsManagedSystemElementForSettingInterface.h,NONE,1.1 Linux_DnsManagedSystemElementForSettingExternal.cpp,NONE,1.1 setting.provider,NONE,1.1 Linux_DnsManagedSystemElementForSettingFactory.h,NONE,1.1 CmpiLinux_DnsManagedSystemElementForSettingProvider.cpp,NONE,1.1 Linux_DnsManagedSystemElementForSettingInstance.h,NONE,1.1

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

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

Added Files:
	Linux_DnsManagedSystemElementForSettingDefaultImplementation.h 
	Linux_DnsManagedSystemElementForSettingExternal.h 
	Linux_DnsManagedSystemElementForSettingRepositoryExternal.cpp 
	Linux_DnsManagedSystemElementForSettingInstance.cpp 
	Linux_DnsManagedSystemElementForSettingResourceAccess.h 
	Linux_DnsManagedSystemElementForSettingFakeFactory.cpp 
	Linux_DnsManagedSystemElementForSettingManualInstance.h 
	Linux_DnsManagedSystemElementForSettingFactory.cpp 
	Linux_DnsManagedSystemElementForSettingRepositoryInstance.cpp 
	Linux_DnsManagedSystemElementForSettingRepositoryExternal.h 
	Linux_DnsManagedSystemElementForSettingManualInstance.cpp 
	Linux_DnsManagedSystemElementForSettingRepositoryInstance.h 
	makefile 
	Linux_DnsManagedSystemElementForSettingResourceAccess.cpp 
	CmpiLinux_DnsManagedSystemElementForSettingProvider.h 
	Linux_DnsManagedSystemElementForSettingInstanceName.h 
	Linux_DnsManagedSystemElementForSettingInstanceName.cpp 
	Linux_DnsManagedSystemElementForSettingDefaultImplementation.cpp 
	Linux_DnsManagedSystemElementForSettingInterface.h 
	Linux_DnsManagedSystemElementForSettingExternal.cpp 
	setting.provider 
	Linux_DnsManagedSystemElementForSettingFactory.h 
	CmpiLinux_DnsManagedSystemElementForSettingProvider.cpp 
	Linux_DnsManagedSystemElementForSettingInstance.h 
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_DnsManagedSystemElementForSettingResourceAccess.cpp ---
 /**
 * Linux_DnsManagedSystemElementForSettingResourceAccess.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_DnsManagedSystemElementForSettingResourceAccess.h"


namespace genProvider {
  
    //Linux_DnsManagedSystemElementForSettingResourceAccess::Linux_DnsManagedSystemElementForSettingResourceAccess();
    Linux_DnsManagedSystemElementForSettingResourceAccess::~Linux_DnsManagedSystemElementForSettingResourceAccess() { };
    
    /* intrinsic methods */
    /*
    void Linux_DnsManagedSystemElementForSettingResourceAccess::enumInstanceNames(
     const CmpiContext& ctx, const CmpiBroker &mbp, const char *nsp,
     Linux_DnsManagedSystemElementForSettingInstanceNameEnumeration& instnames){
      
      int numInstanceNames=1;
      for(int i=0;i<numInstanceNames;i++){
      
        //place here the code retrieving your instanceName
      
        Linux_DnsManagedSystemElementForSettingInstanceName instanceName;
        
      }      
    }
    */
  	/*
    void Linux_DnsManagedSystemElementForSettingResourceAccess::enumInstances(
     const CmpiContext& ctx,
     const CmpiBroker &mbp,
     const char *nsp,
     const char* *properties,
  	 Linux_DnsManagedSystemElementForSettingManualInstanceEnumeration& instances){};
  	*/
  	/*
    Linux_DnsManagedSystemElementForSettingManualInstance 
     Linux_DnsManagedSystemElementForSettingResourceAccess::getInstance(
     const CmpiContext& ctx,
     const CmpiBroker &mbp,
     const char* *properties,
     const Linux_DnsManagedSystemElementForSettingInstanceName&){
      Linux_DnsManagedSystemElementForSettingManualInstance instance;
      
    }
  	*/
  	/*
    void Linux_DnsManagedSystemElementForSettingResourceAccess::setInstance(
     const CmpiContext& ctx,
     const CmpiBroker &mbp,
     const char* *properties,
     const Linux_DnsManagedSystemElementForSettingManualInstance&){};
  	*/
  	/*
    void Linux_DnsManagedSystemElementForSettingResourceAccess::createInstance(
     const CmpiContext& ctx, const CmpiBroker &mbp,
     const Linux_DnsManagedSystemElementForSettingManualInstance&){};
  	*/
  	/*
    void Linux_DnsManagedSystemElementForSettingResourceAccess::deleteInstance(
     const CmpiContext& ctx, const CmpiBroker &mbp,
     const Linux_DnsManagedSystemElementForSettingInstanceName&){};
	*/
    
    /* Association Interface */
    
    void Linux_DnsManagedSystemElementForSettingResourceAccess::referencesElement( 
     const CmpiContext& ctx,  
     const CmpiBroker &mbp,
     const char *nsp,
     const char** properties,
     const Linux_DnsAddressMatchListInstanceName& sourceInst,
     Linux_DnsManagedSystemElementForSettingManualInstanceEnumeration& instEnum) {
/*	cout << "Linux_DnsManagedSystemElementForSettingResourceAcces::referencesElement()" << endl;

        DNSZONE *zones = getZones();
	DNSZONE *zones_ptr = zones;

        if ( ! zones)
                throw CmpiStatus(CMPI_RC_ERR_INVALID_PARAMETER,"The indicated Zone does not exist");

        for (; zones->zoneName ; zones++)
        {
               	ZONEOPTS *zopts = zones->zoneOpts;
	        while (zopts && zopts->key)
		{
        	        if ( 	strcmp(zopts->key, DNS_ALLOW_NOTIFY_STR)   &&
				strcmp(zopts->key, DNS_ALLOW_QUERY_STR)    &&
				strcmp(zopts->key, DNS_ALLOW_TRANSFER_STR) && 
				strcmp(zopts->key, DNS_ALLOW_UPDATE_STR )  
			 )
				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_DnsManagedSystemElementForSettingInstanceName AuInstName;
                        	Linux_DnsManagedSystemElementForSettingManualInstance AuInst;
				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.setElement( zoneInstName );
        	                AuInstName.setSetting( sourceInst );
	                        AuInst.setInstanceName( AuInstName );

                        	instEnum.addElement( AuInst );
        		}
                	zopts++;
                }
        }
        freeZones( zones_ptr );
*/
    };
    
    
    void Linux_DnsManagedSystemElementForSettingResourceAccess::referencesSetting( 
     const CmpiContext& ctx,  
     const CmpiBroker &mbp,
     const char *nsp,
     const char** properties,
     const Linux_DnsZoneInstanceName& sourceInst,
     Linux_DnsManagedSystemElementForSettingManualInstanceEnumeration& instEnum) {

    };
    
    
    void Linux_DnsManagedSystemElementForSettingResourceAccess::associatorsElement( 
     const CmpiContext& ctx,  
     const CmpiBroker &mbp,
     const char *nsp,
     const char** properties,
     const Linux_DnsAddressMatchListInstanceName& sourceInst,
     Linux_DnsZoneInstanceEnumeration&) { };
    
    
    void Linux_DnsManagedSystemElementForSettingResourceAccess::associatorsSetting( 
     const CmpiContext& ctx,  
     const CmpiBroker &mbp,
     const char *nsp,
     const char** properties,
     const Linux_DnsZoneInstanceName& sourceInst,
     Linux_DnsAddressMatchListInstanceEnumeration&) {

    };
    
   
    /* extrinsic methods */
	
}



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

namespace genProvider {

  //*********************************************************
  //Linux_DnsManagedSystemElementForSettingInstance
  //*********************************************************

  //empty constructor
  Linux_DnsManagedSystemElementForSettingInstance::
   Linux_DnsManagedSystemElementForSettingInstance(){   	
   	init();  	   	
  };
  
  
  //copy constructor	
  Linux_DnsManagedSystemElementForSettingInstance::
   Linux_DnsManagedSystemElementForSettingInstance
   (const Linux_DnsManagedSystemElementForSettingInstance& original){   	
   	init(original);  	   	
  };
  
  
  //constructor using CmpiInstance
  Linux_DnsManagedSystemElementForSettingInstance::
   Linux_DnsManagedSystemElementForSettingInstance (const CmpiInstance& inst, const char* instanceNamespace){
    CmpiData cmpiData;
    init(); 
    
    CmpiObjectPath cop=inst.getObjectPath();
    cop.setNameSpace(instanceNamespace);
    setInstanceName(Linux_DnsManagedSystemElementForSettingInstanceName(cop));
    
  }
  
  
  //Destructor
  Linux_DnsManagedSystemElementForSettingInstance::
   ~Linux_DnsManagedSystemElementForSettingInstance(){
   	reset();  	  
  };
  
  
  //copy operator
  Linux_DnsManagedSystemElementForSettingInstance&
   Linux_DnsManagedSystemElementForSettingInstance::operator=
   (const Linux_DnsManagedSystemElementForSettingInstance& original){   	
   	init(original);
   	return *this;
  };
  
  
  //converts to CmpiInstance
  CmpiInstance Linux_DnsManagedSystemElementForSettingInstance::
   getCmpiInstance(const char** properties) const{
   	
   	CmpiObjectPath objectPath=getInstanceName().getObjectPath();      
    CmpiInstance cmpiInstance(objectPath);    
    getInstanceName().fillKeys(cmpiInstance);
    
    if (properties) {
	  cmpiInstance.setPropertyFilter(properties,0);
    }
  	
  	return cmpiInstance;
  	
  }
  
  
  //InstanceName related methods
  unsigned int Linux_DnsManagedSystemElementForSettingInstance::
   isInstanceNameSet() const{
  	return isSet.instanceName;
  }
  
  const Linux_DnsManagedSystemElementForSettingInstanceName&
    Linux_DnsManagedSystemElementForSettingInstance::getInstanceName() const{

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

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


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

  
  //*********************************************************
  //Linux_DnsManagedSystemElementForSettingInstanceNameEnumeration
  //*********************************************************

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

--- NEW FILE: Linux_DnsManagedSystemElementForSettingInstance.h ---
 /**
 * Linux_DnsManagedSystemElementForSettingInstance.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_DnsManagedSystemElementForSettingInstance_h
#define Linux_DnsManagedSystemElementForSettingInstance_h

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

#include "Linux_DnsManagedSystemElementForSettingInstanceName.h"

namespace genProvider {

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

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


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

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

    CmpiObjectPath op(nsp,"Linux_DnsManagedSystemElementForSetting");
    CmpiEnumeration en=broker.enumInstanceNames(context,op);
    while(en.hasNext()) {
      CmpiObjectPath opi = en.getNext();
      Linux_DnsManagedSystemElementForSettingInstanceName iname(opi);
      instnames.addElement(iname);
    }
  };
  	  
  void Linux_DnsManagedSystemElementForSettingExternal::enumInstances(
   const char *nsp,
   const char* *properties,
   Linux_DnsManagedSystemElementForSettingInstanceEnumeration& instances) {
   		
    CmpiObjectPath op(nsp,"Linux_DnsManagedSystemElementForSetting");
    CmpiEnumeration en=broker.enumInstances(context,op,properties);
    while(en.hasNext()) {
      CmpiInstance inst = en.getNext();
      Linux_DnsManagedSystemElementForSettingInstance instance(inst,nsp);
      instances.addElement(instance);
    }
  };
  	  
  Linux_DnsManagedSystemElementForSettingInstance
   Linux_DnsManagedSystemElementForSettingExternal::getInstance(
   const char* *properties,
   const Linux_DnsManagedSystemElementForSettingInstanceName& instanceName) {
    
    CmpiObjectPath op=instanceName.getObjectPath();
    CmpiInstance inst=broker.getInstance(context,op,properties);
    return Linux_DnsManagedSystemElementForSettingInstance(inst,instanceName.getNamespace());
  }
      
  void Linux_DnsManagedSystemElementForSettingExternal::setInstance(
   const char* *properties,
   const Linux_DnsManagedSystemElementForSettingInstance& instance){
  
    CmpiObjectPath op=instance.getInstanceName().getObjectPath();
    CmpiInstance inst=instance.getCmpiInstance();
    broker.setInstance(context,op,inst,properties);
  }
      
  void Linux_DnsManagedSystemElementForSettingExternal::createInstance(
   const Linux_DnsManagedSystemElementForSettingInstance& instance){
  
    CmpiObjectPath op=instance.getInstanceName().getObjectPath();
    CmpiInstance inst=instance.getCmpiInstance();
    broker.createInstance(context,op,inst);
  }
  
  void Linux_DnsManagedSystemElementForSettingExternal::deleteInstance(
   const Linux_DnsManagedSystemElementForSettingInstanceName& instanceName){
    
    CmpiObjectPath op=instanceName.getObjectPath();
    broker.deleteInstance(context,op);
  }
      
    //Reference calls
    
    void Linux_DnsManagedSystemElementForSettingExternal::
     referencesElement( 
     const char *nsp,
     const char** properties,
     const Linux_DnsAddressMatchListInstanceName& sourceInst,
     Linux_DnsManagedSystemElementForSettingInstanceEnumeration& instances){
      
      CmpiObjectPath op=sourceInst.getObjectPath();
      CmpiEnumeration en=broker.references
       (context, op, "Linux_DnsAddressMatchList",
        "Element", properties);
      while(en.hasNext()) {
        CmpiInstance inst = en.getNext();
        Linux_DnsManagedSystemElementForSettingInstance instance(inst,nsp);
        instances.addElement(instance);
      }      
    }

    void Linux_DnsManagedSystemElementForSettingExternal::
     referenceNamesElement( 
     const char *nsp,
     const Linux_DnsAddressMatchListInstanceName& sourceInst,
     Linux_DnsManagedSystemElementForSettingInstanceNameEnumeration& instanceNames){
      
      CmpiObjectPath op=sourceInst.getObjectPath();
      CmpiEnumeration en=broker.referenceNames
       (context, op, "Linux_DnsAddressMatchList",
        "Element");
      while(en.hasNext()) {
        CmpiObjectPath instName = en.getNext();
        Linux_DnsManagedSystemElementForSettingInstanceName instanceName(instName);
        instanceNames.addElement(instanceName);
      }      
    }

    void Linux_DnsManagedSystemElementForSettingExternal::
     referencesSetting( 
     const char *nsp,
     const char** properties,
     const Linux_DnsZoneInstanceName& sourceInst,
     Linux_DnsManagedSystemElementForSettingInstanceEnumeration& instances){
      
      CmpiObjectPath op=sourceInst.getObjectPath();
      CmpiEnumeration en=broker.references
       (context, op, "Linux_DnsZone",
        "Setting", properties);
      while(en.hasNext()) {
        CmpiInstance inst = en.getNext();
        Linux_DnsManagedSystemElementForSettingInstance instance(inst,nsp);
        instances.addElement(instance);
      }      
    }

    void Linux_DnsManagedSystemElementForSettingExternal::
     referenceNamesSetting( 
     const char *nsp,
     const Linux_DnsZoneInstanceName& sourceInst,
     Linux_DnsManagedSystemElementForSettingInstanceNameEnumeration& instanceNames){
      
      CmpiObjectPath op=sourceInst.getObjectPath();
      CmpiEnumeration en=broker.referenceNames
       (context, op, "Linux_DnsZone",
        "Setting");
      while(en.hasNext()) {
        CmpiObjectPath instName = en.getNext();
        Linux_DnsManagedSystemElementForSettingInstanceName instanceName(instName);
        instanceNames.addElement(instanceName);
      }      
    }
     
    //Associator calls

    void Linux_DnsManagedSystemElementForSettingExternal::
     associatorsElement( 
     const char *nsp,
     const char** properties,
     const Linux_DnsAddressMatchListInstanceName& sourceInst,
     Linux_DnsZoneInstanceEnumeration& instances){
      
      CmpiObjectPath op=sourceInst.getObjectPath();
      CmpiEnumeration en=broker.associators
       (context,op,0,0,0,0,properties);
      while(en.hasNext()) {
        CmpiInstance inst = en.getNext();
        Linux_DnsZoneInstance instance(inst,nsp);
        instances.addElement(instance);
      }      
    }

    void Linux_DnsManagedSystemElementForSettingExternal::
     associatorNamesElement( 
     const char *nsp,
     const Linux_DnsAddressMatchListInstanceName& sourceInst,
     Linux_DnsZoneInstanceNameEnumeration& instanceNames){
      
      CmpiObjectPath op=sourceInst.getObjectPath();
      CmpiEnumeration en=broker.associatorNames
       (context,op,0,0,0,0);
      while(en.hasNext()) {
        CmpiObjectPath instName = en.getNext();
        Linux_DnsZoneInstanceName instanceName(instName);
        instanceNames.addElement(instanceName);
      }      
    }

    void Linux_DnsManagedSystemElementForSettingExternal::
     associatorsSetting( 
     const char *nsp,
     const char** properties,
     const Linux_DnsZoneInstanceName& sourceInst,
     Linux_DnsAddressMatchListInstanceEnumeration& instances){
      
      CmpiObjectPath op=sourceInst.getObjectPath();
      CmpiEnumeration en=broker.associators
       (context,op,0,0,0,0,properties);
      while(en.hasNext()) {
        CmpiInstance inst = en.getNext();
        Linux_DnsAddressMatchListInstance instance(inst,nsp);
        instances.addElement(instance);
      }      
    }

    void Linux_DnsManagedSystemElementForSettingExternal::
     associatorNamesSetting( 
     const char *nsp,
     const Linux_DnsZoneInstanceName& sourceInst,
     Linux_DnsAddressMatchListInstanceNameEnumeration& instanceNames){
      
      CmpiObjectPath op=sourceInst.getObjectPath();
      CmpiEnumeration en=broker.associatorNames
       (context,op,0,0,0,0);
      while(en.hasNext()) {
        CmpiObjectPath instName = en.getNext();
        Linux_DnsAddressMatchListInstanceName instanceName(instName);
        instanceNames.addElement(instanceName);
      }      
    }

      
}

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

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

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

--- NEW FILE: Linux_DnsManagedSystemElementForSettingDefaultImplementation.h ---
 /**
 * Linux_DnsManagedSystemElementForSettingDefaultImplementation.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_DnsManagedSystemElementForSettingDefaultImplementation_h
#define Linux_DnsManagedSystemElementForSettingDefaultImplementation_h

#include "Linux_DnsManagedSystemElementForSettingInstanceName.h"
#include "Linux_DnsManagedSystemElementForSettingManualInstance.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_DnsManagedSystemElementForSettingInterface.h"

namespace genProvider {

  class Linux_DnsManagedSystemElementForSettingDefaultImplementation:
   public Linux_DnsManagedSystemElementForSettingInterface {
  	
    public:    
    virtual ~Linux_DnsManagedSystemElementForSettingDefaultImplementation() { };
    
    /* intrinsic methods */
    virtual void enumInstanceNames(
     const CmpiContext& ctx,
     const CmpiBroker &mbp,
     const char *nsp,
     Linux_DnsManagedSystemElementForSettingInstanceNameEnumeration& instnames);
  	
    virtual void enumInstances(
     const CmpiContext& ctx,
     const CmpiBroker &mbp,
     const char *nsp,
     const char* *properties,
  	 Linux_DnsManagedSystemElementForSettingManualInstanceEnumeration& instances);
  	
    virtual Linux_DnsManagedSystemElementForSettingManualInstance getInstance(
     const CmpiContext& ctx,
     const CmpiBroker &mbp,
     const char* *properties,
     const Linux_DnsManagedSystemElementForSettingInstanceName&);
  	
    virtual void setInstance(
     const CmpiContext& ctx,
     const CmpiBroker &mbp,
     const char* *properties,
     const Linux_DnsManagedSystemElementForSettingManualInstance&);
  	
    virtual void createInstance(
     const CmpiContext& ctx,
     const CmpiBroker &mbp,
     const Linux_DnsManagedSystemElementForSettingManualInstance&);
  	
    virtual void deleteInstance(
     const CmpiContext& ctx,
     const CmpiBroker &mbp,
     const Linux_DnsManagedSystemElementForSettingInstanceName&);
	
    
    /* Association Interface */

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

    virtual void referencesSetting( 
     const CmpiContext& ctx,  
     const CmpiBroker &mbp,
     const char *nsp,
     const char** properties,
     const Linux_DnsZoneInstanceName& sourceInst,
     Linux_DnsManagedSystemElementForSettingManualInstanceEnumeration& 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_DnsManagedSystemElementForSettingFactory.h ---
 /**
 * Linux_DnsManagedSystemElementForSettingFactory.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_DnsManagedSystemElementForSettingFactory_h
#define Linux_DnsManagedSystemElementForSettingFactory_h


#include "Linux_DnsManagedSystemElementForSettingInterface.h"

namespace genProvider{
	
class Linux_DnsManagedSystemElementForSettingFactory{
public:

	Linux_DnsManagedSystemElementForSettingFactory(){};
	~Linux_DnsManagedSystemElementForSettingFactory(){};
	
	static Linux_DnsManagedSystemElementForSettingInterface* getImplementation();
};
}
#endif
 

--- NEW FILE: Linux_DnsManagedSystemElementForSettingRepositoryInstance.h ---
 /**
 * Linux_DnsManagedSystemElementForSettingRepositoryInstance.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_DnsManagedSystemElementForSettingRepositoryInstance_h
#define Linux_DnsManagedSystemElementForSettingRepositoryInstance_h

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

#include "Linux_DnsManagedSystemElementForSettingInstanceName.h"

namespace genProvider {

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

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


--- NEW FILE: Linux_DnsManagedSystemElementForSettingExternal.h ---
 /**
 * Linux_DnsManagedSystemElementForSettingExternal.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_DnsManagedSystemElementForSettingExternal_h
#define Linux_DnsManagedSystemElementForSettingExternal_h

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

namespace genProvider {

  class Linux_DnsManagedSystemElementForSettingExternal {
  	
    public:
    Linux_DnsManagedSystemElementForSettingExternal(
     const CmpiBroker& brkr, const CmpiContext& ctx);
    virtual ~Linux_DnsManagedSystemElementForSettingExternal();
    
    virtual void enumInstanceNames(
     const char *nsp,
     Linux_DnsManagedSystemElementForSettingInstanceNameEnumeration&);
     
    virtual void enumInstances(
     const char *nsp,
     const char* *properties,
     Linux_DnsManagedSystemElementForSettingInstanceEnumeration&);
     
    virtual Linux_DnsManagedSystemElementForSettingInstance getInstance(
     const char* *properties,
     const Linux_DnsManagedSystemElementForSettingInstanceName&);
     
    virtual void setInstance(
     const char* *properties,
     const Linux_DnsManagedSystemElementForSettingInstance&);
     
    virtual void createInstance(
     const Linux_DnsManagedSystemElementForSettingInstance&);
     
    virtual void deleteInstance(
     const Linux_DnsManagedSystemElementForSettingInstanceName&);
    
    //association calls
    
    void referencesElement( 
     const char *nsp,
     const char** properties,
     const Linux_DnsAddressMatchListInstanceName& sourceInst,
     Linux_DnsManagedSystemElementForSettingInstanceEnumeration& instances);

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

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

    void referenceNamesSetting( 
     const char *nsp,
     const Linux_DnsZoneInstanceName& sourceInst,
     Linux_DnsManagedSystemElementForSettingInstanceNameEnumeration& 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: 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_DnsManagedSystemElementForSettingInstanceName.o \
        Linux_DnsManagedSystemElementForSettingInstance.o \
        Linux_DnsManagedSystemElementForSettingExternal.o \
        Linux_DnsManagedSystemElementForSettingRepositoryInstance.o \
        Linux_DnsManagedSystemElementForSettingRepositoryExternal.o \
        Linux_DnsManagedSystemElementForSettingManualInstance.o \
        Linux_DnsManagedSystemElementForSettingDefaultImplementation.o

FAKEFACTORY= Linux_DnsManagedSystemElementForSettingFakeFactory.o

NORMALFACTORY= Linux_DnsManagedSystemElementForSettingFactory.o

RESOURCEOBJECT= Linux_DnsManagedSystemElementForSettingResourceAccess.o

PROVIDEROBJECT=CmpiLinux_DnsManagedSystemElementForSettingProvider.o 

all: testfiles preinstall install

buildall: clean all

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

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

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

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

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

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

deleteFakeLib:
	$(RM) *.so

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

preinstall: prelink
	install libLinux_DnsManagedSystemElementForSettingSupport.so $(COMMONLIB_OUT)

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

install: link
	install libLinux_DnsManagedSystemElementForSettingSupport.so $(COMMONLIB_OUT)	
	install libLinux_DnsManagedSystemElementForSetting.so $(CIMOMLIB_OUT)
#	install -m 644 Linux_DnsManagedSystemElementForSetting*.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_DnsManagedSystemElementForSetting*.h \
	$(RM) $(COMMONLIB)/libLinux_DnsManagedSystemElementForSettingSupport.so \
	$(RM) $(CIMOMLIB)/libLinux_DnsManagedSystemElementForSetting.so

--- NEW FILE: Linux_DnsManagedSystemElementForSettingFactory.cpp ---
 /**
 * Linux_DnsManagedSystemElementForSettingFactory.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_DnsManagedSystemElementForSettingFactory.h"
#include "Linux_DnsManagedSystemElementForSettingResourceAccess.h"

namespace genProvider{
	
	Linux_DnsManagedSystemElementForSettingInterface* 
	  Linux_DnsManagedSystemElementForSettingFactory::getImplementation(){
	  	
	  	return (new Linux_DnsManagedSystemElementForSettingResourceAccess());
	  };
}
 

--- NEW FILE: Linux_DnsManagedSystemElementForSettingInstanceName.h ---
 /**
 * Linux_DnsManagedSystemElementForSettingInstanceName.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_DnsManagedSystemElementForSettingInstanceName_h
#define Linux_DnsManagedSystemElementForSettingInstanceName_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_DnsManagedSystemElementForSettingInstanceName {
  public:
       Linux_DnsManagedSystemElementForSettingInstanceName();
  	
       Linux_DnsManagedSystemElementForSettingInstanceName
  	    (const Linux_DnsManagedSystemElementForSettingInstanceName& original);
  	   
       Linux_DnsManagedSystemElementForSettingInstanceName
        (const CmpiObjectPath& path);
  	 
       ~Linux_DnsManagedSystemElementForSettingInstanceName();
       
       Linux_DnsManagedSystemElementForSettingInstanceName& operator=
  	    (const Linux_DnsManagedSystemElementForSettingInstanceName& 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_DnsManagedSystemElementForSettingInstanceName& 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_DnsManagedSystemElementForSettingInstanceNameEnumerationElement{
  	Linux_DnsManagedSystemElementForSettingInstanceName* m_elementP;
  	Linux_DnsManagedSystemElementForSettingInstanceNameEnumerationElement* m_nextP;
  	
  	Linux_DnsManagedSystemElementForSettingInstanceNameEnumerationElement();
  	~Linux_DnsManagedSystemElementForSettingInstanceNameEnumerationElement();  	
  };
  

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


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

using namespace std;

namespace genProvider {

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

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

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

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

      Linux_DnsZoneExternal external(mbp, ctx);

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

    void Linux_DnsManagedSystemElementForSettingDefaultI...
 
[truncated message content]