counterthreshold.cpp

270的linux说明

		{
			TRYBLOCK { return pAPI_Threshold->GetThreshold(); } CATCHBLOCK
		}
		else
			THROWNE(IntelMobileText("Intel::Mobile::Threshold::IntCounterThreshold"), IntelMobileText("GetThreshold"));
	}
	else
		THROWNE(IntelMobileText("Intel::Mobile::Threshold::IntCounterThreshold"), IntelMobileText("GetThreshold"));

} // GetThreshold()

//==============================================================================
// SetThreshold()
//==============================================================================
bool IntCounterThreshold::SetThreshold( __int32 threshold ) 
{ 
	if (m_pImpl)
	{
		Intel::Mobile::ThresholdAPI::IntCounterThreshold* pAPI_Threshold = reinterpret_cast<Intel::Mobile::ThresholdAPI::IntCounterThreshold*>(m_pImpl);
		if (pAPI_Threshold)
		{
			TRYBLOCK { return pAPI_Threshold->SetThreshold(threshold); } CATCHBLOCK
		}
		else
			THROWNE(IntelMobileText("Intel::Mobile::Threshold::IntCounterThreshold"), IntelMobileText("SetThreshold"));
	}
	else
		THROWNE(IntelMobileText("Intel::Mobile::Threshold::IntCounterThreshold"), IntelMobileText("SetThreshold"));

} // SetThreshold()

//==============================================================================
// GetOffset()
//==============================================================================
__int32 IntCounterThreshold::GetOffset() const
{ 
	if (m_pImpl)
	{
		Intel::Mobile::ThresholdAPI::IntCounterThreshold* pAPI_Threshold = reinterpret_cast<Intel::Mobile::ThresholdAPI::IntCounterThreshold*>(m_pImpl);
		if (pAPI_Threshold)
		{
			TRYBLOCK { return pAPI_Threshold->GetOffset(); } CATCHBLOCK
		}
		else
			THROWNE(IntelMobileText("Intel::Mobile::Threshold::IntCounterThreshold"), IntelMobileText("GetOffset"));
	}
	else
		THROWNE(IntelMobileText("Intel::Mobile::Threshold::IntCounterThreshold"), IntelMobileText("GetOffset"));

} // GetOffset()

//==============================================================================
// SetOffset()
//==============================================================================
bool IntCounterThreshold::SetOffset( __int32 offset ) 
{ 
	if (m_pImpl)
	{
		Intel::Mobile::ThresholdAPI::IntCounterThreshold* pAPI_Threshold = reinterpret_cast<Intel::Mobile::ThresholdAPI::IntCounterThreshold*>(m_pImpl);
		if (pAPI_Threshold)
		{
			TRYBLOCK { return pAPI_Threshold->SetOffset(offset); } CATCHBLOCK
		}
		else
			THROWNE(IntelMobileText("Intel::Mobile::Threshold::IntCounterThreshold"), IntelMobileText("SetOffset"));
	}
	else
		THROWNE(IntelMobileText("Intel::Mobile::Threshold::IntCounterThreshold"), IntelMobileText("SetOffset"));

} // SetOffset()

//++++++++++++++++++++++++++++++++++++++++++++++++++++
//  
//  Class UIntCounterThreshold
//
//++++++++++++++++++++++++++++++++++++++++++++++++++++

//==============================================================================
// C-Tor() : Constructor
//==============================================================================
UIntCounterThreshold::UIntCounterThreshold()
{
	try {
		m_pImpl = new Intel::Mobile::ThresholdAPI::UIntCounterThreshold();
	}
	catch(...)
	{
		if (m_pImpl)
		{
			delete m_pImpl;
			m_pImpl = NULL;
		}
	}
}

UIntCounterThreshold::UIntCounterThreshold(void *pImpl)
: CounterThreshold(pImpl)
{
}
//==============================================================================
// D-Tor() : 
//==============================================================================
UIntCounterThreshold::~UIntCounterThreshold()
{
	if (m_flag)
	{
		if (m_pImpl)
		{

			Intel::Mobile::ThresholdAPI::UIntCounterThreshold *p = reinterpret_cast<Intel::Mobile::ThresholdAPI::UIntCounterThreshold*>(m_pImpl);
			if (p)
				delete p;

			m_pImpl = NULL;
		}
	}
}

