Thread: [Sblim-commit] cmpi-dns/provider/Linux_DnsAllowQueryACLForZone Linux_DnsAllowQueryACLForZoneManualIn

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

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

Added Files:
	Linux_DnsAllowQueryACLForZoneManualInstance.h 
	Linux_DnsAllowQueryACLForZoneInterface.h 
	Linux_DnsAllowQueryACLForZoneInstanceName.cpp 
	Linux_DnsAllowQueryACLForZoneFactory.h 
	Linux_DnsAllowQueryACLForZoneDefaultImplementation.cpp 
	Linux_DnsAllowQueryACLForZoneDefaultImplementation.h 
	setting.provider 
	Linux_DnsAllowQueryACLForZoneResourceAccess.cpp 
	Linux_DnsAllowQueryACLForZoneRepositoryExternal.h 
	Linux_DnsAllowQueryACLForZoneInstanceName.h 
	Linux_DnsAllowQueryACLForZoneFactory.cpp 
	Linux_DnsAllowQueryACLForZoneResourceAccess.h 
	Linux_DnsAllowQueryACLForZoneExternal.h 
	Linux_DnsAllowQueryACLForZoneRepositoryInstance.h makefile 
	Linux_DnsAllowQueryACLForZoneManualInstance.cpp 
	Linux_DnsAllowQueryACLForZoneRepositoryInstance.cpp 
	Linux_DnsAllowQueryACLForZoneRepositoryExternal.cpp 
	Linux_DnsAllowQueryACLForZoneFakeFactory.cpp 
	Linux_DnsAllowQueryACLForZoneInstance.h 
	Linux_DnsAllowQueryACLForZoneExternal.cpp 
	CmpiLinux_DnsAllowQueryACLForZoneProvider.h 
	Linux_DnsAllowQueryACLForZoneInstance.cpp 
	CmpiLinux_DnsAllowQueryACLForZoneProvider.cpp 
Log Message:
WBEM-SMT DNS provider component.

First initial upload.

This module includes: 
- CIM model for DNS
- CMPI provider for DNS
- Resource Access layer for DNS

--- NEW FILE: setting.provider ---
#Provider configuration

#CPPFLAGS.provider
LDFLAGS.provider=-ldnssupport

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

namespace genProvider{

  Linux_DnsAllowQueryACLForZoneRepositoryExternal::Linux_DnsAllowQueryACLForZoneRepositoryExternal(
   const CmpiBroker& brkr, const CmpiContext& ctx ) 
   : broker(brkr), context(ctx) {};

  const char * Linux_DnsAllowQueryACLForZoneRepositoryExternal::
   nsp="IBMShadow/cimv2";

  Linux_DnsAllowQueryACLForZoneRepositoryExternal::
   ~Linux_DnsAllowQueryACLForZoneRepositoryExternal(){};

  void Linux_DnsAllowQueryACLForZoneRepositoryExternal::enumInstanceNames(
   Linux_DnsAllowQueryACLForZoneInstanceNameEnumeration& instnames) {

    CmpiObjectPath op(nsp,"Linux_DnsAllowQueryACLForZone");
    CmpiEnumeration en=broker.enumInstanceNames(context,op);
    while(en.hasNext()) {
      CmpiObjectPath opi = en.getNext();
      Linux_DnsAllowQueryACLForZoneInstanceName iname(opi);
      instnames.addElement(iname);
    }
  };

  void Linux_DnsAllowQueryACLForZoneRepositoryExternal::enumInstances(
   const char* *properties,
   Linux_DnsAllowQueryACLForZoneRepositoryInstanceEnumeration& instances) {

    CmpiObjectPath op(nsp,"Linux_DnsAllowQueryACLForZone");
    CmpiEnumeration en=broker.enumInstances(context,op,properties);
    while(en.hasNext()) {
      CmpiInstance inst = en.getNext();
      Linux_DnsAllowQueryACLForZoneRepositoryInstance instance(inst,nsp);
      instances.addElement(instance);
    }
  };

