/sblim-cmpi-samba-1.0/provider/Linux_SambaShareSecurityForGlobal/Linux_SambaShareSecurityForGlobalInstance.cpp

// =======================================================================

// Linux_SambaShareSecurityForGlobalInstance.cpp

//     created on Fri, 23 Jun 2006 using ECUTE 2.2.1

//

// Copyright (c) 2006, 2009, International Business Machines

//

// THIS FILE IS PROVIDED UNDER THE TERMS OF THE ECLIPSE 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 Eclipse Public License from

// http://www.opensource.org/licenses/eclipse-1.0.php

//

// Author:        generated

//

// Contributors:

//                Wolfgang Taphorn   <taphorn@de.ibm.com>

//                Mukunda Chowdaiah  <cmukunda@in.ibm.com>

//                Ashoka S Rao       <ashoka.rao@in.ibm.com>

//                Rodrigo Ceron      <rceron@br.ibm.com>

//

// =======================================================================

#include "Linux_SambaShareSecurityForGlobalInstance.h"

#include "CmpiData.h"

#include "CmpiString.h"

#include "CmpiArray.h"

#include <string>



namespace genProvider {



  //****************************************************************************

  //Linux_SambaShareSecurityForGlobalInstance

  //----------------------------------------------------------------------------

  //empty constructor

  Linux_SambaShareSecurityForGlobalInstance::Linux_SambaShareSecurityForGlobalInstance() {   	

   	init();  	   	

  }

  

  //----------------------------------------------------------------------------

  //copy constructor	

  //----------------------------------------------------------------------------

  Linux_SambaShareSecurityForGlobalInstance::Linux_SambaShareSecurityForGlobalInstance(

    const Linux_SambaShareSecurityForGlobalInstance& anInstance) {   	

   	init(anInstance);  	   	

  }

  

  //----------------------------------------------------------------------------

  //constructor using CmpiInstance

  //----------------------------------------------------------------------------

  Linux_SambaShareSecurityForGlobalInstance::Linux_SambaShareSecurityForGlobalInstance(

    const CmpiInstance& aCmpiInstance,

    const char* anInstanceNamespaceP) {



    CmpiData cmpiData;



    init(); 

    

    CmpiObjectPath cop = aCmpiInstance.getObjectPath();

    cop.setNameSpace(anInstanceNamespaceP);

    setInstanceName(Linux_SambaShareSecurityForGlobalInstanceName(cop));



    cmpiData = aCmpiInstance.getProperty("IsCurrent");

    if ( ! cmpiData.isNullValue()){

      CMPIUint16 IsCurrent = cmpiData;

      setIsCurrent(IsCurrent);

    }



    cmpiData = aCmpiInstance.getProperty("IsDefault");

    if ( ! cmpiData.isNullValue()){

      CMPIUint16 IsDefault = cmpiData;

      setIsDefault(IsDefault);

    }



    

  }

  

  //----------------------------------------------------------------------------

  //Destructor

  //----------------------------------------------------------------------------

  Linux_SambaShareSecurityForGlobalInstance::

   ~Linux_SambaShareSecurityForGlobalInstance(){

   	reset();  	  

  }

  

  

  //----------------------------------------------------------------------------

  //copy operator

  //----------------------------------------------------------------------------

  Linux_SambaShareSecurityForGlobalInstance&

  Linux_SambaShareSecurityForGlobalInstance::operator=(

    const Linux_SambaShareSecurityForGlobalInstance& anInstance) {   	

   	

   	init(anInstance);

   	return *this;

  

  }

  

  

  //----------------------------------------------------------------------------

  //converts to CmpiInstance

  //----------------------------------------------------------------------------

  CmpiInstance

  Linux_SambaShareSecurityForGlobalInstance::getCmpiInstance(

    const char** aPropertiesPP) const {

   	

   	CmpiObjectPath objectPath=getInstanceName().getObjectPath();      

    CmpiInstance cmpiInstance(objectPath);    

    getInstanceName().fillKeys(cmpiInstance);

    

    if (aPropertiesPP) {

	    cmpiInstance.setPropertyFilter(aPropertiesPP,0);

    }



  	if (isSet.IsCurrent) {

  	  

  	  cmpiInstance.setProperty(

  	    "IsCurrent",

  	    CmpiData(m_IsCurrent));

  	}



  	if (isSet.IsDefault) {

  	  

  	  cmpiInstance.setProperty(

  	    "IsDefault",

  	    CmpiData(m_IsDefault));

  	}



  	

  	return cmpiInstance;

  	

  }

  

  //----------------------------------------------------------------------------

