AbyssLibSrc/AbyssLib/AbyssLib/SimulatedHeap.h

説明を見る。

/*************************************************
ファイル名：SimulatedHeap.h
作成者　　：あびす
役割　　　：擬似ヒープ
*************************************************/
#ifndef ABYSSLIB_SIMULATEDHEAP_H
#define ABYSSLIB_SIMULATEDHEAP_H

namespace nsAbyssLib{

namespace nsTextStream{
//依存クラス（参照先：TextStream.h）
class ITextStream;
}
namespace nsCommand{
//依存構造体（参照先：Command.h）
struct CmdParam;
//依存クラス（参照先：Command.h）
class ICmd_Base;
}
namespace nsCore{
//依存クラス（参照先：AbyssLib.h）
class INovelEngine;
}

namespace nsSimulatedHeap{

//擬似ヒープ（インターフェース）
class ISingleHeap{
public:
    //操作
    virtual int Get(const char* Text) const = 0;                            //取得
    virtual bool Find(const char* Text) const = 0;                          //検索
    virtual void Set(const char* Text, int Value) = 0;                      //追加/設定
    virtual void Print(const ITextStream* Output) const = 0;                //内容を表示
};

//擬似ヒープ
class SingleHeap : public ISingleHeap{
public:
    SingleHeap(){}                                                          //デフォルトコンストラクタ

    void Clear();                                                           //消去
    int Get(const char* Text) const;                                        //取得
    bool Find(const char* Text) const;                                      //検索
    void Set(const char* Text, int Value);                                  //追加/設定
    void Print(const ITextStream* Output) const;                            //内容を表示

    map<string, int>* GetObj();                                             //実体を取得(1)
    const map<string, int>* GetObj() const;                                 //実体を取得(2)

    void Save(IIOStream* IOStream);                                         //保存
    void Load(IIOStream* IOStream);                                         //読み込み
private:
    map<string, int> m_Heap;                                                //擬似ヒープ

    SingleHeap(const SingleHeap&);                                          //コピーコンストラクタ（禁止）
    SingleHeap& operator =(const SingleHeap&);                              //代入演算子（禁止）
};

//擬似ヒープ（命令）（インターフェース）
class ICommandHeap{
public:
    //操作（命令リスト）
    virtual void Print(const ITextStream* Output) const = 0;                //命令の内容を表示
    //操作（イテレータ）
    virtual int GetIterator() const = 0;                                    //イテレータを取得
    virtual void AddIterator(int it) = 0;                                   //イテレータを加算
    virtual void SetIterator(int it) = 0;                                   //イテレータを設定
    virtual void PopIterator() = 0;                                         //イテレータをポップ
    virtual void PushIterator(int it) = 0;                                  //イテレータをプッシュ
    virtual void PrintIterator(const ITextStream* Output) const = 0;        //イテレータの内容を表示
};

//擬似ヒープ（命令）
class CommandHeap : public ICommandHeap{
public:
    CommandHeap();                                                          //デフォルトコンストラクタ
    ~CommandHeap();                                                         //デストラクタ

    void Initialize();                                                      //初期化

    void SetParent(INovelEngine* Parent);                                   //親エンジンを設定

    void Run();                                                             //命令を実行
    void Clear();                                                           //命令リストを消去
    void Print(const ITextStream* Output) const;                            //命令の内容を表示
    void Add(ICmd_Base* NewCommand, const CmdParam& Parameter);             //命令を新規に追加

    vector<ICmd_Base*>* GetObj();                                           //実体を取得(1)
    const vector<ICmd_Base*>* GetObj() const;                               //実体を取得(2)

    void Save(IIOStream* IOStream);                                         //保存
    void Load(IIOStream* IOStream);                                         //読み込み

    int GetIterator() const;                                                //イテレータを取得
    void AddIterator(int it);                                               //イテレータを加算
    void SetIterator(int it);                                               //イテレータを設定
    void PopIterator();                                                     //イテレータをポップ
    void ClearIterator();                                                   //イテレータを全消去
    void PushIterator(int it);                                              //イテレータをプッシュ
    void PrintIterator(const ITextStream* Output) const;                    //イテレータの内容を表示

    void SaveIterator(IIOStream* IOStream);                                 //イテレータを保存する
    void LoadIterator(IIOStream* IOStream);                                 //イテレータを読み込む
private:
    INovelEngine* Outer;                                                    //親エンジンのアドレス
    vector<int> m_Iterator;                                                 //イテレータ（命令）
    vector<ICmd_Base*> m_Heap;                                              //擬似ヒープ（命令）

    CommandHeap(const CommandHeap&);                                        //コピーコンストラクタ（禁止）
    CommandHeap& operator =(const CommandHeap&);                            //代入演算子（禁止）
};

}
}

#endif