プログラミング/組み込み言語/Sqrat/各クラスの説明 のバックアップソース(No.2)

Sqratの各クラスについて説明しています。~
Sqratの概要および導入については[[別ページを参照>../概要と導入]]してください。

#contents


*@code{Object}; クラス … Sqratオブジェクトの基底クラス [#object]

**解説 [#object-descript]

@code{Object}; クラスは、以降に説明する次のクラスの基底クラスです。

-[[@code{Script}; クラス>#script]]
-[[@code{RootTable}; クラス>#table]]
-[[@code{Table}; クラス>#table]]
-[[@code{Class<C,A>}; クラス>#class]]
-[[@code{DerivedClass<C,B,A>}; クラス>#derivedclass]]
-[[@code{Enumeration}; クラス>#enumeration]]
-[[@code{ConstTable}; クラス>#consttable]]

自身のラップ対象となる @code{HSQOBJECT}; インスタンスを保持しており、オブジェクトに共通する操作をサポートします。~
当然ながら、このクラスを継承しているクラスのインスタンスにおいても後述する公開メンバ関数を使うことができます。

**公開メンバ関数一覧 [#object-members]

//////////
:コンストラクタ|
#code(c,nomenu,nonumber,nooutline,noliteral,nocomment){{
Object();
Object(HSQOBJECT o, HSQUIRRELVM v = DefaultVM::Get());
Object(const Object& so);
}}
通常、直接このクラスのコンストラクタを呼び出すことはありません。
//////////
:@code{Cast<T>};|
#code(c,nomenu,nonumber,nooutline,noliteral,nocomment){{
template<class T> T Cast() const;
}}
自身をテンプレート引数 @code{T}; で指定したC++型として取得します。~
@code{T}; には、 @code{int}; 等の基本型の他、あらかじめバインドしたクラス型等も指定できます。
//////////
:@code{GetInstanceUP};|
#code(c,nomenu,nonumber,nooutline,noliteral,nocomment){{
SQUserPointer GetInstanceUP(SQUserPointer tag = NULL) const;
}}
自身に対してSquirrel API関数 @code{sq_getinstanceup}; を呼び出し、得られたユーザポインタを取得します。~
引数 @code{tag}; に型チェックを行うべき型を渡せますが、結果は見ていないようです。
//////////
:@code{GetObject};|
#code(c,nomenu,nonumber,nooutline,noliteral,nocomment){{
virtual HSQOBJECT GetObject() const;
virtual HSQOBJECT& GetObject();
}}
自身のラップ対象であるオブジェクトを取得します。
//////////
:@code{GetSlot};|
#code(c,nomenu,nonumber,nooutline,noliteral,nocomment){{
Object GetSlot(const SQChar* slot) const;
}}
自身が保持する、指定した名前の変数の値を取得します。~
詳しくは[[概要と導入の『変数の値の取得』の項>../概要と導入#basic-s2c-getvar]]を参照してください。
//////////
:@code{GetType};|
#code(c,nomenu,nonumber,nooutline,noliteral,nocomment){{
SQObjectType GetType() const;
}}
自身のSquirrel型を取得します。
//////////
:@code{GetVM};|
#code(c,nomenu,nonumber,nooutline,noliteral,nocomment){{
HSQUIRRELVM& GetVM();
HSQUIRRELVM GetVM() const;
}}
自身を保持しているVMを取得します。
//////////
:@code{IsNull};|
#code(c,nomenu,nonumber,nooutline,noliteral,nocomment){{
bool IsNull() const;
}}
自身が @code{null}; 値であるならば @code{true}; 、そうでなければ @code{false}; を返します。
//////////
:@code{Release};|
#code(c,nomenu,nonumber,nooutline,noliteral,nocomment){{
void Release();
}}
自身の参照カウントをデクリメントします。~
通常、直接呼び出す必要はありません。
//////////
//:@code{};|
//#code(c,nomenu,nonumber,nooutline,noliteral,nocomment){{
//}}


*@code{Script}; クラス … スクリプトのコンパイルと実行 [#script]

**解説 [#script-descript]

@code{Script}; クラスでは、Squirrelスクリプトのコンパイル、実行、およびバイトコードの保存を行うことができます。~
コーディング例を次に示します。

#code(c){{
// 文字列をSquirrelスクリプトとしてコンパイル＆実行
Script scriptA(vm);
scriptA.CompileString(_SC("print(\"Hello, Sqrat World.\\n\");"));
scriptA.Run();

// ファイルをSquirrelスクリプトとしてコンパイルし、バイトコードを保存
Script scriptB(vm);
try
{
    scriptB.CompileFile(_SC("test.nut"));
    scriptB.WriteCompiledFile(_SC("test.cnut"));
}
catch (const Exception& ex)
{
    // 例外メッセージを出力
    printfunc(vm, _SC("%s\n"), ex.Message().data());
}
}}

**公開メンバ関数一覧 [#script-members]

:継承元|
--[[@code{Object}; クラスの公開メンバ関数一覧>#object-members]]
//////////
:コンストラクタ|
#code(c,nomenu,nonumber,nooutline,noliteral,nocomment){{
Script(HSQUIRRELVM v = DefaultVM::Get());
}}
//////////
:@code{CompileFile};|
#code(c,nomenu,nonumber,nooutline,noliteral,nocomment){{
void CompileFile(const Sqrat::string& path);
}}
引数 @code{path}; で指定されたパスにあるファイルをSquirrelスクリプトとしてコンパイルします。~
コンパイルに失敗した場合は Sqrat::Exception インスタンスを例外としてスローします。
//////////
:@code{CompileString};|
#code(c,nomenu,nonumber,nooutline,noliteral,nocomment){{
void CompileString(const Sqrat::string& script);
}}
引数 @code{script}; に渡された文字列をSquirrelスクリプトとしてコンパイルします。~
コンパイルに失敗した場合は Sqrat::Exception インスタンスを例外としてスローします。
//////////
:@code{Run};|
#code(c,nomenu,nonumber,nooutline,noliteral,nocomment){{
void Run();
}}
コンパイルしたSquirrelスクリプトを実行します。~
まだコンパイルしていない場合は何も行いません。~
実行に失敗した場合は Sqrat::Exception インスタンスを例外としてスローします。
//////////
:@code{WriteCompiledFile};|
#code(c,nomenu,nonumber,nooutline,noliteral,nocomment){{
void WriteCompiledFile(const Sqrat::string& path);
}}
コンパイルしたSquirrelスクリプトのバイトコードを、引数 @code{path}; で指定されたパスのファイルに保存します。~
まだコンパイルしていない場合は何も行いません。~
保存されたファイルは、テキストのスクリプトファイルと同様に @code{CompileFile}; メンバ関数に渡すことができます。
//////////
//:@code{};|
//#code(c,nomenu,nonumber,nooutline,noliteral,nocomment){{
//}}