  Linux_DnsAllowQueryACLForZoneRepositoryInstance
   Linux_DnsAllowQueryACLForZoneRepositoryExternal::getInstance(
   const char* *properties,
   const Linux_DnsAllowQueryACLForZoneInstanceName& instanceName) {

    CmpiObjectPath op=instanceName.getObjectPath();
    op.setNameSpace(nsp);
    CmpiInstance inst=broker.getInstance(context,op,properties);
    return Linux_DnsAllowQueryACLForZoneRepositoryInstance(inst,nsp);
  }

  void Linux_DnsAllowQueryACLForZoneRepositoryExternal::setInstance(
   const char* *properties,
   const Linux_DnsAllowQueryACLForZoneRepositoryInstance& instance){

    //make a copy of the given instance and set it to the right nameSpace
    Linux_DnsAllowQueryACLForZoneInstanceName instanceName(instance.getInstanceName());
    instanceName.setNamespace(nsp,1);
    Linux_DnsAllowQueryACLForZoneRepositoryInstance copiedInstance(instance);
    copiedInstance.setInstanceName(instanceName);

    CmpiObjectPath op=instanceName.getObjectPath();
    CmpiInstance inst=copiedInstance.getCmpiInstance();
    broker.setInstance(context,op,inst,properties);
  }

  void Linux_DnsAllowQueryACLForZoneRepositoryExternal::createInstance(
   const Linux_DnsAllowQueryACLForZoneRepositoryInstance& instance){

    //make a copy of the given instance and set it to the right nameSpace
    Linux_DnsAllowQueryACLForZoneInstanceName instanceName(instance.getInstanceName());
    instanceName.setNamespace(nsp,1);
    Linux_DnsAllowQueryACLForZoneRepositoryInstance copiedInstance(instance);
    copiedInstance.setInstanceName(instanceName);

    CmpiObjectPath op=instanceName.getObjectPath();
    CmpiInstance inst=copiedInstance.getCmpiInstance();
    broker.createInstance(context,op,inst);
  }

  void Linux_DnsAllowQueryACLForZoneRepositoryExternal::deleteInstance(
   const Linux_DnsAllowQueryACLForZoneInstanceName& instanceName){

    CmpiObjectPath op=instanceName.getObjectPath();
    op.setNameSpace(nsp);
    broker.deleteInstance(context,op);
  }  
}

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

#define DNS_ATTR_STR	"allow-query"

namespace genProvider {

    //Linux_DnsAllowQueryACLForZoneResourceAccess::Linux_DnsAllowQueryACLForZoneResourceAccess();
    Linux_DnsAllowQueryACLForZoneResourceAccess::~Linux_DnsAllowQueryACLForZoneResourceAccess() { };

    /* intrinsic methods */

