base_enum.h

270的linux说明

/*

Copyright (c) 2008, Intel Corporation. 

All rights reserved.

 

Redistribution and use in source and binary forms, with or without modification, 
are permitted provided that the following conditions are met:


    * Redistributions of source code must retain the above copyright notice, 
this list of conditions and the following disclaimer.

    * Redistributions in binary form must reproduce the above copyright notice, 
this list of conditions and the following disclaimer in the documentation and/or 
other materials provided with the distribution.

    * Neither the name of Intel Corporation nor the names of its contributors 
may be used to endorse or promote products derived from this software without 
specific prior written permission.

 

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND 
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 
IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, 
INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 
BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, 
OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 
WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY 
OF SUCH DAMAGE.

*/

//==============================================================================
// base_Enum.h : Definition of the class IntelMobileEnum
//==============================================================================
#ifndef BASE_ENUM_H
#define BASE_ENUM_H


#include "inc/framework/basetypes.h"
#include "inc/framework/win2linux.h"
#include "base_StringObject.h"
#include <string>
using namespace std;

#define DECLARE_ENUM( name )									\
			private:											\
				static void*	m_pHash;						\
				name();											\
				name( int value );								\
				name( IntelMobileChar *desc, int value );			

namespace Intel
{
	namespace Mobile
	{

		namespace Base
		{
			class  BaseEnum
			{
			private:
				int				m_nValue;
				IntelMobileString			m_strDesc;
				void*			m_pHash;

			protected:
				BaseEnum();
				BaseEnum( void* hash, int value );
				BaseEnum( void* hash, IntelMobileChar *desc, int value );

			public:
				bool operator == ( const BaseEnum& e );
				const StringObject ToString();
				int GetIntValue();
			};

			class  ProviderTypeEnum : public Intel::Mobile::Base::BaseEnum
			{
			public:
				static const ProviderTypeEnum	Battery;
				static const ProviderTypeEnum	Processor;
				static const ProviderTypeEnum	LinkProtocol;
				static const ProviderTypeEnum	Protocol802_11;
				static const ProviderTypeEnum	Protocol802_3;
				static const ProviderTypeEnum	ProtocolCdma;
				static const ProviderTypeEnum	ProtocolGprs;
				static const ProviderTypeEnum	ProtocolWwan;
				static const ProviderTypeEnum	NetworkAdapter;
				static const ProviderTypeEnum	RadioAdapter;
				static const ProviderTypeEnum	WiredAdapter;
				static const ProviderTypeEnum	Context;
				static const ProviderTypeEnum	Platform;
				static const ProviderTypeEnum	PhysicalDisk;
				static const ProviderTypeEnum	LogicalDisk;
				static const ProviderTypeEnum	Memory;
				static const ProviderTypeEnum	ProtocolBluetoothPan;
				static const ProviderTypeEnum	DisplayAdapter;

				DECLARE_ENUM( ProviderTypeEnum );
			};

		}

		namespace Battery
		{
			class ConditionEnumProperty;

			///////////////////////////////////////////////////////////////////////
			//   Enum defintion
			//
			class  ConditionEnum	: public Intel::Mobile::Base::BaseEnum
			{
				friend class Intel::Mobile::Battery::ConditionEnumProperty;
			public:
				static const ConditionEnum	Unknown;
				static const ConditionEnum	Charged;
				static const ConditionEnum	Charging;
				static const ConditionEnum	Discharged;
				static const ConditionEnum	Discharging;

				DECLARE_ENUM( ConditionEnum );
			};
		}

		namespace Context
		{
			class SourceEnumProperty;
			class StateEnumProperty;

			///////////////////////////////////////////////////////////////////////
			//   Enum defintion
			//
			class  StateEnum	: public Intel::Mobile::Base::BaseEnum
			{
				friend class Intel::Mobile::Context::StateEnumProperty;
			public:
				static const StateEnum	Unknown;
				static const StateEnum	Charged;
				static const StateEnum	Charging;
				static const StateEnum	Discharging;
				static const StateEnum	Discharged;