*@code{RootTable}; クラス、 @code{Table}; クラス … テーブルの定義 [#table]

**解説 [#table-descript]

@code{RootTable}; クラスは、文字通りルートテーブルを表します。~
ルートテーブルは、C++でいうグローバル名前空間のようなものと考えるとわかりやすいです。

@code{Table}; クラスは、テーブルを表します。~
C++でいう名前空間のようなものと考えるとわかりやすいです。~
基本的にはルートテーブルもしくは他のテーブルにバインドして用います。

この2クラスはどちらも @code{TableBase}; クラスを継承しています。~
両者の違いはコンストラクタでの処理のみです。

テーブル作成のC++コーディング例を次に示します。

#code(c){{
Table tableA(vm);
Table tableB(vm);

// tableB を tableA にバインド
tableA.Bind("B", tableB);

// tableA をルートテーブルにバインド
RootTable(vm).Bind("A", tableA);
}}

上記のコードは、次のSquirrelスクリプトと同義です。

#code(squirrel){{
A <- { B = {} }
}}

**公開メンバ関数一覧 [#table-members]

:継承元|
--[[@code{Object}; クラスの公開メンバ関数一覧>#object-members]]
//////////
:コンストラクタ|
#code(c,nomenu,nonumber,nooutline,noliteral,nocomment){{
RootTable(HSQUIRRELVM v = DefaultVM::Get());
Table(HSQUIRRELVM v = DefaultVM::Get());
}}
//////////
:@code{Bind};|
#code(c,nomenu,nonumber,nooutline,noliteral,nocomment){{
void Bind(const SQChar* name, Object& obj);
}}
テーブル定義またはクラス定義 @code{obj}; をこのテーブルに @code{name}; で指定した名前でバインドします。~
詳しくは[[概要と導入の『クラスやテーブルのバインド』の項>../概要と導入#basic-c2s-bind]]を参照してください。
//////////
:@code{Func};|
#code(c,nomenu,nonumber,nooutline,noliteral,nocomment){{
template<class F> TableBase& Func(const SQChar* name, F method);
}}
C/C++関数 @code{method}; をこのテーブルに @code{name}; という名前でバインドします。~
詳しくは[[概要と導入の『クラスやテーブルのバインド』の項>../概要と導入#basic-c2s-bind]]を参照してください。
//////////
:@code{GetFunction};|
#code(c,nomenu,nonumber,nooutline,noliteral,nocomment){{
Function GetFunction(const SQChar* name);
}}
このテーブル内にあるSquirrel関数を取得します。~
詳しくは[[概要と導入の『関数の取得と実行』の項>../概要と導入#basic-s2c-getfunc]]を参照してください。
//////////
:@code{Overload};|
#code(c,nomenu,nonumber,nooutline,noliteral,nocomment){{
template<class F> TableBase& Overload(const SQChar* name, F method);
}}
C++のオーバーロード関数 @code{method}; をこのテーブルに @code{name}; という名前でバインドします。~
基本的な使い方は @code{Func}; メンバ関数と同じですが、オーバーロード関数を定義したい場合はこちらを用います。~
なお、登録できるオーバーロード関数は引数の数が異なるもののみです（引数の型が異なるだけだと上書きされます）。~
@code{Func}; メンバ関数を用いる場合と比べ、呼び出し時にラッパー関数を通す分だけ若干のオーバーヘッドがあります。
//////////
:@code{SetInstance};|
#code(c,nomenu,nonumber,nooutline,noliteral,nocomment){{
template<class V> TableBase& SetInstance(const SQChar* name, V* val);
}}
@code{name}; で指定した名前のSquirrel変数を作成し、インスタンス @code{val}; をバインドします。~
既に変数が存在する場合は上書きされます。~
基本的には、あらかじめバインドしたクラス型のインスタンスを渡します。~
ここで渡したインスタンスがSquirrel側で操作されると、C++側にも変更が反映されます。~
詳しくは[[概要と導入の『変数への値のバインド』の項>../概要と導入#basic-c2s-setvar]]を参照してください。
//////////
:@code{SetValue};|
#code(c,nomenu,nonumber,nooutline,noliteral,nocomment){{
template<class V> TableBase& SetValue(const SQChar* name, const V& val);
}}
@code{name}; で指定した名前のSquirrel変数を作成し、値 @code{val}; をバインドします。~
既に変数が存在する場合は上書きされます。~
値には基本型の他、あらかじめバインドしたクラス型も用いることができます（ただしコピー可能である必要があります）。~
ここで渡した値はコピーされるため、Squirrel側で操作してもC++側には影響を及ぼしません。~
詳しくは[[概要と導入の『変数への値のバインド』の項>../概要と導入#basic-c2s-setvar]]を参照してください。
//////////
:@code{SquirrelFunc};|
#code(c,nomenu,nonumber,nooutline,noliteral,nocomment){{
TableBase& SquirrelFunc(const SQChar* name, SQFUNCTION func);
}}
Squirrel用関数 @code{func}; をこのテーブルに @code{name}; で指定した名前でバインドします。~
C/C++関数をバインドしたい場合は @code{Func}; メンバ関数を用いてください。
//////////
//:@code{};|
//#code(c,nomenu,nonumber,nooutline,noliteral,nocomment){{
//}}