    void Linux_DnsAllowQueryACLForZoneResourceAccess::enumInstanceNames(
     const CmpiContext& ctx, const CmpiBroker &mbp, const char *nsp,
     Linux_DnsAllowQueryACLForZoneInstanceNameEnumeration& instnames){

      	DNSZONE * zones, all_zones;

        zones = getZones();

        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_DnsAllowQueryACLForZoneInstanceName 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); 
		}
        }
	freeZones( zones );    
    }

    void Linux_DnsAllowQueryACLForZoneResourceAccess::enumInstances(
     const CmpiContext& ctx,
     const CmpiBroker &mbp,
     const char *nsp,
     const char* *properties,
  	 Linux_DnsAllowQueryACLForZoneManualInstanceEnumeration& 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_DnsAllowQueryACLForZoneInstanceName AuInstName;
			Linux_DnsAllowQueryACLForZoneManualInstance 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( zones ); 
    };

    Linux_DnsAllowQueryACLForZoneManualInstance 
     Linux_DnsAllowQueryACLForZoneResourceAccess::getInstance(
     const CmpiContext& ctx,
     const CmpiBroker &mbp,
     const char* *properties,
     const Linux_DnsAllowQueryACLForZoneInstanceName& instanceName){

     	Linux_DnsAllowQueryACLForZoneManualInstance AuInst;
        AuInst.setInstanceName( instanceName );
	return AuInst;

    }

  	/*
    void Linux_DnsAllowQueryACLForZoneResourceAccess::setInstance(
     const CmpiContext& ctx,
     const CmpiBroker &mbp,
     const char* *properties,
     const Linux_DnsAllowQueryACLForZoneManualInstance&){};
  	*/

    void Linux_DnsAllowQueryACLForZoneResourceAccess::createInstance(
     const CmpiContext& ctx, const CmpiBroker &mbp,
     const Linux_DnsAllowQueryACLForZoneManualInstance& anInstance){
	cout << "Linux_DnsAllowQueryACLForZoneResourceAccess::createInstance()" << endl;

   	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 already exist masters put them in the list.
	if (zopts)
	{
		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_DnsAllowQueryACLForZoneResourceAccess::deleteInstance(
     const CmpiContext& ctx, const CmpiBroker &mbp,
     const Linux_DnsAllowQueryACLForZoneInstanceName& 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 already exist masters put them in the list.
	if (zopts)
	{
		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_DnsAllowQueryACLForZoneResourceAccess::referencesElement( 
     const CmpiContext& ctx,  
     const CmpiBroker &mbp,
     const char *nsp,
     const char** properties,
     const Linux_DnsAddressMatchListInstanceName& sourceInst,
     Linux_DnsAllowQueryACLForZoneManualInstanceEnumeration& instEnum) {

	cout << "Linux_DnsAllowQueryACLForZoneResourceAccess::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_DnsAllowQueryACLForZoneInstanceName AuInstName;
			Linux_DnsAllowQueryACLForZoneManualInstance 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_DnsAllowQueryACLForZoneResourceAccess::referencesSetting( 
     const CmpiContext& ctx,  
     const CmpiBroker &mbp,
     const char *nsp,
     const char** properties,
     const Linux_DnsZoneInstanceName& sourceInst,
     Linux_DnsAllowQueryACLForZoneManualInstanceEnumeration& instEnum) {

	cout << "Linux_DnsAllowQueryACLForZoneResourceAccess::referencesSetting()" << endl;

	// ACL *list_acl = ReadACL();
	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++)
        {
		if ( strcmp( zones->zoneName, sourceInst.getName() ) != 0 )
				continue;

		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_DnsAllowQueryACLForZoneManualInstance AuInst;
			Linux_DnsAllowQueryACLForZoneInstanceName AuInstName;

			// AddressMatchList -> Setting
			Linux_DnsAddressMatchListInstance addrList;
			Linux_DnsAddressMatchListInstanceName addrListName;
			addrListName.setNamespace( nsp );
			addrListName.setName( (*iter).c_str() );
			addrListName.setServiceName( DEFAULT_SERVICE_NAME );
			/* addrList.setInstanceName( addrListName );
			char *aclValue = getACL(list_acl, (*iter).c_str());
			if ( ! aclValue )
				continue;

			DnsArray aclArray = DnsArray( aclValue );
			addrList.setAddressList( aclArray.toArray(), aclArray.size() ); */
			//

			// Zone -> Element
			AuInstName.setElement( sourceInst );
			AuInstName.setSetting( addrListName );
			AuInst.setInstanceName( AuInstName );

			instEnum.addElement( AuInst );
		}
	}
	freeZones( all_zones );
   };

    void Linux_DnsAllowQueryACLForZoneResourceAccess::associatorsElement( 
     const CmpiContext& ctx,  
     const CmpiBroker &mbp,
     const char *nsp,
     const char** properties,
     const Linux_DnsAddressMatchListInstanceName& sourceInst,
     Linux_DnsZoneInstanceEnumeration& instEnum) {

	cout << "Linux_DnsAllowQueryACLForZoneResourceAccess::associatorsElement()" << 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;

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

			instEnum.addElement( zoneInst );
		}
	}
	freeZones( all_zones );
    };

    void Linux_DnsAllowQueryACLForZoneResourceAccess::associatorsSetting( 
     const CmpiContext& ctx,  
     const CmpiBroker &mbp,
     const char *nsp,
     const char** properties,
     const Linux_DnsZoneInstanceName& sourceInst,
     Linux_DnsAddressMatchListInstanceEnumeration& instEnum) {
     	cout << "Linux_DnsAllowQueryACLForZoneResourceAccess::associatorsSetting()" << endl;

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

	ACL *list_acl = ReadACL();

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

        for (; zones->zoneName && list_acl ; zones++)
        {
		if ( strcmp( zones->zoneName, sourceInst.getName() ) != 0 )
				continue;

		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)
		{

			// AddressMatchList -> Setting
			Linux_DnsAddressMatchListInstance addrList;
			Linux_DnsAddressMatchListInstanceName addrListName;
			addrListName.setNamespace( nsp );
			addrListName.setName( (*iter).c_str() );
			addrListName.setServiceName( DEFAULT_SERVICE_NAME );
			addrList.setInstanceName( addrListName );

			char *aclValue = getACL(list_acl, (*iter).c_str());
			if ( ! aclValue )
				continue;

			DnsArray aclArray = DnsArray( aclValue );
			addrList.setAddressList( aclArray.toArray(), aclArray.size() );
			addrList.setAddressListType( DNS_AMLTYPE_AML );

			instEnum.addElement( addrList );
		}
	}
	freeZones( all_zones );
     };

    /* extrinsic methods */

}

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