//==============================================================================
// SetObservedProperty() : 
//==============================================================================
bool UIntCounterThreshold::SetObservedProperty( const Intel::Mobile::Base::UIntProperty& observedProperty )
{
	if (m_pImpl)
	{
		Intel::Mobile::BaseAPI::UIntProperty* pAPI_Property = reinterpret_cast<Intel::Mobile::BaseAPI::UIntProperty*>(observedProperty.GetImpl());
		if (pAPI_Property)
		{
			Intel::Mobile::ThresholdAPI::UIntCounterThreshold* pThreshold = reinterpret_cast<Intel::Mobile::ThresholdAPI::UIntCounterThreshold*>(m_pImpl);
			if (pThreshold)
			{
				TRYBLOCK { return pThreshold->SetObservedProperty(*pAPI_Property); } CATCHBLOCK
			}
			else
				THROWNE(IntelMobileText("Intel::Mobile::Threshold::UIntCounterThreshold"), IntelMobileText("SetObservedProperty"));
		}
		else
			THROWNE(IntelMobileText("Intel::Mobile::Threshold::UIntCounterThreshold"), IntelMobileText("SetObservedProperty"));
	}
	else
		THROWNE(IntelMobileText("Intel::Mobile::Threshold::UIntCounterThreshold"), IntelMobileText("SetObservedProperty"));

} // SetObservedProperty()

//==============================================================================
// GetThreshold()
//==============================================================================
unsigned __int32 UIntCounterThreshold::GetThreshold() const
{ 
	if (m_pImpl)
	{
		Intel::Mobile::ThresholdAPI::UIntCounterThreshold* pAPI_Threshold = reinterpret_cast<Intel::Mobile::ThresholdAPI::UIntCounterThreshold*>(m_pImpl);
		if (pAPI_Threshold)
		{
			TRYBLOCK { return pAPI_Threshold->GetThreshold(); } CATCHBLOCK
		}
		else
			THROWNE(IntelMobileText("Intel::Mobile::Threshold::UIntCounterThreshold"), IntelMobileText("GetThreshold"));
	}
	else
		THROWNE(IntelMobileText("Intel::Mobile::Threshold::UIntCounterThreshold"), IntelMobileText("GetThreshold"));

} // GetThreshold()

//==============================================================================
// SetThreshold()
//==============================================================================
bool UIntCounterThreshold::SetThreshold( unsigned __int32 threshold ) 
{ 
	if (m_pImpl)
	{
		Intel::Mobile::ThresholdAPI::UIntCounterThreshold* pAPI_Threshold = reinterpret_cast<Intel::Mobile::ThresholdAPI::UIntCounterThreshold*>(m_pImpl);
		if (pAPI_Threshold)
		{
			TRYBLOCK { return pAPI_Threshold->SetThreshold(threshold); } CATCHBLOCK
		}
		else
			THROWNE(IntelMobileText("Intel::Mobile::Threshold::UIntCounterThreshold"), IntelMobileText("SetThreshold"));
	}
	else
		THROWNE(IntelMobileText("Intel::Mobile::Threshold::UIntCounterThreshold"), IntelMobileText("SetThreshold"));

} // SetThreshold()

//==============================================================================
// GetOffset()
//==============================================================================
unsigned __int32 UIntCounterThreshold::GetOffset() const
{ 
	if (m_pImpl)
	{
		Intel::Mobile::ThresholdAPI::UIntCounterThreshold* pAPI_Threshold = reinterpret_cast<Intel::Mobile::ThresholdAPI::UIntCounterThreshold*>(m_pImpl);
		if (pAPI_Threshold)
		{
			TRYBLOCK { return pAPI_Threshold->GetOffset(); } CATCHBLOCK
		}
		else
			THROWNE(IntelMobileText("Intel::Mobile::Threshold::UIntCounterThreshold"), IntelMobileText("GetOffset"));
	}
	else
		THROWNE(IntelMobileText("Intel::Mobile::Threshold::UIntCounterThreshold"), IntelMobileText("GetOffset"));

} // GetOffset()

//==============================================================================
// SetOffset()
//==============================================================================
bool UIntCounterThreshold::SetOffset( unsigned __int32 offset ) 
{ 
	if (m_pImpl)
	{
		Intel::Mobile::ThresholdAPI::UIntCounterThreshold* pAPI_Threshold = reinterpret_cast<Intel::Mobile::ThresholdAPI::UIntCounterThreshold*>(m_pImpl);
		if (pAPI_Threshold)
		{
			TRYBLOCK { return pAPI_Threshold->SetOffset(offset); } CATCHBLOCK
		}
		else
			THROWNE(IntelMobileText("Intel::Mobile::Threshold::UIntCounterThreshold"), IntelMobileText("SetOffset"));
	}
	else
		THROWNE(IntelMobileText("Intel::Mobile::Threshold::UIntCounterThreshold"), IntelMobileText("SetOffset"));

} // SetOffset()