*@code{Class<C,A>}; クラス … クラスの定義 [#class]

**解説 [#class-descript]

C++クラスをSquirrelにバインドするためのクラスです。~
コーディング例を次に示します。

#code(c){{
// バインド対象のクラス
class Sample
{
public:
    Sample() : _text(_SC("")), _num(1) {}

    // メンバ関数
    int mulNum(int value) { return (value * _num); }

    // アクセッサ(プロパティ)
    int getNum() const { return _num; }
    void setNum(const int& num) { _num = num; }

    // メンバ変数
    Sqrat::string _text;

private:
    int _num;
};

// Sample クラスをバインドする関数
void bindSampleClass(HSQUIRRELVM vm)
{
    using namespace Sqrat;

    RootTable(vm).Bind(
        _SC("Sample"),
        Class<Sample>(vm)
            .Func(_SC("mulNum"), &Sample::mulNum)               // メンバ関数
            .Prop(_SC("Num"), &Sample::getNum, &Sample::setNum) // プロパティ
            .Var(_SC("Text"), &Sample::_text)                   // メンバ変数
        );
}
}}

上記の @code{bindSampleClass}; 関数を通したVMでは、次のようなSquirrelスクリプトを実行できます。

#code(squirrel){{
local sample = Sample();
sample.Num = 3;
local answer = sample.mulNum(5);
sample.Text = "ABC";

