AbyssLib 1.310
あびす謹製ノベルゲームフレームワークライブラリ

AbyssLibSrc/AbyssLib/AbyssLib/CMisc.h

説明を見る。
00001 /*************************************************
00002 ファイル名:CMisc.h
00003 作成者  :あびす
00004 役割   :汎用クラス
00005 *************************************************/
00010 #ifndef ABYSSLIB_CMISC_H
00011 #define ABYSSLIB_CMISC_H
00012 
00013 namespace nsAbyssLib{
00014 namespace nsCMisc{
00015 
00016 /*****************************
00017             列挙型
00018 *****************************/
00019 //シンボルの種類
00023 enum TYPE_SYMBOL{
00027     SY_NONE,                                                            //未使用
00032     SY_LOCAL,                                                           //内部変数
00037     SY_GLOBAL,                                                          //外部変数
00041     SY_BUTTON,                                                          //ボタン
00045     SY_SPRITE,                                                          //スプライト
00046 };
00047 
00048 //トークンの種類
00052 enum TYPE_TOKEN{
00056     TK_CONST,                                                           //定数
00060     TK_LABEL,                                                           //ラベル
00064     TK_STRING,                                                          //文字列
00068     TK_OPERATOR,                                                        //演算子
00072     TK_IDENTIFER,                                                       //識別子
00076     TK_PARAMETER,                                                       //多項式
00080     TK_SEPARATOR,                                                       //区切り文字
00081 };
00082 
00083 //演算子の種類
00087 enum TYPE_OPERATOR{
00091     OP_PLUS1,                                                           //  +(単項)
00095     OP_PLUS2,                                                           //  +(二項)
00099     OP_MINUS1,                                                          //  -(単項)
00103     OP_MINUS2,                                                          //  -(二項)
00107     OP_DIVIDE,                                                          //  /
00111     OP_MULTIPLY,                                                        //  *
00115     OP_REMAINDER,                                                       //  %
00116 
00120     OP_LOGIC_OR,                                                        //  |
00124     OP_LOGIC_AND,                                                       //  &
00128     OP_LOGIC_XOR,                                                       //  ^
00132     OP_LOGIC_NOT1,                                                      //  ~
00136     OP_LOGIC_NOT2,                                                      //  !
00137 
00141     OP_PARENT_LEFT,                                                     //  (
00145     OP_PARENT_RIGHT,                                                    //  )
00146 
00150     OP_COMP_OR,                                                         //  ||
00154     OP_COMP_AND,                                                        //  &&
00158     OP_COMP_EQUAL,                                                      //  ==
00162     OP_COMP_BIGGER,                                                     //  >
00166     OP_COMP_SMALLER,                                                    //  <
00170     OP_COMP_EQUAL_NOT,                                                  //  !=
00174     OP_COMP_EQUAL_BIGGER,                                               //  >=
00178     OP_COMP_EQUAL_SMALLER,                                              //  <=
00179 
00183     OP_EQUAL,                                                           //  =
00187     OP_EQUAL_PLUS,                                                      //  +=
00191     OP_EQUAL_MINUS,                                                     //  -=
00195     OP_EQUAL_DIVIDE,                                                    //  /=
00199     OP_EQUAL_MULTIPLY,                                                  //  *=
00203     OP_EQUAL_REMAINDER,                                                 //  %=
00207     OP_EQUAL_OR,                                                        //  |=
00211     OP_EQUAL_AND,                                                       //  &=
00215     OP_EQUAL_XOR,                                                       //  ^=
00216 };
00217 
00218 //区切り文字の種類
00222 enum TYPE_SEPARATOR{
00226     SP_COMMA,                                                           //  ,
00230     SP_SEMICOLON,                                                       //  ;
00234     SP_BLOCK_LEFT,                                                      //  {
00238     SP_BLOCK_RIGHT,                                                     //  }
00239 };
00240 
00241 /*****************************
00242         構造体&クラス
00243 *****************************/
00244 //文字列
00251 class mystr{
00252 public:
00256     mystr();                                                            //デフォルトコンストラクタ
00262     mystr(const char* Src);                                             //コピーコンストラクタ(1)
00267     mystr(const mystr& Src);                                            //コピーコンストラクタ(2)
00271     ~mystr();                                                           //デストラクタ
00272 
00278     void assign(const char* Src);                                       //割り当て(1)
00283     void assign(const mystr& Src);                                      //割り当て(2)
00284 
00289     const char* c_str() const;                                          //アクセス
00290 
00295     unsigned int size() const;                                          //サイズを取得
00296 
00303     mystr& operator =(const char* RHS);                                 //代入演算子(1)
00309     mystr& operator =(const mystr& RHS);                                //代入演算子(2)
00316     bool operator ==(const char* RHS) const;                            //比較演算子(1)
00322     bool operator ==(const mystr& RHS) const;                           //比較演算子(2)
00329     bool operator !=(const char* RHS) const;                            //比較演算子(3)
00335     bool operator !=(const mystr& RHS) const;                           //比較演算子(4)
00336 private:
00337     char* m_Data;                                                       //文字列へのポインタ
00338     unsigned int m_Capacity;                                            //文字列のキャパシティ
00339 };
00340 
00341 //動的配列(文字列)
00348 class vector_mystr{
00349 public:
00353     vector_mystr();                                                     //デフォルトコンストラクタ
00358     vector_mystr(const vector_mystr& Src);                              //コピーコンストラクタ
00362     ~vector_mystr();                                                    //デストラクタ
00363 
00367     void clear();                                                       //消去
00368 
00373     void push_back(const mystr& Src);                                   //追加
00379     void pop_back();                                                    //削除
00380 
00387     mystr& at(unsigned int Num);                                        //参照(1-1)
00394     const mystr& at(unsigned int Num) const;                            //参照(1-2)
00401     mystr& back();                                                      //参照(2-1)
00408     const mystr& back() const;                                          //参照(2-2)
00409 
00414     bool empty() const;                                                 //空か?
00419     unsigned int size() const;                                          //サイズを取得
00420 
00426     vector_mystr& operator =(const vector_mystr& RHS);                  //代入演算子
00427 private:
00428     mystr** m_P;                                                        //配列
00429     unsigned int m_Size;                                                //サイズ
00430     unsigned int m_Capacity;                                            //キャパシティ
00431 };
00432 
00433 //前方宣言
00434 struct Token;
00435 
00436 //多項式
00443 class Expression{
00444 public:
00448     Expression();                                                       //デフォルトコンストラクタ
00453     Expression(const Expression& Src);                                  //コピーコンストラクタ
00457     ~Expression();                                                      //デストラクタ
00458 
00462     void clear();                                                       //消去
00463 
00468     void push_back(const Token& Src);                                   //追加
00474     void pop_back();                                                    //削除
00475 
00482     Token& at(unsigned int Num);                                        //参照(1-1)
00489     const Token& at(unsigned int Num) const;                            //参照(1-2)
00496     Token& back();                                                      //参照(2-1)
00503     const Token& back() const;                                          //参照(2-2)
00504 
00509     bool empty() const;                                                 //空か?
00514     unsigned int size() const;                                          //サイズを取得
00515 
00521     Expression& operator =(const Expression& RHS);                      //代入演算子
00522 private:
00523     Token** m_P;                                                        //配列
00524     unsigned int m_Size;                                                //サイズ
00525     unsigned int m_Capacity;                                            //キャパシティ
00526 };
00527 
00528 //トークン
00540 struct Token{
00544     int Type;                                                           //タイプ
00548     int SubType;                                                        //サブタイプ
00552     int Line;                                                           //行番号
00556     int Value;                                                          //定数コンテナ
00560     mystr Text;                                                         //文字列コンテナ
00564     Expression Param;                                                   //多項式コンテナ
00565 
00569     Token(){                                                            //デフォルトコンストラクタ
00570         Clear();
00571     }
00575     void Clear(){                                                       //各要素をクリア
00576         Type = -1;
00577         SubType = -1;
00578         Line = -1;
00579         Value = 0;
00580         Text = "";
00581         Param.clear();
00582     }
00583 };
00584 
00585 //ルビテキスト(字単位)
00595 struct RubyTextToken{
00599     mystr Text;                                                         //テキスト
00603     unsigned int Size;                                                  //サイズ
00607     COLORREF Color;                                                     //カラー
00611     mystr Font;                                                         //フォント
00615     BYTE a;                                                             //透過度
00621     bool IsBold;                                                        //太字か?
00627     bool IsItalic;                                                      //斜体か?
00631     unsigned int Width;                                                 //横幅
00635     unsigned int Height;                                                //縦幅
00641     float Degree;                                                       //回転角度
00642 
00646     RubyTextToken(){                                                    //デフォルトコンストラクタ
00647         Clear();
00648     }
00652     void Clear(){                                                       //各要素をクリア
00653         Text = "";
00654         Size = 0;
00655         Color = 0;
00656         Font = "";
00657         a = 0;
00658         IsBold = false;
00659         IsItalic = false;
00660         Width = 0;
00661         Height = 0;
00662         Degree = 0.0f;
00663     }
00669     bool operator ==(const RubyTextToken& RHS) const{                   //比較演算子(1)
00670         return(Text==RHS.Text && Size==RHS.Size && Color==RHS.Color && Font==RHS.Font && a==RHS.a && 
00671                IsBold==RHS.IsBold && IsItalic==RHS.IsItalic && Width==RHS.Width && Height==RHS.Height && Degree==RHS.Degree);
00672     }
00678     bool operator !=(const RubyTextToken& RHS) const{                   //比較演算子(2)
00679         return(Text!=RHS.Text || Size!=RHS.Size || Color!=RHS.Color || Font!=RHS.Font || a!=RHS.a || 
00680                IsBold!=RHS.IsBold || IsItalic!=RHS.IsItalic || Width!=RHS.Width || Height!=RHS.Height || Degree!=RHS.Degree);
00681     }
00682 };
00683 
00684 //ルビテキスト(行単位)
00695 class RubyTextTokenLine{
00696 public:
00700     RubyTextTokenLine();                                                //デフォルトコンストラクタ
00705     RubyTextTokenLine(const RubyTextTokenLine& Src);                    //コピーコンストラクタ
00709     ~RubyTextTokenLine();                                               //デストラクタ
00710 
00714     void clear();                                                       //消去
00715 
00720     bool push_back(const RubyTextToken& Src);                           //追加(字)
00726     void pop_back();                                                    //削除(字)
00727 
00734     RubyTextToken& at(unsigned int Num);                                //参照(1-1)
00741     const RubyTextToken& at(unsigned int Num) const;                    //参照(1-2)
00748     RubyTextToken& back();                                              //参照(2-1)
00755     const RubyTextToken& back() const;                                  //参照(2-2)
00756 
00761     unsigned int GetWidth() const;                                      //横幅を取得
00766     unsigned int GetHeight() const;                                     //縦幅を取得
00767 
00772     bool empty() const;                                                 //空か?
00777     unsigned int size() const;                                          //サイズを取得
00778 
00784     RubyTextTokenLine& operator =(const RubyTextTokenLine& RHS);        //代入演算子
00790     bool operator ==(const RubyTextTokenLine& RHS) const;               //比較演算子(1)
00796     bool operator !=(const RubyTextTokenLine& RHS) const;               //比較演算子(2)
00797 private:
00798     RubyTextToken** m_P;                                                //配列
00799     unsigned int m_Size;                                                //サイズ
00800     unsigned int m_Capacity;                                            //キャパシティ
00801 };
00802 
00803 //テキスト(字単位)
00813 struct TextToken{
00817     mystr Text;                                                         //テキスト
00821     unsigned int Size;                                                  //サイズ
00825     COLORREF Color;                                                     //カラー
00829     mystr Font;                                                         //フォント
00833     BYTE a;                                                             //透過度
00839     bool IsBold;                                                        //太字か?
00845     bool IsItalic;                                                      //斜体か?
00849     unsigned int Width;                                                 //横幅
00853     unsigned int Height;                                                //縦幅
00857     RubyTextTokenLine Ruby;                                             //ルビ
00863     float Degree;                                                       //回転角度
00864 
00868     TextToken(){                                                        //デフォルトコンストラクタ
00869         Clear();
00870     }
00874     void Clear(){                                                       //各要素をクリア
00875         Text = "";
00876         Size = 0;
00877         Color = 0;
00878         Font = "";
00879         a = 0;
00880         IsBold = false;
00881         IsItalic = false;
00882         Width = 0;
00883         Height = 0;
00884         Ruby.clear();
00885         Degree = 0.0f;
00886     }
00892     bool operator ==(const TextToken& RHS) const{                       //比較演算子(1)
00893         return(Text==RHS.Text && Size==RHS.Size && Color==RHS.Color && Font==RHS.Font && a==RHS.a && 
00894                IsBold==RHS.IsBold && IsItalic==RHS.IsItalic && Width==RHS.Width && Height==RHS.Height && Ruby==RHS.Ruby && Degree==RHS.Degree);
00895     }
00901     bool operator !=(const TextToken& RHS) const{                       //比較演算子(2)
00902         return(Text!=RHS.Text || Size!=RHS.Size || Color!=RHS.Color || Font!=RHS.Font || a!=RHS.a || 
00903                IsBold!=RHS.IsBold || IsItalic!=RHS.IsItalic || Width!=RHS.Width || Height!=RHS.Height || Ruby!=RHS.Ruby || Degree!=RHS.Degree);
00904     }
00905 };
00906 
00907 //テキスト(行単位)
00918 class TextTokenLine{
00919 public:
00923     TextTokenLine();                                                    //デフォルトコンストラクタ
00928     TextTokenLine(const TextTokenLine& Src);                            //コピーコンストラクタ
00932     ~TextTokenLine();                                                   //デストラクタ
00933 
00937     void clear();                                                       //消去
00938 
00946     bool push_back(const TextToken& Src, unsigned int MaxWidth);        //追加(字)
00952     void pop_back();                                                    //削除(字)
00953 
00960     TextToken& at(unsigned int Num);                                    //参照(1-1)
00967     const TextToken& at(unsigned int Num) const;                        //参照(1-2)
00974     TextToken& back();                                                  //参照(2-1)
00981     const TextToken& back() const;                                      //参照(2-2)
00982 
00987     unsigned int GetWidth() const;                                      //横幅を取得
00992     unsigned int GetHeight() const;                                     //縦幅を取得
00993 
00998     bool empty() const;                                                 //空か?
01003     unsigned int size() const;                                          //サイズを取得
01004 
01010     TextTokenLine& operator =(const TextTokenLine& RHS);                //代入演算子
01016     bool operator ==(const TextTokenLine& RHS) const;                   //比較演算子(1)
01022     bool operator !=(const TextTokenLine& RHS) const;                   //比較演算子(2)
01023 private:
01024     TextToken** m_P;                                                    //配列
01025     unsigned int m_Size;                                                //サイズ
01026     unsigned int m_Capacity;                                            //キャパシティ
01027 };
01028 
01029 //テキスト(文単位)
01040 class TextTokenSection{
01041 public:
01045     TextTokenSection();                                                 //デフォルトコンストラクタ
01050     TextTokenSection(const TextTokenSection& Src);                      //コピーコンストラクタ
01054     ~TextTokenSection();                                                //デストラクタ
01055 
01059     void clear();                                                       //消去
01060 
01069     bool push_back(const TextTokenLine& Src, unsigned int MaxWidth, unsigned int MaxHeight);
01070                                                                         //追加(行)
01076     void pop_back();                                                    //削除(行)
01077 
01084     TextTokenLine& at(unsigned int Num);                                //参照(1-1)
01091     const TextTokenLine& at(unsigned int Num) const;                    //参照(1-2)
01098     TextTokenLine& back();                                              //参照(2-1)
01105     const TextTokenLine& back() const;                                  //参照(2-2)
01106 
01111     unsigned int GetWidth() const;                                      //横幅を取得
01116     unsigned int GetHeight() const;                                     //縦幅を取得
01117 
01122     bool empty() const;                                                 //空か?
01127     unsigned int size() const;                                          //サイズを取得
01128 
01134     TextTokenSection& operator =(const TextTokenSection& RHS);          //代入演算子
01140     bool operator ==(const TextTokenSection& RHS) const;                //比較演算子(1)
01146     bool operator !=(const TextTokenSection& RHS) const;                //比較演算子(2)
01147 private:
01148     TextTokenLine** m_P;                                                //配列
01149     unsigned int m_Size;                                                //サイズ
01150     unsigned int m_Capacity;                                            //キャパシティ
01151 };
01152 
01153 }
01154 }
01155 
01156 #endif
 全て クラス ネームスペース ファイル 関数 変数 型定義 列挙型 列挙型の値 フレンド マクロ定義