namespace genProvider {

  //*********************************************************
  //Linux_DnsAllowQueryACLForZoneInstance
  //*********************************************************

  //empty constructor
  Linux_DnsAllowQueryACLForZoneInstance::
   Linux_DnsAllowQueryACLForZoneInstance(){   	
   	init();  	   	
  };

  //copy constructor	
  Linux_DnsAllowQueryACLForZoneInstance::
   Linux_DnsAllowQueryACLForZoneInstance
   (const Linux_DnsAllowQueryACLForZoneInstance& original){   	
   	init(original);  	   	
  };

  //constructor using CmpiInstance
  Linux_DnsAllowQueryACLForZoneInstance::
   Linux_DnsAllowQueryACLForZoneInstance (const CmpiInstance& inst, const char* instanceNamespace){
    CmpiData cmpiData;
    init(); 

    CmpiObjectPath cop=inst.getObjectPath();
    cop.setNameSpace(instanceNamespace);
    setInstanceName(Linux_DnsAllowQueryACLForZoneInstanceName(cop));

  }

  //Destructor
  Linux_DnsAllowQueryACLForZoneInstance::
   ~Linux_DnsAllowQueryACLForZoneInstance(){
   	reset();  	  
  };

  //copy operator
  Linux_DnsAllowQueryACLForZoneInstance&
   Linux_DnsAllowQueryACLForZoneInstance::operator=
   (const Linux_DnsAllowQueryACLForZoneInstance& original){   	
   	init(original);
   	return *this;
  };

  //converts to CmpiInstance
  CmpiInstance Linux_DnsAllowQueryACLForZoneInstance::
   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_DnsAllowQueryACLForZoneInstance::
   isInstanceNameSet() const{
  	return isSet.instanceName;
  }

  const Linux_DnsAllowQueryACLForZoneInstanceName&
    Linux_DnsAllowQueryACLForZoneInstance::getInstanceName() const{

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

   	return m_instanceName;
  }

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

  //set isSet attributes to FALSE
  void Linux_DnsAllowQueryACLForZoneInstance::init(){
   	isSet.instanceName=0;

  };

  //copies another instance properties in this
  void Linux_DnsAllowQueryACLForZoneInstance::init
   (const Linux_DnsAllowQueryACLForZoneInstance& original){   	
   	init();

    if(original.isInstanceNameSet()){
      setInstanceName(original.getInstanceName());
    }    
   }