::print(answer + "\n");      // "15\n"
::print(sample.Num + "\n");  // "3\n"
::print(sample.Text + "\n"); // "ABC\n"
}}

また、定義済みのクラスのインスタンスであれば、Squirrelの変数に設定したり、関数の引数に渡すこともできます。

**テンプレート引数 [#class-template]

#code(c,nomenu,nonumber,nooutline,noliteral,nocomment){{
template<
    class C,
    class A = DefaultAllocator<C>
> class Class;
}}

:@code{class C};|
このクラスの定義対象となるC++クラス型を指定します。
:@code{class A};|
C++クラスに対するアロケータを指定します。~
アロケータによって次のことが行われます。
--インスタンス生成（コンストラクタ呼び出し）
--インスタンスコピー
--インスタンス解放（デストラクタ呼び出し）
:|
Sqratで定義済みのアロケータは次の通りです（これ以外のアロケータを自前で定義することもできます）。
::@code{DefaultAllocator<C>};|
インスタンスの生成、コピー、解放をすべてサポートするアロケータです。~
@code{Class<T,A>}; クラスにおいてアロケータを省略した場合の既定のアロケータとなります。
::@code{NoConstructor};|
インスタンスの生成、コピー、解放のいずれもサポートしない（即ち何もしない）アロケータです。~
Squirrelスクリプト内で勝手に生成やコピーを行われたくない場合等に用います。
::@code{CopyOnly<C>};|
インスタンスのコピーと解放をサポートし、生成はサポートしないアロケータです。
::@code{NoCopy<C>};|
インスタンスの生成と解放をサポートし、コピーはサポートしないアロケータです。

**公開メンバ関数一覧 [#class-members]

:継承元|
--[[@code{Object}; クラスの公開メンバ関数一覧>#object-members]]
//////////
:コンストラクタ|
#code(c,nomenu,nonumber,nooutline,noliteral,nocomment){{
Class(HSQUIRRELVM v = DefaultVM::Get(), bool createClass = true);
}}
引数 @code{createClass}; は、このクラスを継承したクラスで独自の初期化処理を行う場合のみ @code{false}; にします。~
直接このクラスを用いる場合には @code{false}; にしてはいけません。
//////////
:@code{Func};|
#code(c,nomenu,nonumber,nooutline,noliteral,nocomment){{
template<class F> Class& Func(const SQChar* name, F method);
}}
対象C++クラスのメンバ関数 @code{method}; をこのクラスに @code{name}; という名前でバインドします。
//////////
:@code{GetFunction};|
#code(c,nomenu,nonumber,nooutline,noliteral,nocomment){{
Function GetFunction(const SQChar* name);
}}
このクラスにバインドされている @code{name}; という名前の静的メンバ関数を取得します。
//////////
:@code{GetObject};|
#code(c,nomenu,nonumber,nooutline,noliteral,nocomment){{
virtual HSQOBJECT GetObject() const;
virtual HSQOBJECT& GetObject();
}}
[[@code{Object}; クラス>#object]]からオーバーライド。~
自身のラップ対象となるクラス型のオブジェクトを取得します。
//////////
:@code{GlobalFunc};|
#code(c,nomenu,nonumber,nooutline,noliteral,nocomment){{
template<class F> Class& GlobalFunc(const SQChar* name, F method);
}}
対象C++クラスのメンバ関数ではない関数 @code{method}; を、このクラスに @code{name}; という名前のメンバ関数としてバインドします。~
関数 @code{method}; の第一引数は対象クラスのポインタ型にする必要があります。~
呼び出される際には、第一引数に呼び出し元のクラスインスタンスが渡されます。
//////////
:@code{Overload};|
#code(c,nomenu,nonumber,nooutline,noliteral,nocomment){{
template<class F> Class& Overload(const SQChar* name, F method);
}}
対象C++クラスのオーバーロードメンバ関数 @code{method}; をこのクラスに @code{name}; という名前でバインドします。~
基本的な使い方は @code{Func}; メンバ関数と同じですが、オーバーロード関数を定義したい場合はこちらを用います。~
なお、登録できるオーバーロード関数は引数の数が異なるもののみです（引数の型が異なるだけだと上書きされます）。~
@code{Func}; メンバ関数を用いる場合と比べ、呼び出し時にラッパー関数を通す分だけ若干のオーバーヘッドがあります。
//////////
:@code{Prop};|
#code(c,nomenu,nonumber,nooutline,noliteral,nocomment){{
template<class V> Class& Prop(
    const SQChar* name, V (C::*getMethod)() const, void (C::*setMethod)(const V&));