				DECLARE_ENUM( StateEnum );
			};

			class  SourceEnum	: public Intel::Mobile::Base::BaseEnum
			{
				friend class Intel::Mobile::Context::SourceEnumProperty;
			public:
				static const SourceEnum	Internal;
				static const SourceEnum	External;

				DECLARE_ENUM( SourceEnum );
			};
		}

		
		namespace Display
		{
			class OrientationEnumProperty;
			class ScreenStateEnumProperty;

			///////////////////////////////////////////////////////////////////////
			//   Enum defintion
			//
			class  OrientationEnum	: public Intel::Mobile::Base::BaseEnum
			{
				friend class Intel::Mobile::Display::OrientationEnumProperty;
			public:
				static const OrientationEnum	Landscape;
				static const OrientationEnum	Portrait;
				static const OrientationEnum	InvertedLandscape;
				static const OrientationEnum	InvertedPortrait;

				DECLARE_ENUM( OrientationEnum );
			};

			class  ScreenStateEnum	: public Intel::Mobile::Base::BaseEnum
			{
				friend class Intel::Mobile::Display::ScreenStateEnumProperty;
			public:
				static const ScreenStateEnum	Blanked;
				static const ScreenStateEnum	Unblanked;

				DECLARE_ENUM( ScreenStateEnum );
			};
		}
		namespace Platform
		{
			class FeatureEnumProperty;
			class FeatureEnumArrayProperty;
			class  FeatureEnum: public Intel::Mobile::Base::BaseEnum
			{
				friend class Intel::Mobile::Platform::FeatureEnumProperty;
				friend class Intel::Mobile::Platform::FeatureEnumArrayProperty;
			public:
				static const FeatureEnum	CentrinoTechnology;

				DECLARE_ENUM( FeatureEnum );
			};
		}


		namespace Network
		{
			struct ApStruct;
			class Protocol802_11Instance;

			class AdapterLinkEnumProperty;
			class ConnectionStateEnumProperty;
			class ProtocolStateEnumProperty;
			class OperatingModeEnumProperty;
			class WlanPowerModeEnumProperty;
			class CardTypeEnumProperty;
			class HardwareRadioStateEnumProperty;
			class SoftwareRadioStateEnumProperty;
			class WlanBandEnumProperty;
			class BandEnumProperty;
			class AuthenticationModeEnumProperty;
			class WlanEncryptionModeEnumProperty;
			class AssociationStateEnumProperty;
			class SecurityModeEnumProperty;
			class QosEnumProperty;
			class WwanEncryptionModeEnumProperty;
			class WwanPowerModeEnumProperty;
			class ChannelStateEnumProperty;
			class RoamingStateEnumProperty;
			class ServiceIndicationEnumProperty;
			class CallStateEnumProperty;
			class WwanBandEnumProperty;
			class CallCategoryEnumProperty;
			class LinkQualityEnumProperty;
			class GprsClassEnumProperty;
			class AnswerStateEnumProperty;
			class ProtocolRevisionEnumProperty;
			class ModulationTypeEnumProperty;
			class WlanBandEnumArrayProperty;
			class BandEnumArrayProperty;
			class ModulationTypeEnumArrayProperty;
			class SecurityModeEnumArrayProperty;
			class WwanEncryptionModeEnumArrayProperty;
			class WlanEncryptionModeEnumArrayProperty;
			class HciVersionEnumProperty;
			class LmpVersionEnumProperty;
			class MajorDeviceClassEnumProperty;
			class ServiceClassEnumArrayProperty;


