SIP Stack (1 of 3)

#pragma once

#ifndef AApplication_h
	#define AApplication_h
 
	//#pragma warning( disable : 4267 )

	#include <string>
	#include <sys/timeb.h>

	#include "FWOS.h"
	
	#include "AManagedObject.h"
	#include "CMessageProcessor.h"
	#include "CHHCoreErrorDefinition.h"
	#include "CLogConfiguration.h"

	namespace CoreFW
	{
		class AApplicationState ;	
		class CApplicationUninitializedState ;
		class CApplicationStoppedState ;
		class CApplicationStartingState ;
		class CApplicationOpeningState ;
		class CApplicationOpenedState ;
		class CApplicationRunningState ;
		class CApplicationClosingState ;
		class CApplicationStoppingState ;

		class CORE_DLL_DECLARATION_SPECIFIER AApplication : public AManagedObject
		{
			friend class CApplicationUninitializedState ;
			friend class CApplicationStoppedState ;
			friend class CApplicationStartingState ;
			friend class CApplicationOpeningState ;
			friend class CApplicationOpenedState ;
			friend class CApplicationRunningState ;
			friend class CApplicationClosingState ;
			friend class CApplicationStoppingState ;

		private:
			AApplication() ;
		protected:
			AApplication( const std::string &strResourceName ) ;

		public:
			virtual ~AApplication() ;

			virtual FW_RETURN_TYPE Start() ; // start event processing, logger, open managed-object
			virtual FW_RETURN_TYPE Stop() ;  // stop event processing, logger, close managed-object

		public:
			FW_RETURN_TYPE Initialize() ; // Initialize the application object
			FW_RETURN_TYPE Open() ;   // Open managed object
			FW_RETURN_TYPE Close() ;  // Close managed object

			FW_RETURN_TYPE HandleMessage( CMessage *pMessage ) ;
			
			bool IsRunning() ;
			bool IsStopped() ;
			bool IsClosing() ;

			const std::string& GetApplicationFilePath() const ;
			void SetApplicationFilePath( const std::string &strApplicationFilePath ) ;

			const _timeb& GetApplicationRunningTime() const ;
		
            const std::string& GetCurrentLogFolderPath() const ;
			void SetCurrentLogFolderPath( const std::string& strCurrentLogFolderPath ) ;

			CLogConfiguration* GetLogConfiguration() ;

			const std::string& GetApplicationTitle() const ;
			void SetApplicationTitle( const std::string &strApplicationTitle ) ;

		protected:
			virtual FW_RETURN_TYPE ApplicationStarted() = 0 ;
			virtual FW_RETURN_TYPE ApplicationStopping() = 0 ;
			virtual FW_RETURN_TYPE MakeApplicationRunning() ;

			//////////////////////////////////////////////////////////////////////////////
			// Administering Managed-Objects
			///////////////////////////////////////////////////////////////////////////////
			virtual FW_RETURN_TYPE CreateManagedObjects() ;
			virtual FW_RETURN_TYPE InitializeManagedObjects() ;
			virtual FW_RETURN_TYPE OpenManagedObjects() ;
			virtual FW_RETURN_TYPE CloseManagedObjects() ;

			//  Messaging 
			virtual FW_RETURN_TYPE OnMessageProcessorStarting( AObserverSubject *pObserverSubject ) ;
			virtual FW_RETURN_TYPE OnMessageProcessorStarted( AObserverSubject *pObserverSubject ) ;
			virtual FW_RETURN_TYPE OnMessageProcessorStopping( AObserverSubject *pObserverSubject ) ;
			virtual FW_RETURN_TYPE OnMessageProcessorStopped( AObserverSubject *pObserverSubject ) ;
			
		protected:
			FW_RETURN_TYPE OnOpened() ;
			FW_RETURN_TYPE OnClose() ;
			
			void InitializeApplicationStates( const std::string &strResourceName ) ;

			// Switching to require State
			FW_RETURN_TYPE SetStateToStopped() ;
			FW_RETURN_TYPE SetStateToStarting() ;
			FW_RETURN_TYPE SetStateToOpening() ;
			FW_RETURN_TYPE SetStateToOpened() ;
			FW_RETURN_TYPE SetStateToRunning() ;
			FW_RETURN_TYPE SetStateToClosing() ;
			FW_RETURN_TYPE SetStateToStopping() ;
			AApplicationState* GetState() ;

			FW_RETURN_TYPE SetState( AApplicationState *pApplicationState ) ;  

			void ReleaseManagedObjects( bool bDeallocateManagedObject = false ) ;
			bool AreManagedObjectsOpen() ;
			bool AreManagedObjectsClosed() ;
			int GetManagedObjectsCount() ;
			FW_RETURN_TYPE AddManagedObject( AManagedObject *pManagedObject ) ;


			void ReleaseMessageProcessorList() ;
			FW_RETURN_TYPE AddMessageProcessor( CMessageProcessor *pMessageProcessor ) ;
			bool AreMessageProcessorsStopped() ;

		private:
			FW_RETURN_TYPE PrimInitialize() ;
			FW_RETURN_TYPE PrimStart() ;
			FW_RETURN_TYPE PrimOpen() ;
			FW_RETURN_TYPE PrimClose() ;
			FW_RETURN_TYPE PrimStop() ;

			FW_RETURN_TYPE PrimOnMessageProcessorStarted( AObserverSubject *pObserverSubject ) ;
			FW_RETURN_TYPE PrimOnMessageProcessorStopped( AObserverSubject *pObserverSubject ) ;
			FW_RETURN_TYPE PrimOnManagedObjectOpened( AObserverSubject *pObserverSubject ) ;
			FW_RETURN_TYPE PrimOnManagedObjectClosed( AObserverSubject *pObserverSubject ) ;
			FW_RETURN_TYPE PrimOnApplicationStarted( AObserverSubject *pObserverSubject ) ;

		protected:
			TAManagedObjectList m_ManagedObjectList ;
			TCMessageProcessorList m_MessageProcessorList ;
		
			// Application states
			AApplicationState *m_pState ;
			AApplicationState *m_pUninitializedState ;
			AApplicationState *m_pStoppedState ;
			AApplicationState *m_pStartingState ;
			AApplicationState *m_pOpeningState ;
			AApplicationState *m_pOpenedState ;
			AApplicationState *m_pRunningState ;
			AApplicationState *m_pClosingState ;
			AApplicationState *m_pStoppingState ;

			std::string m_strApplicationFilePath ;

			_timeb m_tApplicationRunningTime ;
			std::string m_strApplicationTitle ;
			CLogConfiguration m_LogConfiguration ;
			std::string m_strCurrentLogFolderPath ;	
		}; 

		inline CLogConfiguration* AApplication::GetLogConfiguration()
		{
			return &m_LogConfiguration ;
		}

		inline const _timeb& AApplication::GetApplicationRunningTime() const
		{
			return m_tApplicationRunningTime ;
		}

		inline const std::string& AApplication::GetApplicationTitle() const
		{
			return m_strApplicationTitle ;
		}

		inline void AApplication::SetApplicationTitle( const std::string &strApplicationTitle )
		{
			m_strApplicationTitle = strApplicationTitle ;
		}

		inline const std::string& AApplication::GetCurrentLogFolderPath() const
		{
			return m_strCurrentLogFolderPath ;
		}

		inline void AApplication::SetCurrentLogFolderPath( const std::string& strCurrentLogFolderPath )
		{
			m_strCurrentLogFolderPath = strCurrentLogFolderPath ;
		}

		inline AApplicationState* AApplication::GetState()
		{
			return m_pState ;
		}

		inline const std::string& AApplication::GetApplicationFilePath() const
		{
			return m_strApplicationFilePath ;
		}

		inline void AApplication::SetApplicationFilePath( const std::string &strApplicationFilePath )
		{
			m_strApplicationFilePath = strApplicationFilePath ;
		}

		inline FW_RETURN_TYPE AApplication::SetState( AApplicationState *pApplicationState )
		{
			m_pState = pApplicationState ; 
	 	    return FW_ERR_SUCCESS ; 
		}

		inline int AApplication::GetManagedObjectsCount()
		{
			return m_ManagedObjectList.size() ; 
		}

		inline bool AApplication::IsClosing()
		{
			return ( m_pState == m_pClosingState ) ;
		}

		inline bool AApplication::IsRunning()
		{ 
			//return ( ( m_pState == m_pRunningState ) && AreManagedObjectsOpen() ) ; 
			return ( m_pState == m_pRunningState ) ;
		}

		inline bool AApplication::IsStopped() 
		{ 
			//return ( ( m_pState == m_pStoppedState ) && AreManagedObjectsClosed() ) ; 
			return ( m_pState == m_pStoppedState ) ;
		}

		inline FW_RETURN_TYPE AApplication::SetStateToStopped()
		{
			return SetState( m_pStoppedState ) ; 
		}

		inline FW_RETURN_TYPE AApplication::SetStateToStarting()
		{
			return SetState( m_pStartingState ) ; 
		}

		inline FW_RETURN_TYPE AApplication::SetStateToOpening()
		{ 
			return SetState( m_pOpeningState ) ; 
		}

		inline FW_RETURN_TYPE AApplication::SetStateToOpened()
		{
			return SetState( m_pOpenedState ) ; 
		}

		inline FW_RETURN_TYPE AApplication::SetStateToRunning()
		{ 
			return SetState( m_pRunningState ) ; 
		}

		inline FW_RETURN_TYPE AApplication::SetStateToClosing()
		{
			return SetState( m_pClosingState ) ;
		}

		inline FW_RETURN_TYPE AApplication::SetStateToStopping()
		{
			return SetState( m_pStoppingState ) ; 
		}
		
	} // End namespace

#endif