ceStateCoreImpl.h

Go to the documentation of this file.

/* --- Source License
 * Author  : FX Programmer.
 * Contact : CorEngine@gmail.com
 *
 * Copyright (c) 2010 by FX Programmer.
 *
 * This source code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU Lesser General Public License as published by
 * the Free Software Foundation; either version 2.1 of the License, or
 * (at your option) any later version.
 *
 * This source code is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
 * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
 * License for more details.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *    1. The origin of this software must not be misrepresented; you must not
 *       claim that you wrote the original software. If you use this software
 *       in a product, an acknowledgement in the product documentation would be
 *       appreciated but is not required.
 *    2. Altered source versions must be clearly marked as such, and must not
 *       be misrepresented as being the original software.
 *    3. Redistributions of source code must retain the above copyright
 *       notice, this list of conditions and the following disclaimer.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with this source code; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301, USA.
 */

 #ifndef _CE_STATECORE_IMPL_H_
 #define _CE_STATECORE_IMPL_H_ 0x1 
 #ifndef __cplusplus
 #error ceStateCoreImpl.h requires C++ compilation (use a .cpp suffix)
 #endif

 #if __GNUC__ >= 0x3
 #pragma GCC system_header
 #endif

 #if _MSC_VER > 1000
 #pragma once
 #pragma warning(disable: 4100)
 #endif

 #include "ceStateCore.h"

 namespace ce {

// ---                                          class IStateManagerImpl --- */

 // #define CE_WITHOUT_GLOBAL_STATE 0x1
 // #define CE_FSM_VERIFY 0x1

 template <class T>
 class IStateManagerImpl
 {
  public:

    #ifndef DOXYGEN_SHOULD_SKIP_THIS
    IStateManagerImpl(void)
    {
      this -> pT = static_cast<T*>(this);

      this -> pT -> State = CreateStateManager();
      if (!this -> pT -> State) return;

    };

    virtual ~IStateManagerImpl(void)
    { DestroyStateManager(&this -> pT -> State); };
    #endif

    // #ifdef CE_FSM_VERIFY
    inline const short APICALL
      VerifyStateManager(void) const
    { return (!this -> pT -> State) ? 0x0 : 0x1; };
    // #endif

    #ifndef CE_WITHOUT_GLOBAL_STATE
    // --- Global State --- */
      inline void APICALL
      SetGlobalState(IState *State) const
    { this -> pT -> State -> SetGlobalState(State); };

    inline IState* APICALL
      GetGlobalState(void) const
    { return this -> pT -> State -> GetGlobalState(); };
    // -------------------- */
    #endif // CE_WITHOUT_GLOBAL_STATE

    // --- Current State --- */
      inline void APICALL
      SetCurrentState(IState *State) const
    { this -> pT -> State -> SetCurrentState(State); };

    inline IState* APICALL
      GetCurrentState(void) const
    { return this -> pT -> State -> GetCurrentState(); };
    // --------------------- */

    // --- Previous State --- */
      inline void APICALL
      SetPreviousState(IState *State) const
    { this -> pT -> State -> SetPreviousState(State); };

    inline IState* APICALL
      GetPreviousState(void) const
    { return this -> pT -> State -> GetPreviousState(); };
    // ---------------------- */

    inline void APICALL
      Update(void) const
    { this -> pT -> State -> Update(); };

      inline void APICALL
      ChangeState(IState *State) const
    { this -> pT -> State -> ChangeState(State); };

    inline void APICALL
      RevertToPreviousState(void) const
    { this -> pT -> State -> RevertToPreviousState(); };

    inline short APICALL
      IsInState(const IState &State) const
    { return this -> pT -> State -> IsInState(State); };

  protected:

    IStateManager *State; 

  private:

    T *pT;

    IStateManagerImpl(const IStateManagerImpl&);
    void operator=(const IStateManagerImpl&);

    // DISALLOW_COPY_AND_ASSIGN(IStateManagerImpl);
 };

// ---                                      end class IStateManagerImpl --- */

 } // end namespace ce

 #if _MSC_VER > 1000
 #pragma warning(default:4100)
 #endif

 #endif // _CE_STATECORE_IMPL_H_