template<class V> Class& Prop(
    const SQChar* name, V (C::*getMethod)(), void (C::*setMethod)(V));
template<class V> Class& Prop(const SQChar* name, V (C::*getMethod)() const);
template<class V> Class& Prop(const SQChar* name, V (C::*getMethod)());
}}
対象C++クラスの2つのメンバ関数 @code{getMethod}; および @code{setMethod}; を、このクラスに @code{name}; という名前のプロパティとしてバインドします。~
あるいは、取得専用プロパティ用に、メンバ関数 @code{getMethod}; のみをバインドすることもできます。~
設定できるメンバ関数プロトタイプの組み合わせは次の2通りです。
#code(c,nomenu,nonumber,nooutline,noliteral,nocomment){{
Type get() const;
void set(const Type& value);
}}
#code(c,nomenu,nonumber,nooutline,noliteral,nocomment){{
Type get();
void set(Type value);
}}
前者は値型に、後者は参照型もしくはポインタ型に用いることになるでしょう。
//////////
:@code{SetStaticValue};|
#code(c,nomenu,nonumber,nooutline,noliteral,nocomment){{
template<class V> Class& SetStaticValue(const SQChar* name, const V& val);
}}
このクラスに @code{name}; という名前の静的メンバ変数を作成し、値 @code{val}; をバインドします。~
既に変数が存在する場合は上書きされます。~
値には基本型の他、あらかじめバインドしたクラス型も用いることができます（ただしコピー可能である必要があります）。~
Squirrelでは、クラスの静的メンバ変数は定数値として扱われます。
//////////
:@code{SetValue};|
#code(c,nomenu,nonumber,nooutline,noliteral,nocomment){{
template<class V> Class& SetValue(const SQChar* name, const V& val);
}}
このクラスに @code{name}; という名前のメンバ変数を作成し、値 @code{val}; をバインドします。~
既に変数が存在する場合は上書きされます。~
値には基本型の他、あらかじめバインドしたクラス型も用いることができます（ただしコピー可能である必要があります）。~
ここで渡した値はコピーされるため、Squirrel側で操作してもC++側には影響を及ぼしません。
//////////
:@code{SquirrelFunc};|
#code(c,nomenu,nonumber,nooutline,noliteral,nocomment){{
template<class F> Class& SquirrelFunc(const SQChar* name, SQFUNCTION func);
}}
Squirrel用関数 @code{func}; をこのクラスに @code{name}; という名前のメンバ関数としてバインドします。
//////////
:@code{StaticFunc};|
#code(c,nomenu,nonumber,nooutline,noliteral,nocomment){{
template<class F> Class& StaticFunc(const SQChar* name, F method);
}}
関数 @code{method}; をこのクラスに @code{name}; という名前の静的メンバ関数としてバインドします。~
関数 @code{method}; は、対象C++クラスの静的メンバ関数でなくても構いません。
//////////
:@code{Var};|
#code(c,nomenu,nonumber,nooutline,noliteral,nocomment){{
template<class V> Class& Var(const SQChar* name, V C::* var);
}}
対象C++クラスのメンバ変数 @code{var}; をこのクラスに @code{name}; という名前でバインドします。
//////////
//:@code{};|
//#code(c,nomenu,nonumber,nooutline,noliteral,nocomment){{
//}}


*@code{DerivedClass<C,B,A>}; クラス … 継承クラスの定義 [#derivedclass]

**解説 [#derivedclass-descript]

あるC++クラスを継承しているC++クラスをSquirrelにバインドするためのクラスです。~
継承元のC++クラスはあらかじめ [[@code{Class<C,A>}; クラス>#class]]もしくはこのクラスを用いてバインド済みである必要があります。

コーディング例を次に示します。

#code(c){{
// ベースクラス
class Base
{
public:
    // 純粋仮想関数
    virtual double getNum() const = 0;
    virtual void setNum(const double& num) = 0;

    // getNum の返り値を出力
    void printNum()
    {
        ::printf("%lf\n", getNum());
    }
};

// 継承クラス
class Derived : public Base
{
public:
    Derived() : _num(0.0) {}

    // 純粋仮想関数の実装
    virtual double getNum() const { return _num; }
    virtual void setNum(const double& num) { _num = num; }

private:
    double _num;
};

// バインド用関数
void bindBaseAndDerived(HSQUIRRELVM vm)
{
    using namespace Sqrat;

    // ベースクラスをバインド
    RootTable(vm).Bind(
        _SC("Base"),
        Class<Base, NoConstructor>(vm)
            .Prop(_SC("Num"), &Base::getNum, &Base::setNum)
            .Func(_SC("printNum"), &Base::printNum)
        );

    // 継承クラスをバインド
    RootTable(vm).Bind(
        _SC("Derived"), DerivedClass<Derived, Base>(vm));
}
}}

上記の @code{bindBaseAndDerived}; 関数を通したVMでは、次のようなSquirrelスクリプトを実行できます。

#code(squirrel){{
local derived = Derived();
derived.Num = 3.14;
derived.printNum();
}}