  //reset the instance data
  void Linux_DnsAllowQueryACLForZoneInstance::reset(){

  };

  //*********************************************************
  //Linux_DnsAllowQueryACLForZoneInstanceEnumerationElement	
  //*********************************************************

  Linux_DnsAllowQueryACLForZoneInstanceEnumerationElement::
   Linux_DnsAllowQueryACLForZoneInstanceEnumerationElement(){

  	m_elementP=0;
  	m_nextP=0;

  };

  Linux_DnsAllowQueryACLForZoneInstanceEnumerationElement::
   ~Linux_DnsAllowQueryACLForZoneInstanceEnumerationElement(){

  	if (m_elementP!=0)
  	  delete(m_elementP);
  	if (m_nextP!=0)
  	  delete(m_nextP);

  };

  //*********************************************************
  //Linux_DnsAllowQueryACLForZoneInstanceNameEnumeration
  //*********************************************************

  Linux_DnsAllowQueryACLForZoneInstanceEnumeration::
   Linux_DnsAllowQueryACLForZoneInstanceEnumeration(){

  	 firstElementP=0;
     currentElementP=0;
     endElementP=0;
  };

  Linux_DnsAllowQueryACLForZoneInstanceEnumeration::
   Linux_DnsAllowQueryACLForZoneInstanceEnumeration(
   const Linux_DnsAllowQueryACLForZoneInstanceEnumeration& original){

     firstElementP=0;
     currentElementP=0;
     endElementP=0;

     int size=original.getSize();
     for(int i=0;i<size;i++)
       addElement(original.getElement(i));           
  };

  Linux_DnsAllowQueryACLForZoneInstanceEnumeration::
   ~Linux_DnsAllowQueryACLForZoneInstanceEnumeration(){

  	if (firstElementP!=0)
  	  delete(firstElementP);

  };

  void Linux_DnsAllowQueryACLForZoneInstanceEnumeration::reset(){

  	currentElementP=firstElementP;
  };

  bool Linux_DnsAllowQueryACLForZoneInstanceEnumeration::hasNext() const{

  	return (currentElementP!=0);

  };

  int Linux_DnsAllowQueryACLForZoneInstanceEnumeration::getSize() const{

    int size=0;
    Linux_DnsAllowQueryACLForZoneInstanceEnumerationElement* followingP=firstElementP;

  	while(followingP!=0){
        followingP=followingP->m_nextP;
        size++;
    }

    return size;

  };

  const Linux_DnsAllowQueryACLForZoneInstance&  
   Linux_DnsAllowQueryACLForZoneInstanceEnumeration::getElement(int pos) const{

    Linux_DnsAllowQueryACLForZoneInstanceEnumerationElement* followingP=firstElementP;

    int i=0;
    while((followingP!=0)&&(i<pos)){
        followingP=followingP->m_nextP;
        i++;
    }

    return *(followingP->m_elementP);
  };

  const Linux_DnsAllowQueryACLForZoneInstance&
   Linux_DnsAllowQueryACLForZoneInstanceEnumeration::getNext() {

  	 Linux_DnsAllowQueryACLForZoneInstanceEnumerationElement* currentP=
  	  currentElementP;
  	 currentElementP=currentElementP->m_nextP;

  	 return *(currentP->m_elementP);
  };

  void Linux_DnsAllowQueryACLForZoneInstanceEnumeration::addElement
   (const Linux_DnsAllowQueryACLForZoneInstance& elementP){

  	if(firstElementP==0){
  	  firstElementP=new Linux_DnsAllowQueryACLForZoneInstanceEnumerationElement();
  	  firstElementP->m_elementP=new Linux_DnsAllowQueryACLForZoneInstance(elementP);
  	  endElementP=firstElementP;
  	  currentElementP=firstElementP;
  	}else{
  	  endElementP->m_nextP=new Linux_DnsAllowQueryACLForZoneInstanceEnumerationElement();
  	  endElementP=endElementP->m_nextP;
  	  endElementP->m_elementP=new Linux_DnsAllowQueryACLForZoneInstance(elementP);
  	}
  };  
}