			///////////////////////////////////////////////////////////////////////
			//   Enum defintion
			//
			class  AdapterLinkEnum: public Intel::Mobile::Base::BaseEnum
			{
				friend class Intel::Mobile::Network::AdapterLinkEnumProperty;
			public:
				static const AdapterLinkEnum	Unknown;
				static const AdapterLinkEnum	LinkProtocol802_3;
				static const AdapterLinkEnum	Gprs;
				static const AdapterLinkEnum	Cdma;
				static const AdapterLinkEnum	LinkProtocol802_11;
				static const AdapterLinkEnum	IrDa;
				static const AdapterLinkEnum	Ieee1394;
				static const AdapterLinkEnum	PhoneLine;
				static const AdapterLinkEnum	Bluetooth;
				static const AdapterLinkEnum	Uwb;

				DECLARE_ENUM( AdapterLinkEnum );
			};

			class  ConnectionStateEnum: public Intel::Mobile::Base::BaseEnum
			{
				friend class Intel::Mobile::Network::ConnectionStateEnumProperty;
			public:
				static const ConnectionStateEnum	Unknown;
				static const ConnectionStateEnum	Disconnected;
				static const ConnectionStateEnum	Connecting;
				static const ConnectionStateEnum	Connected;
				static const ConnectionStateEnum	Disconnecting;
				static const ConnectionStateEnum	HardwareNotPresent;
				static const ConnectionStateEnum	HardwareDisabled;
				static const ConnectionStateEnum	HardwareMalfunction;
				static const ConnectionStateEnum	Authenticating;
				static const ConnectionStateEnum	AuthenticationSucceeded;
				static const ConnectionStateEnum	AuthenticationFailed; 

				DECLARE_ENUM( ConnectionStateEnum );
			};

			class  ProtocolStateEnum: public Intel::Mobile::Base::BaseEnum
			{
				friend class Intel::Mobile::Network::ProtocolStateEnumProperty;
			public:
				static const ProtocolStateEnum	DeviceNotPresent;
				static const ProtocolStateEnum	DevicePresent;
				static const ProtocolStateEnum	MediaPresent;
				static const ProtocolStateEnum	NonZeroIpAddress;

				DECLARE_ENUM( ProtocolStateEnum );
			};

			class  OperatingModeEnum: public Intel::Mobile::Base::BaseEnum
			{
				friend class Intel::Mobile::Network::OperatingModeEnumProperty;
				friend class Intel::Mobile::Network::ApStruct;
				friend class Intel::Mobile::Network::Protocol802_11Instance;
			public:
				static const OperatingModeEnum	Unknown;
				static const OperatingModeEnum	Adhoc;
				static const OperatingModeEnum	Infrastructure;

				DECLARE_ENUM( OperatingModeEnum );
			};

			class  WlanPowerModeEnum: public Intel::Mobile::Base::BaseEnum
			{
				friend class Intel::Mobile::Network::WlanPowerModeEnumProperty;
			public:
				static const WlanPowerModeEnum	ContinuousAccess;
				static const WlanPowerModeEnum	FastPowerSaving;
				static const WlanPowerModeEnum	MaxPowerSaving;

				DECLARE_ENUM( WlanPowerModeEnum );
			};

			class  CardTypeEnum: public Intel::Mobile::Base::BaseEnum
			{
				friend class Intel::Mobile::Network::CardTypeEnumProperty;
			public:
				static const CardTypeEnum	Unknown;
				static const CardTypeEnum	Cardbus;
				static const CardTypeEnum	Pci;
				static const CardTypeEnum	MiniPci;
				static const CardTypeEnum	EmbeddedUsb;
				static const CardTypeEnum	DongleUsb;
				static const CardTypeEnum	CompactFlash;

				DECLARE_ENUM( CardTypeEnum );
			};

			class  HardwareRadioStateEnum: public Intel::Mobile::Base::BaseEnum
			{
				friend class Intel::Mobile::Network::HardwareRadioStateEnumProperty;
			public:
				static const HardwareRadioStateEnum	Unknown;
				static const HardwareRadioStateEnum	Enabled;
				static const HardwareRadioStateEnum	Disabled;

				DECLARE_ENUM( HardwareRadioStateEnum );
			};