また、 @code{DerivedClass<C,B,A>}; クラスは @code{Class<C,A>}; クラスを継承しており、 @code{Class<C,A>}; クラスと同様にメンバ関数の追加等をすることができます。

**テンプレート引数 [#derivedclass-template]

#code(c,nomenu,nonumber,nooutline,noliteral,nocomment){{
template<
    class C,
    class B,
    class A = DefaultAllocator<C>
> class DerivedClass;
}}

:@code{class C};|
このクラスの定義対象となるC++クラス型を指定します。
:@code{class B};|
@code{C}; の継承元となるC++クラス型を指定します。~
あらかじめバインド済みである必要があります。
:@code{class A};|
C++クラスに対するアロケータを指定します。~
詳しくは [[@code{Class<C,A>}; クラスのテンプレート引数の項>#class-template]]を参照してください。

**公開メンバ関数一覧 [#derivedclass-members]

:継承元|
--[[@code{Object}; クラスの公開メンバ関数一覧>#object-members]]
--[[@code{Class<C,A>}; クラスの公開メンバ関数一覧>#class-members]]
//////////
:コンストラクタ|
#code(c,nomenu,nonumber,nooutline,noliteral,nocomment){{
DerivedClass(HSQUIRRELVM v = DefaultVM::Get());
}}
//////////
//:@code{};|
//#code(c,nomenu,nonumber,nooutline,noliteral,nocomment){{
//}}


*@code{Enumeration}; クラス … 列挙定数値の定義 [#enumeration]

**解説 [#enumeration-descript]

@code{Enumeration}; クラスは列挙定数値を定義するためのクラスです。~
C/C++でいう @code{enum}; 値のようなものですが、C/C++とは違い次の型の値を設定可能です。

-@code{int};
-@code{float};
-@code{SQChar*};（文字列）

このクラスのインスタンスは、後述する [[@code{ConstTable}; クラス>#consttable]]のインスタンスにバインドして用います。~
コーディング例は [[@code{ConstTable}; クラスの解説の項>#consttable-descript]]を参照してください。

**公開メンバ関数一覧 [#enumeration-members]

:継承元|
--[[@code{Object}; クラスの公開メンバ関数一覧>#object-members]]
//////////
:コンストラクタ|
#code(c,nomenu,nonumber,nooutline,noliteral,nocomment){{
Enumeration(HSQUIRRELVM v = DefaultVM::Get(), bool createTable = true);
}}
引数 @code{createTable}; は、このクラスを継承したクラスで独自の初期化処理を行う場合のみ @code{false}; にします。~
直接このクラスを用いる場合には @code{false}; にしてはいけません。
//////////
:@code{Const};|
#code(c,nomenu,nonumber,nooutline,noliteral,nocomment){{
virtual Enumeration& Const(const SQChar* name, const int val);
virtual Enumeration& Const(const SQChar* name, const float val);
virtual Enumeration& Const(const SQChar* name, const SQChar* val);
}}
@code{name}; という名前の列挙定数値 @code{val}; を設定します。
//////////
//:@code{};|
//#code(c,nomenu,nonumber,nooutline,noliteral,nocomment){{
//}}


*@code{ConstTable}; クラス … 定数テーブルの定義 [#consttable]

**解説 [#consttable-descript]

@code{ConstTable}; クラスは定数値を定義するためのクラスです。~
また、前述の [[@code{Enumeration}; クラス>#enumeration]]で定義した列挙をバインドすることもできます。~
定数値はSquirrelスクリプトのコンパイル時点で評価されるため、通常の変数を定数代わりに用いる場合と比べ、テーブルの走査が不要な分だけ処理速度が向上します。

コーディング例を次に示します。

#code(c){{
// 定数値の設定
ConstTable(vm)
    .Const(_SC("ConstInt"), 1)                      // int
    .Const(_SC("ConstFloat"), 3.5F)                 // float
    .Const(_SC("ConstStr"), _SC("string sample"))   // SQChar*
    ;

// 列挙定数値 Pos の設定
Enumeration pos(vm);
pos.Const(_SC("Left"),   0);
pos.Const(_SC("Center"), 1);
pos.Const(_SC("Right"),  2);
ConstTable(vm).Enum(_SC("Pos"), pos);

// 列挙定数値 Color の設定(別の書き方)
ConstTable(vm).Enum(
    _SC("Color"),
    Enumeration(vm)
        .Const(_SC("Red"),   0)
        .Const(_SC("Green"), 1)
        .Const(_SC("Blue"),  2)
    );
}}

上記の処理を通したVMでは、次のようなSquirrelスクリプトを実行できます。

#code(squirrel){{
::print(ConstInt + 3 + "\n"); // "4\n"
::print(ConstStr + "\n");     // "string sample\n"
::print(Pos.Center + "\n");   // "1\n"
::print(Color.Blue + "\n");   // "2\n"
}}

なお、 @code{ConstTable}; クラスは @code{Enumeration}; クラスを継承しています。

**公開メンバ関数一覧 [#consttable-members]

:継承元|
--[[@code{Object}; クラスの公開メンバ関数一覧>#object-members]]
--[[@code{Enumeration}; クラスの公開メンバ関数一覧>#enumeration-members]]
//////////
:コンストラクタ|
#code(c,nomenu,nonumber,nooutline,noliteral,nocomment){{
ConstTable(HSQUIRRELVM v = DefaultVM::Get());
}}
//////////
:@code{Const};|
#code(c,nomenu,nonumber,nooutline,noliteral,nocomment){{
virtual ConstTable& Const(const SQChar* name, const int val);
virtual ConstTable& Const(const SQChar* name, const float val);
virtual ConstTable& Const(const SQChar* name, const SQChar* val);
}}
@code{name}; という名前の定数値 @code{val}; を設定します。
//////////
:@code{Enum};|
#code(c,nomenu,nonumber,nooutline,noliteral,nocomment){{
ConstTable& Enum(const SQChar* name, Enumeration& en);
}}
@code{name}; という名前の列挙 @code{en}; をバインドします。
//////////
//:@code{};|
//#code(c,nomenu,nonumber,nooutline,noliteral,nocomment){{
//}}


*@code{Function}; クラス … Squirrel関数のラッパー [#function]

**解説 [#function-descript]

@code{Function}; クラスは、Squirrelの関数をC++の関数的に扱う仕組みを提供します。~
インスタンスの取得には [[@code{Table}; クラス>#table]]または [[@code{Class<C,A>}; クラス>#class]]の @code{GetFunction}; メンバ関数を用います。~
また、 @code{Function}; クラスのコンストラクタでも同等の処理が行えます。

コーディング例は[[概要と導入の『関数の取得と実行』の項>../概要と導入#basic-s2c-getfunc]]を参照してください。

**公開メンバ関数一覧 [#function-members]

//////////
:コンストラクタ|
#code(c,nomenu,nonumber,nooutline,noliteral,nocomment){{
Function();
Function(const Function& sf);
Function(const Object& e, const SQChar* slot);
}}
3つ目の形式は、テーブルまたはクラスである @code{e}; から @code{slot}; という名前の関数を取得してラップ対象とします。~
即ち、 @code{e.GetFunction(slot)}; と意味的には同じです。
//////////
:@code{Evaluate};|
#code(c,nomenu,nonumber,nooutline,noliteral,nocomment){{
template<class R> R Evaluate();
template<class R, class A1> R Evaluate(A1 a1);
template<class R, class A1, class A2> R Evaluate(A1 a1, A2 a2);
// 以下、引数9個分まで。
}}
返り値を取得するタイプの関数呼び出しです。~
詳しくは[[概要と導入の『関数の取得と実行』の項>../概要と導入#basic-s2c-getfunc]]を参照してください。
//////////
:@code{Execute};|
#code(c,nomenu,nonumber,nooutline,noliteral,nocomment){{
void Execute();
template<class A1> void Execute(A1 a1);
template<class A1, class A2> void Execute(A1 a1, A2 a2);
// 以下、引数9個分まで。
}}
返り値を取得しないタイプの関数呼び出しです。~
詳しくは[[概要と導入の『関数の取得と実行』の項>../概要と導入#basic-s2c-getfunc]]を参照してください。
//////////
:@code{GetEnv};|
#code(c,nomenu,nonumber,nooutline,noliteral,nocomment){{
HSQOBJECT& GetEnv();
}}
このクラスのラップ対象である関数が属するテーブルまたはクラスのオブジェクトを取得します。
//////////
:@code{GetFunc};|
#code(c,nomenu,nonumber,nooutline,noliteral,nocomment){{
HSQOBJECT& GetFunc();
}}
このクラスのラップ対象である関数のオブジェクトを取得します。
//////////
:@code{GetVM};|
#code(c,nomenu,nonumber,nooutline,noliteral,nocomment){{
HSQUIRRELVM& GetVM();
}}
自身を保持しているVMを取得します。
//////////
:@code{IsNull};|
#code(c,nomenu,nonumber,nooutline,noliteral,nocomment){{
bool IsNull();
}}
自身が @code{null}; 値であるならば @code{true}; 、そうでなければ @code{false}; を返します。~
関数が取得できなかった場合等に @code{null}; 値となります。
//////////
:@code{Release};|
#code(c,nomenu,nonumber,nooutline,noliteral,nocomment){{
void Release();
}}
自身および自身が属するテーブルまたはクラスの参照カウントをデクリメントし、自身を @code{null}; 値とします。~
デストラクタでも呼び出されるため、通常このメンバ関数を直接呼び出す必要はありません。
//////////
:@code{operator()};|
#code(c,nomenu,nonumber,nooutline,noliteral,nocomment){{
void operator()();
template<class A1> void operator()(A1 a1);
template<class A1, class A2> void operator()(A1 a1, A2 a2);
// 以下、引数9個分まで。
}}
@code{Execute}; メンバ関数と同じです。~
詳しくは[[概要と導入の『関数の取得と実行』の項>../概要と導入#basic-s2c-getfunc]]を参照してください。
//////////
//:@code{};|
//#code(c,nomenu,nonumber,nooutline,noliteral,nocomment){{
//}}


*@code{DefaultVM}; クラス … 既定のVMの設定 [#defaultvm]

**解説 [#defaultvm-descript]

後述するSqratの各オブジェクトクラスは、コンストラクタの引数にVMをとります。

#code(c){{
Table myTable(vm);
Class<Foo> myClass(vm);
Script myScript(vm);
// etc...
}}

この仕様によって複数のVMを使い分けることができるのですが、VMを1つしか使わない場合は逆に冗長なものとなります。~
そこで、 @code{DefaultVM}; クラスを使うことにより、既定のVMを設定することができます。

#code(c){{
// 既定のVMを設定
DefaultVM::Set(vm);

// 引数のVMを省略すると DefaultVM::Get() が使われる
Table myTable();
Class<Foo> myClass();
Script myScript();
// etc...
}}

複数のVMを使う場合でも、どちらか片方を既定のVMとし、もう片方を使う場合は引数を省略しないようにすることで使い分けは可能です。

**公開メンバ関数一覧 [#defaultvm-members]

//////////
:@code{Get};|
#code(c,nomenu,nonumber,nooutline,noliteral,nocomment){{
static HSQUIRRELVM Get();
}}
既定のVMを取得します。~
各オブジェクトクラスのコンストラクタ引数の既定値として用いられます。~
なお、一度も @code{Set}; メンバ関数を呼びだしていない場合、この関数は不定値を返します。
//////////
:@code{Set};|
#code(c,nomenu,nonumber,nooutline,noliteral,nocomment){{
static void Set(HSQUIRRELVM vm);
}}
既定のVMを設定します。
//////////
//:@code{};|
//#code(c,nomenu,nonumber,nooutline,noliteral,nocomment){{
//}}


*@code{Exception}; クラス … Sqrat例外クラス [#exception]

**解説 [#exception-descript]

Sqratがスローする例外クラスです。~
例外発生時のエラーメッセージをメンバとして持ちます。

現時点では [[@code{Script}; クラス>#script]]の各メンバ関数でのみ用いられています。

**公開メンバ関数一覧 [#exception-members]

//////////
:コンストラクタ|
#code(c,nomenu,nonumber,nooutline,noliteral,nocomment){{
Exception(const Sqrat::string& msg);
Exception(const Exception& ex);
}}
//////////
:@code{Message};|
#code(c,nomenu,nonumber,nooutline,noliteral,nocomment){{
const Sqrat::string Message() const;
}}
例外メッセージを取得します。
//////////
//:@code{};|
//#code(c,nomenu,nonumber,nooutline,noliteral,nocomment){{
//}}