  // InstanceName related methods

  //----------------------------------------------------------------------------

  unsigned int 

  Linux_SambaShareSecurityForGlobalInstance::isInstanceNameSet() const {

  	return isSet.instanceName;

  }

  

  //----------------------------------------------------------------------------

  const Linux_SambaShareSecurityForGlobalInstanceName&

  Linux_SambaShareSecurityForGlobalInstance::getInstanceName() const {



    if( ! isSet.instanceName) {

   	  throw CmpiErrorFormater::getErrorException(

        CmpiErrorFormater::NOT_SET,

        "InstanceName (CIM Key Attributes)",

        "Linux_SambaShareSecurityForGlobal");

   	}

  		

   	return m_instanceName;

  

  }



  //----------------------------------------------------------------------------

  void

  Linux_SambaShareSecurityForGlobalInstance::setInstanceName(

    const Linux_SambaShareSecurityForGlobalInstanceName& val) {



    m_instanceName = val;

    isSet.instanceName = 1;



  }

       

  //----------------------------------------------------------------------------

  // IsCurrent related methods

  //----------------------------------------------------------------------------

  unsigned int

  Linux_SambaShareSecurityForGlobalInstance::isIsCurrentSet() const {

    return isSet.IsCurrent;

  }



  //----------------------------------------------------------------------------

  void Linux_SambaShareSecurityForGlobalInstance::setIsCurrent(

    const CMPIUint16 aValue) {

  

    m_IsCurrent = aValue;

    isSet.IsCurrent = 1;

  

  }       



  //----------------------------------------------------------------------------

  const CMPIUint16

  Linux_SambaShareSecurityForGlobalInstance::getIsCurrent() const {

    

    if ( ! isSet.IsCurrent) {

   	  throw CmpiErrorFormater::getErrorException(

   	    CmpiErrorFormater::NOT_SET,

        "IsCurrent",

        "Linux_SambaShareSecurityForGlobal");

   	}





    return m_IsCurrent;



  }

       

  //----------------------------------------------------------------------------

  // IsDefault related methods

  //----------------------------------------------------------------------------

  unsigned int

  Linux_SambaShareSecurityForGlobalInstance::isIsDefaultSet() const {

    return isSet.IsDefault;

  }



  //----------------------------------------------------------------------------

  void Linux_SambaShareSecurityForGlobalInstance::setIsDefault(

    const CMPIUint16 aValue) {

  

    m_IsDefault = aValue;

    isSet.IsDefault = 1;

  

  }       



  //----------------------------------------------------------------------------

  const CMPIUint16

  Linux_SambaShareSecurityForGlobalInstance::getIsDefault() const {

    

    if ( ! isSet.IsDefault) {

   	  throw CmpiErrorFormater::getErrorException(

   	    CmpiErrorFormater::NOT_SET,

        "IsDefault",

        "Linux_SambaShareSecurityForGlobal");

   	}





    return m_IsDefault;



  }



  

  //----------------------------------------------------------------------------

  //set isSet attributes to FALSE

  //----------------------------------------------------------------------------

  void

  Linux_SambaShareSecurityForGlobalInstance::init() {

   	isSet.instanceName = 0;

    isSet.IsCurrent = 0;

    isSet.IsDefault = 0;

  	

  }

  

  //----------------------------------------------------------------------------

  //copies another instance properties in this

  //----------------------------------------------------------------------------

  void 

  Linux_SambaShareSecurityForGlobalInstance::init(

    const Linux_SambaShareSecurityForGlobalInstance& anOriginal) {   	



   	init();

   	   	

    if(anOriginal.isInstanceNameSet()) {

      setInstanceName(anOriginal.getInstanceName());

    }

       	

    if (anOriginal.isIsCurrentSet()) {

      const CMPIUint16 IsCurrentOriginal = anOriginal.getIsCurrent();

      setIsCurrent(IsCurrentOriginal);

    }

   	

    if (anOriginal.isIsDefaultSet()) {

      const CMPIUint16 IsDefaultOriginal = anOriginal.getIsDefault();

      setIsDefault(IsDefaultOriginal);

    }

    

  }

  

  //----------------------------------------------------------------------------

  //reset the instance data

  //----------------------------------------------------------------------------

  void

  Linux_SambaShareSecurityForGlobalInstance::reset() {

   	

  }

  

  //----------------------------------------------------------------------------

  //Linux_SambaShareSecurityForGlobalInstanceEnumerationElement	

  //----------------------------------------------------------------------------

