base_classobject.cpp~

来自「270的linux说明」· CPP~ 代码 · 共 190 行

//==============================================================================
// base_ClassObject.cpp
//       Implementation of base class  InstanceCollection
//==============================================================================
#include "base_ClassObject.h"
#include "base_ClassObject_Impl.h"

using namespace Intel::Mobile::BaseAPI;

//==============================================================================
// C_Tor()
//==============================================================================
ClassObject::ClassObject( IntelMobileChar* type, const IntelMobileChar* version, void *pImpl )
           : EventClient( pImpl )
{
	if ( type )
    {
        m_Type = ::strcpy( new IntelMobileChar[::strlen(type)+1], type ); 
    }

	if ( version )
    {
        m_Version = ::strcpy( new IntelMobileChar[::strlen(version)+1], version ); 
    }

	m_pImpl = new ClassObjectImplPtr( new ClassObjectImpl( this, type, version ) );
}   
//==============================================================================
// D_Tor()
//==============================================================================
ClassObject::~ClassObject() 
{
    if ( m_pImpl ) // If we have a valid impl * delete the SMART POINTER object
    {
		if ( m_Type )
			delete[] m_Type;

		if ( m_Version )
			delete[] m_Version;

        ClassObjectImplPtr* pClassImpl = reinterpret_cast<ClassObjectImplPtr*>(m_pImpl);
        
        (*pClassImpl)->SetOwner( NULL ); // Remove this as owner of the impl.

        delete pClassImpl;
    }
} 
//==============================================================================
// GetType()
//==============================================================================
IntelMobileChar* ClassObject::GetType() const
{ 
    IntelMobileChar* pszType = NULL;

    if ( m_pImpl )
    {

        pszType = ::strcpy( new IntelMobileChar[::strlen(m_Type)+1], m_Type ); 
    }

    return pszType;

} // GetType()
//==============================================================================
// GetVersion()
//==============================================================================
IntelMobileChar* ClassObject::GetVersion() const
{ 
    IntelMobileChar* pszVersion = NULL;

    if ( m_pImpl )
    {
        pszVersion = ::strcpy( new IntelMobileChar[::strlen(m_Version)+1], m_Version ); 
    }

    return pszVersion;

} // GetVersion()

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

//==============================================================================
// AddObserver()  
//==============================================================================
bool ClassObject::AddObserver( Event::EventType eType, Observer& observer )
{
 	if ( IsEventAvailable( eType ) )
	{
	   if ( m_pImpl )
		{
			ClassObjectImplPtr		  spImpl = *reinterpret_cast<ClassObjectImplPtr*>(m_pImpl);
			return spImpl->AddObserver( eType, *reinterpret_cast<ObserverImpl*>(observer.GetImpl()) );
		}
	}
	else
	{
		IntelMobileException ex( IntelMobileText("ClassObject : NotSupportEvent Exception"), IntelMobileText("AddObserver"), IntelMobileText("AddObserver") );
		throw( ex ); 
	}
	
	return false;

} // AddObserver() 

//==============================================================================
// RemoveObserver() : Remove it from the observer first. This returns a pointer 
//                    That may, or may not, be 'this' it is however garaunteed 
//                    to be of the same type.
//==============================================================================
bool ClassObject::RemoveObserver( Event::EventType eType, Observer& observer )
{
   	if ( IsEventAvailable( eType ) )
	{
		if ( m_pImpl )
		{
			ClassObjectImplPtr		  spImpl = *reinterpret_cast<ClassObjectImplPtr*>(m_pImpl);
			return spImpl->RemoveObserver( eType, *reinterpret_cast<ObserverImpl*>(observer.GetImpl()) );
		}
	}
	else
	{
		IntelMobileException ex( IntelMobileText("ClassObject : NotSupportEvent Exception"), IntelMobileText("RemoveObserver"), IntelMobileText("RemoveObserver") );
		throw( ex ); 
	}

	return false;

} // RemoveObserver() 

//==============================================================================
// IsEventAvailable() : 
//==============================================================================
bool ClassObject::IsEventAvailable( Event::EventType eType ) 
{ 
   if ( m_pImpl )
	{
		ClassObjectImplPtr		  spImpl = *reinterpret_cast<ClassObjectImplPtr*>(m_pImpl);
		return spImpl->IsEventAvailable( eType );
	}

	return false;

} // IsEventAvailable()

//==============================================================================
// GetInstances() : Get the collection interface and return it in a wrapper.
//==============================================================================
InstanceCollection* ClassObject::GetInstances( const IntelMobileChar* sType )
{
    InstanceCollection        *pCollectionWrapper = NULL;

    if ( m_pImpl )
	{
		ClassObjectImplPtr		  spImpl = *reinterpret_cast<ClassObjectImplPtr*>(m_pImpl);
		InstanceCollectionImplPtr spCollection = spImpl->GetInstances( sType );

		if ( spCollection )
		{
			pCollectionWrapper = new InstanceCollection( new InstanceCollectionImplPtr( spCollection ) );
		}
	}

    return pCollectionWrapper;

} // GetInstances()

//==============================================================================
// GetInstance() : Get a specific instance interface 
//==============================================================================
InstanceObject* ClassObject::GetInstance( const IntelMobileChar* sKey ) 
{ 
    InstanceObject	      *pInstanceWrapper = NULL;

	if ( m_pImpl )
	{
		ClassObjectImplPtr		  spImpl = *reinterpret_cast<ClassObjectImplPtr*>(m_pImpl);
		InstanceObjectImplPtr spInstance = spImpl->GetInstance( sKey );
	  
		if ( spInstance )
		{
			pInstanceWrapper = new InstanceObject( new InstanceObjectImplPtr( spInstance ) );
		}
	}

    return pInstanceWrapper;

} // GetInstance() 

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