			class  SoftwareRadioStateEnum: public Intel::Mobile::Base::BaseEnum
			{
				friend class Intel::Mobile::Network::SoftwareRadioStateEnumProperty;
			public:
				static const SoftwareRadioStateEnum	Unknown;
				static const SoftwareRadioStateEnum	Enabled;
				static const SoftwareRadioStateEnum	Disabled;

				DECLARE_ENUM( SoftwareRadioStateEnum );
			};

			class  WlanBandEnum: public Intel::Mobile::Base::BaseEnum
			{
				friend class Intel::Mobile::Network::WlanBandEnumProperty;
				friend class Intel::Mobile::Network::WlanBandEnumArrayProperty;
				friend class Intel::Mobile::Network::ApStruct;
				friend class Intel::Mobile::Network::Protocol802_11Instance;
			public:
				static const WlanBandEnum	Unknown;
				static const WlanBandEnum	Protocol802_11a;
				static const WlanBandEnum	Protocol802_11b;
				static const WlanBandEnum	Protocol802_11g;

				DECLARE_ENUM( WlanBandEnum );
			};
			class  BandEnum: public Intel::Mobile::Base::BaseEnum
			{
				friend class Intel::Mobile::Network::BandEnumProperty;
				friend class Intel::Mobile::Network::BandEnumArrayProperty;
			public:
				static const BandEnum Unknown;
				static const BandEnum Protocol802_11a;
				static const BandEnum Protocol802_11b;
				static const BandEnum Protocol802_11g;
				static const BandEnum None;
				static const BandEnum Pgsm;
				static const BandEnum Egsm;
				static const BandEnum Dcs;
				static const BandEnum PgsmDcs;
				static const BandEnum EgsmDcs;
				static const BandEnum Pcs;
				static const BandEnum PgsmPcs;
				static const BandEnum EgsmPcs;
				static const BandEnum Gsm850;
				static const BandEnum Gsm850Pcs;
				static const BandEnum Cellular;
				static const BandEnum Auto;
				static const BandEnum Bluetooth;

				DECLARE_ENUM( BandEnum );
			};


			class  AuthenticationModeEnum: public Intel::Mobile::Base::BaseEnum
			{
				friend class Intel::Mobile::Network::AuthenticationModeEnumProperty;
				friend class Intel::Mobile::Network::ApStruct;
				friend class Intel::Mobile::Network::Protocol802_11Instance;
			public:
				static const AuthenticationModeEnum	Unknown;
				static const AuthenticationModeEnum	Open;
				static const AuthenticationModeEnum	Shared;
				static const AuthenticationModeEnum	Wpa;
				static const AuthenticationModeEnum	Wpa_Psk;
				static const AuthenticationModeEnum	Rsn;
				static const AuthenticationModeEnum	Rsn_Psk;
				static const AuthenticationModeEnum	Ccx;

				DECLARE_ENUM( AuthenticationModeEnum );
			};

			class  WlanEncryptionModeEnum: public Intel::Mobile::Base::BaseEnum
			{
				friend class Intel::Mobile::Network::WlanEncryptionModeEnumProperty;
				friend class Intel::Mobile::Network::WlanEncryptionModeEnumArrayProperty;
				friend class Intel::Mobile::Network::ApStruct;
				friend class Intel::Mobile::Network::Protocol802_11Instance;
			public:
				static const WlanEncryptionModeEnum	Unknown;
				static const WlanEncryptionModeEnum	NoWep;
				static const WlanEncryptionModeEnum	Wep40;
				static const WlanEncryptionModeEnum	Wep104;
				static const WlanEncryptionModeEnum	Ckip40;
				static const WlanEncryptionModeEnum	Ckip104;
				static const WlanEncryptionModeEnum	Tkip;
				static const WlanEncryptionModeEnum	Ccmp;
				static const WlanEncryptionModeEnum	Wrap;

				DECLARE_ENUM( WlanEncryptionModeEnum );
			};

			class  AssociationStateEnum: public Intel::Mobile::Base::BaseEnum
			{
				friend class Intel::Mobile::Network::AssociationStateEnumProperty;