  Linux_SambaShareSecurityForGlobalInstanceEnumerationElement::Linux_SambaShareSecurityForGlobalInstanceEnumerationElement() {

   	

  	m_elementP = 0;

  	m_nextP = 0;

  	  

  }

  

  //----------------------------------------------------------------------------

  Linux_SambaShareSecurityForGlobalInstanceEnumerationElement::~Linux_SambaShareSecurityForGlobalInstanceEnumerationElement() {

   	

  	if (m_elementP) {

  	  delete(m_elementP);

  	}

  	

  	if (m_nextP) {

  	  delete(m_nextP);

  	}

  	  

  }



  //----------------------------------------------------------------------------

  //Linux_SambaShareSecurityForGlobalInstanceNameEnumeration

  //----------------------------------------------------------------------------

  Linux_SambaShareSecurityForGlobalInstanceEnumeration::Linux_SambaShareSecurityForGlobalInstanceEnumeration() {

   	

    m_firstElementP = 0;

    m_currentElementP = 0;

    m_endElementP = 0;

  

  }

  

  //----------------------------------------------------------------------------

  Linux_SambaShareSecurityForGlobalInstanceEnumeration::Linux_SambaShareSecurityForGlobalInstanceEnumeration(

    const Linux_SambaShareSecurityForGlobalInstanceEnumeration& anInstanceEnumeration) {

   	

    m_firstElementP = 0;

    m_currentElementP = 0;

    m_endElementP = 0;

  	 

    int size = anInstanceEnumeration.getSize();

    for (int x=0; x < size;++x) {

      addElement(anInstanceEnumeration.getElement(x));

    }           



  }

  

  //----------------------------------------------------------------------------

  Linux_SambaShareSecurityForGlobalInstanceEnumeration::~Linux_SambaShareSecurityForGlobalInstanceEnumeration() {

   	

  	if (m_firstElementP) {

  	  delete(m_firstElementP);

  	}

  	  	

  }

  

  //----------------------------------------------------------------------------

  void

  Linux_SambaShareSecurityForGlobalInstanceEnumeration::reset() {

  	

  	m_currentElementP = m_firstElementP;

  	

  }

  	  

  //----------------------------------------------------------------------------

  bool

  Linux_SambaShareSecurityForGlobalInstanceEnumeration::hasNext() const {

  	

  	return (m_currentElementP != 0);

  

  }

  

  //----------------------------------------------------------------------------

  int

  Linux_SambaShareSecurityForGlobalInstanceEnumeration::getSize() const {

  	

    int size = 0;

    Linux_SambaShareSecurityForGlobalInstanceEnumerationElement* followingP = m_firstElementP;

  	

  	while (followingP) {

      followingP = followingP->m_nextP;

      ++size;

    }

  	

    return size;

    

  }

  

  //----------------------------------------------------------------------------

  const Linux_SambaShareSecurityForGlobalInstance&  

  Linux_SambaShareSecurityForGlobalInstanceEnumeration::getElement(int anIndex) const {

   

    Linux_SambaShareSecurityForGlobalInstanceEnumerationElement* followingP = m_firstElementP;

   

    int x = 0;

    while (followingP && (x < anIndex)) {

      followingP = followingP->m_nextP;

      ++x;

    }

    

    return *(followingP->m_elementP);



  }

  

  //----------------------------------------------------------------------------

  const Linux_SambaShareSecurityForGlobalInstance&

  Linux_SambaShareSecurityForGlobalInstanceEnumeration::getNext() {

   	

    Linux_SambaShareSecurityForGlobalInstanceEnumerationElement* currentElementP =

  	  m_currentElementP;



    m_currentElementP = m_currentElementP->m_nextP;

  	 

    return *(currentElementP->m_elementP);



  }

  	  

  //----------------------------------------------------------------------------

  void

  Linux_SambaShareSecurityForGlobalInstanceEnumeration::addElement(

    const Linux_SambaShareSecurityForGlobalInstance& anInstance) {

   	

  	if (m_firstElementP == 0) {

  	  m_firstElementP = new Linux_SambaShareSecurityForGlobalInstanceEnumerationElement();

  	  m_firstElementP->m_elementP = new Linux_SambaShareSecurityForGlobalInstance(anInstance);

  	  m_endElementP = m_firstElementP;

  	  m_currentElementP = m_firstElementP;

  	} else {

  	  m_endElementP->m_nextP = new Linux_SambaShareSecurityForGlobalInstanceEnumerationElement();

  	  m_endElementP = m_endElementP->m_nextP;

  	  m_endElementP->m_elementP = new Linux_SambaShareSecurityForGlobalInstance(anInstance);

  	}



  }

  

}