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

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;                                                //縦幅
00636 
00640     RubyTextToken(){                                                    //デフォルトコンストラクタ
00641         Clear();
00642     }
00646     void Clear(){                                                       //各要素をクリア
00647         Text = "";
00648         Size = 0;
00649         Color = 0;
00650         Font = "";
00651         a = 0;
00652         IsBold = false;
00653         IsItalic = false;
00654         Width = 0; Height = 0;
00655     }
00661     bool operator ==(const RubyTextToken& RHS) const{                   //比較演算子(1)
00662         return(Text==RHS.Text && Size==RHS.Size && Color==RHS.Color && Font==RHS.Font && a==RHS.a && 
00663                IsBold==RHS.IsBold && IsItalic==RHS.IsItalic && Width==RHS.Width && Height==RHS.Height);
00664     }
00670     bool operator !=(const RubyTextToken& RHS) const{                   //比較演算子(2)
00671         return(Text!=RHS.Text || Size!=RHS.Size || Color!=RHS.Color || Font!=RHS.Font || a!=RHS.a || 
00672                IsBold!=RHS.IsBold || IsItalic!=RHS.IsItalic || Width!=RHS.Width || Height!=RHS.Height);
00673     }
00674 };
00675 
00676 //ルビテキスト(行単位)
00687 class RubyTextTokenLine{
00688 public:
00692     RubyTextTokenLine();                                                //デフォルトコンストラクタ
00697     RubyTextTokenLine(const RubyTextTokenLine& Src);                    //コピーコンストラクタ
00701     ~RubyTextTokenLine();                                               //デストラクタ
00702 
00706     void clear();                                                       //消去
00707 
00712     bool push_back(const RubyTextToken& Src);                           //追加(字)
00718     void pop_back();                                                    //削除(字)
00719 
00726     RubyTextToken& at(unsigned int Num);                                //参照(1-1)
00733     const RubyTextToken& at(unsigned int Num) const;                    //参照(1-2)
00740     RubyTextToken& back();                                              //参照(2-1)
00747     const RubyTextToken& back() const;                                  //参照(2-2)
00748 
00753     unsigned int GetWidth() const;                                      //横幅を取得
00758     unsigned int GetHeight() const;                                     //縦幅を取得
00759 
00764     bool empty() const;                                                 //空か?
00769     unsigned int size() const;                                          //サイズを取得
00770 
00776     RubyTextTokenLine& operator =(const RubyTextTokenLine& RHS);        //代入演算子
00782     bool operator ==(const RubyTextTokenLine& RHS) const;               //比較演算子(1)
00788     bool operator !=(const RubyTextTokenLine& RHS) const;               //比較演算子(2)
00789 private:
00790     RubyTextToken** m_P;                                                //配列
00791     unsigned int m_Size;                                                //サイズ
00792     unsigned int m_Capacity;                                            //キャパシティ
00793 };
00794 
00795 //テキスト(字単位)
00805 struct TextToken{
00809     mystr Text;                                                         //テキスト
00813     unsigned int Size;                                                  //サイズ
00817     COLORREF Color;                                                     //カラー
00821     mystr Font;                                                         //フォント
00825     BYTE a;                                                             //透過度
00831     bool IsBold;                                                        //太字か?
00837     bool IsItalic;                                                      //斜体か?
00841     unsigned int Width;                                                 //横幅
00845     unsigned int Height;                                                //縦幅
00849     RubyTextTokenLine Ruby;                                             //ルビ
00850 
00854     TextToken(){                                                        //デフォルトコンストラクタ
00855         Clear();
00856     }
00860     void Clear(){                                                       //各要素をクリア
00861         Text = "";
00862         Size = 0;
00863         Color = 0;
00864         Font = "";
00865         a = 0;
00866         IsBold = false;
00867         IsItalic = false;
00868         Width = 0; Height = 0;
00869         Ruby.clear();
00870     }
00876     bool operator ==(const TextToken& RHS) const{                       //比較演算子(1)
00877         return(Text==RHS.Text && Size==RHS.Size && Color==RHS.Color && Font==RHS.Font && a==RHS.a && 
00878                IsBold==RHS.IsBold && IsItalic==RHS.IsItalic && Width==RHS.Width && Height==RHS.Height && Ruby==RHS.Ruby);
00879     }
00885     bool operator !=(const TextToken& RHS) const{                       //比較演算子(2)
00886         return(Text!=RHS.Text || Size!=RHS.Size || Color!=RHS.Color || Font!=RHS.Font || a!=RHS.a || 
00887                IsBold!=RHS.IsBold || IsItalic!=RHS.IsItalic || Width!=RHS.Width || Height!=RHS.Height || Ruby!=RHS.Ruby);
00888     }
00889 };
00890 
00891 //テキスト(行単位)
00902 class TextTokenLine{
00903 public:
00907     TextTokenLine();                                                    //デフォルトコンストラクタ
00912     TextTokenLine(const TextTokenLine& Src);                            //コピーコンストラクタ
00916     ~TextTokenLine();                                                   //デストラクタ
00917 
00921     void clear();                                                       //消去
00922 
00930     bool push_back(const TextToken& Src, unsigned int MaxWidth);        //追加(字)
00936     void pop_back();                                                    //削除(字)
00937 
00944     TextToken& at(unsigned int Num);                                    //参照(1-1)
00951     const TextToken& at(unsigned int Num) const;                        //参照(1-2)
00958     TextToken& back();                                                  //参照(2-1)
00965     const TextToken& back() const;                                      //参照(2-2)
00966 
00971     unsigned int GetWidth() const;                                      //横幅を取得
00976     unsigned int GetHeight() const;                                     //縦幅を取得
00977 
00982     bool empty() const;                                                 //空か?
00987     unsigned int size() const;                                          //サイズを取得
00988 
00994     TextTokenLine& operator =(const TextTokenLine& RHS);                //代入演算子
01000     bool operator ==(const TextTokenLine& RHS) const;                   //比較演算子(1)
01006     bool operator !=(const TextTokenLine& RHS) const;                   //比較演算子(2)
01007 private:
01008     TextToken** m_P;                                                    //配列
01009     unsigned int m_Size;                                                //サイズ
01010     unsigned int m_Capacity;                                            //キャパシティ
01011 };
01012 
01013 //テキスト(文単位)
01024 class TextTokenSection{
01025 public:
01029     TextTokenSection();                                                 //デフォルトコンストラクタ
01034     TextTokenSection(const TextTokenSection& Src);                      //コピーコンストラクタ
01038     ~TextTokenSection();                                                //デストラクタ
01039 
01043     void clear();                                                       //消去
01044 
01053     bool push_back(const TextTokenLine& Src, unsigned int MaxWidth, unsigned int MaxHeight);
01054                                                                         //追加(行)
01060     void pop_back();                                                    //削除(行)
01061 
01068     TextTokenLine& at(unsigned int Num);                                //参照(1-1)
01075     const TextTokenLine& at(unsigned int Num) const;                    //参照(1-2)
01082     TextTokenLine& back();                                              //参照(2-1)
01089     const TextTokenLine& back() const;                                  //参照(2-2)
01090 
01095     unsigned int GetWidth() const;                                      //横幅を取得
01100     unsigned int GetHeight() const;                                     //縦幅を取得
01101 
01106     bool empty() const;                                                 //空か?
01111     unsigned int size() const;                                          //サイズを取得
01112 
01118     TextTokenSection& operator =(const TextTokenSection& RHS);          //代入演算子
01124     bool operator ==(const TextTokenSection& RHS) const;                //比較演算子(1)
01130     bool operator !=(const TextTokenSection& RHS) const;                //比較演算子(2)
01131 private:
01132     TextTokenLine** m_P;                                                //配列
01133     unsigned int m_Size;                                                //サイズ
01134     unsigned int m_Capacity;                                            //キャパシティ
01135 };
01136 
01137 }
01138 }
01139 
01140 #endif
 全て クラス ネームスペース ファイル 関数 変数 型定義 列挙型 列挙型の値 フレンド マクロ定義