//++++++++++++++++++++++++++++++++++++++++++++++++++++
//  
//  Class Int64CounterThreshold
//
//++++++++++++++++++++++++++++++++++++++++++++++++++++

//==============================================================================
// C-Tor() : Constructor
//==============================================================================
Int64CounterThreshold::Int64CounterThreshold()
{                                        
	try {
		m_pImpl = new Intel::Mobile::ThresholdAPI::Int64CounterThreshold();
	}
	catch(...)
	{
		if (m_pImpl)
		{
			delete m_pImpl;
			m_pImpl = NULL;
		}
	}
}

Int64CounterThreshold::Int64CounterThreshold(void *pImpl)
: CounterThreshold(pImpl)
{
}
//==============================================================================
// D-Tor() : 
//==============================================================================
Int64CounterThreshold::~Int64CounterThreshold()
{
	if (m_flag)
	{
		if (m_pImpl)
		{

			Intel::Mobile::ThresholdAPI::Int64CounterThreshold *p = reinterpret_cast<Intel::Mobile::ThresholdAPI::Int64CounterThreshold*>(m_pImpl);
			if (p)
				delete p;

			m_pImpl = NULL;
		}
	}
}

//==============================================================================
// SetObservedProperty() : 
//==============================================================================
bool Int64CounterThreshold::SetObservedProperty( const Intel::Mobile::Base::Int64Property& observedProperty )
{
	if (m_pImpl)
	{
		Intel::Mobile::BaseAPI::Int64Property* pAPI_Property = reinterpret_cast<Intel::Mobile::BaseAPI::Int64Property*>(observedProperty.GetImpl());
		if (pAPI_Property)
		{
			Intel::Mobile::ThresholdAPI::Int64CounterThreshold* pThreshold = reinterpret_cast<Intel::Mobile::ThresholdAPI::Int64CounterThreshold*>(m_pImpl);
			if (pThreshold)
			{
				TRYBLOCK { return pThreshold->SetObservedProperty(*pAPI_Property); } CATCHBLOCK
			}
			else
				THROWNE(IntelMobileText("Intel::Mobile::Threshold::Int64CounterThreshold"), IntelMobileText("SetObservedProperty"));
		}
		else
			THROWNE(IntelMobileText("Intel::Mobile::Threshold::Int64CounterThreshold"), IntelMobileText("SetObservedProperty"));
	}
	else
		THROWNE(IntelMobileText("Intel::Mobile::Threshold::Int64CounterThreshold"), IntelMobileText("SetObservedProperty"));

} // SetObservedProperty()

//==============================================================================
// GetThreshold()
//==============================================================================
__int64 Int64CounterThreshold::GetThreshold() const
{ 
	if (m_pImpl)
	{
		Intel::Mobile::ThresholdAPI::Int64CounterThreshold* pAPI_Threshold = reinterpret_cast<Intel::Mobile::ThresholdAPI::Int64CounterThreshold*>(m_pImpl);
		if (pAPI_Threshold)
		{
			TRYBLOCK { return pAPI_Threshold->GetThreshold(); } CATCHBLOCK
		}
		else
			THROWNE(IntelMobileText("Intel::Mobile::Threshold::Int64CounterThreshold"), IntelMobileText("GetThreshold"));
	}
	else
		THROWNE(IntelMobileText("Intel::Mobile::Threshold::Int64CounterThreshold"), IntelMobileText("GetThreshold"));

} // GetThreshold()

//==============================================================================
// SetThreshold()
//==============================================================================
bool Int64CounterThreshold::SetThreshold( __int64 threshold ) 
{ 
	if (m_pImpl)
	{
		Intel::Mobile::ThresholdAPI::Int64CounterThreshold* pAPI_Threshold = reinterpret_cast<Intel::Mobile::ThresholdAPI::Int64CounterThreshold*>(m_pImpl);
		if (pAPI_Threshold)
		{
			TRYBLOCK { return pAPI_Threshold->SetThreshold(threshold); } CATCHBLOCK
		}
		else
			THROWNE(IntelMobileText("Intel::Mobile::Threshold::Int64CounterThreshold"), IntelMobileText("SetThreshold"));
	}
	else
		THROWNE(IntelMobileText("Intel::Mobile::Threshold::Int64CounterThreshold"), IntelMobileText("SetThreshold"));

} // SetThreshold()

//==============================================================================
// GetOffset()
//==============================================================================
__int64 Int64CounterThreshold::GetOffset() const
{ 
	if (m_pImpl)
	{