--- NEW FILE: Linux_DnsAllowQueryACLForZoneManualInstance.h ---
 /**
 * Linux_DnsAllowQueryACLForZoneManualInstance.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_DnsAllowQueryACLForZoneManualInstance_h
#define Linux_DnsAllowQueryACLForZoneManualInstance_h

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

#include "Linux_DnsAllowQueryACLForZoneInstanceName.h"

namespace genProvider {

  class Linux_DnsAllowQueryACLForZoneManualInstance {
  public:
       Linux_DnsAllowQueryACLForZoneManualInstance();

       Linux_DnsAllowQueryACLForZoneManualInstance
  	    (const Linux_DnsAllowQueryACLForZoneManualInstance& original);

       Linux_DnsAllowQueryACLForZoneManualInstance
        (const CmpiInstance& inst, const char* instanceNamespace);

       ~Linux_DnsAllowQueryACLForZoneManualInstance();

       Linux_DnsAllowQueryACLForZoneManualInstance& operator=
  	    (const Linux_DnsAllowQueryACLForZoneManualInstance& original);

       CmpiInstance getCmpiInstance(const char** properties=0) const;

       unsigned int isInstanceNameSet() const;
       void setInstanceName(
        const Linux_DnsAllowQueryACLForZoneInstanceName& val);        
       const Linux_DnsAllowQueryACLForZoneInstanceName&
        getInstanceName() const;

  private:
       void init();
       void init(const Linux_DnsAllowQueryACLForZoneManualInstance& original);
       void reset();

       Linux_DnsAllowQueryACLForZoneInstanceName m_instanceName;

       struct isSetType{
       	 unsigned int instanceName:1;
       } isSet;
  };

  struct Linux_DnsAllowQueryACLForZoneManualInstanceEnumerationElement{
  	Linux_DnsAllowQueryACLForZoneManualInstance* m_elementP;
  	Linux_DnsAllowQueryACLForZoneManualInstanceEnumerationElement* m_nextP;

  	Linux_DnsAllowQueryACLForZoneManualInstanceEnumerationElement();
  	~Linux_DnsAllowQueryACLForZoneManualInstanceEnumerationElement();  	
  };

  class Linux_DnsAllowQueryACLForZoneManualInstanceEnumeration {
  	private:
  	  Linux_DnsAllowQueryACLForZoneManualInstanceEnumerationElement* firstElementP;
  	  Linux_DnsAllowQueryACLForZoneManualInstanceEnumerationElement* currentElementP;
  	  Linux_DnsAllowQueryACLForZoneManualInstanceEnumerationElement* endElementP;

  	public:
  	  Linux_DnsAllowQueryACLForZoneManualInstanceEnumeration();

  	  Linux_DnsAllowQueryACLForZoneManualInstanceEnumeration(
  	   const Linux_DnsAllowQueryACLForZoneManualInstanceEnumeration& original);

  	  ~Linux_DnsAllowQueryACLForZoneManualInstanceEnumeration();

  	  void reset();

  	  bool hasNext() const;

  	  const Linux_DnsAllowQueryACLForZoneManualInstance& getNext();

  	  int getSize() const;

  	  const Linux_DnsAllowQueryACLForZoneManualInstance& getElement(int pos) const;  	  

  	 void addElement(const Linux_DnsAllowQueryACLForZoneManualInstance& elementP);
  };
}
#endif

--- NEW FILE: Linux_DnsAllowQueryACLForZoneFactory.h ---
 /**
 * Linux_DnsAllowQueryACLForZoneFactory.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...

[truncated message content]

Thread: [Sblim-commit] cmpi-dns/provider/Linux_DnsAllowQueryACLForZone Linux_DnsAllowQueryACLForZoneManualIn

sblim-commit