SFXAny

あらゆる型の格納と取得を行うための記憶域を提供するクラスです。

#include <SFXAny.h.hpp>

class SFXAny;

SFMTYPEDEFCLASS(SFXAny)

協調図

解説

SFXAny クラスは、型の安全性を保証しながら、あらゆる型の格納と取得を行うための記憶域を提供します。

ただし、格納する型は以下の条件を満たしている必要があります。

コピー生成可能であること。
代入可能であること。

格納した値を取得するには、any_cast 演算子を使用します。この際、格納した型をテンプレートパラメートとして与える必要があります。

格納された値の型とある型との同一性を判定するには、SFXAny::Contains 関数を呼び出します。

格納した値の型情報を取得するには、SFXAny::GetType 関数を呼び出します。

	注意
	`SFXAny::GetType` 関数で得られた値は型そのものではなく、他の型との同一性の判定にしか使用することができません。通常は、`SFXAny::Contains` 関数を呼び出します。

内部実装

このクラスの内部実装は、以下の通りです。

#include <SFXStructure/SFXTypeInfo.h.hpp>

SFMTYPEDEFCLASS(SFXAny)
class SFXAny {
    private:
        SFMTYPEDEFSTRUCT(HolderBase)
        struct HolderBase {
            virtual                             ~HolderBase                     (Void)
                    {
                    }
            virtual HolderBase*                 Clone                           (Void) const = 0;
            virtual SFXTypeInfo::TypeId         GetType                         (Void) const = 0;
        };
        template <typename T>
        struct Holder : public HolderBase {
                    T                           _value;
                                                Holder                          (T const& value) : _value(value)
                    {
                    }
            virtual HolderBase*                 Clone                           (Void) const
                    {
                        return ::new Holder(_value);
                    }
            virtual SFXTypeInfo::TypeId         GetType                         (Void) const
                    {
                        #if defined TARGET_COMPILER_ARMCPP && TARGET_COMPILER_VERSION < 300000
                        return SFXTypeInfo::GetTypeId((T*)(null));
                        #else
                        return SFXTypeInfo::GetTypeId(reinterpret_cast<T*>(null));
                        #endif
                    }
        };

    private:
        HolderBasePtr                           _content;
    public:
                                                SFXAny                          (Void);
        template <typename T>
                #if (defined TARGET_COMPILER_MSVCPP && TARGET_COMPILER_VERSION < 1300)
                                                SFXAny                          (T const& value)
                {
                    _content = ::new Holder<T>(value);
                }
                #else
                                                SFXAny                          (T const& value) : _content(HolderBasePtr(::new Holder<T>(value)))
                {
                }
                #endif
                                                SFXAny                          (SFXAnyConstRef other);
                                                ~SFXAny                         (Void);
        template <typename T>
                SFXAnyRef                       operator=                       (T const& value)
                {
                    #if defined TARGET_ENVIRONMENT_SIMULATOR
                    if (_content != null)
                    #endif
                    ::delete _content;
                    _content = ::new Holder<T>(value);
                    return *this;
                }
                SFXAnyRef                       operator=                       (SFXAnyConstRef other);
                SFXTypeInfo::TypeId             GetType                         (Void) const;
        template <typename T>
        static  Bool                            Contains                        (SFXAnyConstRef ref, T* param = null)
                {
                    unused(param);
                    #if defined TARGET_COMPILER_ARMCPP && TARGET_COMPILER_VERSION < 300000
                    return SFXTypeInfo::GetTypeId((T*)(null)) == ref.GetType();
                    #else
                    return SFXTypeInfo::GetTypeId(reinterpret_cast<T*>(null)) == ref.GetType();
                    #endif
                }
        template <typename T>
        friend  T const&                        any_cast                        (SFXAnyConstRef ref);
        #if !(defined TARGET_COMPILER_ARMCPP && TARGET_COMPILER_VERSION < 300000)
        template <typename T>
        friend  T &                             any_cast                        (SFXAnyRef ref);
        template <typename T>
        friend  T const*                        any_cast                        (SFXAnyConstPtr ptr);
        #endif
        template <typename T>
        friend  T*                              any_cast                        (SFXAnyPtr ptr);
};

#include <SFXGeneral/SFXEnvironment.h.hpp>

/*public */inline SFXAny::SFXAny(Void) : _content(null)
{
}// SFXAny::SFXAny //

/*public */inline SFXAny::SFXAny(SFXAnyConstRef other) : _content(other._content ? other._content->Clone() : null)
{
}// SFXAny::SFXAny(other) //

/*public */inline SFXAny::~SFXAny(Void)
{
    #if defined TARGET_ENVIRONMENT_SIMULATOR
    if (_content != null)
    #endif
    ::delete _content;
}// SFXAny::~SFXAny //

/*public */inline SFXAnyRef SFXAny::operator=(SFXAnyConstRef other)
{
    #if defined TARGET_ENVIRONMENT_SIMULATOR
    if (_content != null)
    #endif
    ::delete _content;
    _content = other._content ? other._content->Clone() : null;
    return *this;
}// SFXAny::operator=(other) //

/*public */inline SFXTypeInfo::TypeId SFXAny::GetType(Void) const
{
    SFXTypeInfo::TypeId                         result(null);

    if (_content != null) {
        result = _content->GetType();
    }
    return result;
}// SFXAny::GetType //

template <typename T>
inline T const& any_cast(SFXAnyConstRef ref)
{
    #if defined TARGET_COMPILER_ARMCPP && TARGET_COMPILER_VERSION < 300000
    return ((SFXAny::Holder<T>*)(ref._content))->_value;
    #else
    return static_cast<SFXAny::Holder<T>*>(ref._content)->_value;
    #endif
}// any_cast(ref) //

#if !(defined TARGET_COMPILER_ARMCPP && TARGET_COMPILER_VERSION < 300000)
template <typename T>
inline T & any_cast(SFXAnyRef ref)
{
    return static_cast<SFXAny::Holder<T>*>(ref._content)->_value;
}// any_cast(ref) //

template <typename T>
inline T const* any_cast(SFXAnyConstPtr ptr)
{
    return (ptr && ptr->GetType() == SFXTypeInfo::GetTypeId(reinterpret_cast<T*>(null))) ?
        &(static_cast<SFXAny::Holder<T>*>(ptr->_content)->_value) :
        null;
}// any_cast(Ptr) //
#endif

template <typename T>
inline T* any_cast(SFXAnyPtr ptr)
{
    #if defined TARGET_COMPILER_ARMCPP && TARGET_COMPILER_VERSION < 300000
    return (ptr && ptr->GetType() == SFXTypeInfo::GetTypeId((T*)(null))) ?
        &(((SFXAny::Holder<T>*)(ptr->_content))->_value) :
        null;
    #else
    return (ptr && ptr->GetType() == SFXTypeInfo::GetTypeId(reinterpret_cast<T*>(null))) ?
        &(static_cast<SFXAny::Holder<T>*>(ptr->_content)->_value) :
        null;
    #endif
}// any_cast(Ptr) //

参照

any_cast | SFXAny::Contains | SFXAny::GetType | SFXTypeInfo

メンバ

コンストラクタ/デストラクタ
SFXAny( `Void` ) SFXAny クラスのコンストラクタです。
SFXAny( `T const &` value ) SFXAny クラスのコンストラクタです。
SFXAny( `SFXAnyConstRef` other ) SFXAny クラスのコンストラクタです。
~SFXAny( `Void` ) SFXAny クラスのデストラクタです。

パブリック関数
static `Bool`	Contains( `SFXAnyConstRef` ref , `T *` param = null ) 指定された SFXAny インスタンスに格納されている値の型が指定された値の型と同じであるかどうかを判定します。
`SFXTypeInfo::TypeId`	GetType( `Void` ) 格納されている値の型情報を取得します。
`SFXAnyRef`	operator=( `T const &` value ) 左側の SFXAny インスタンスに右側の T 型の値、もしくは SFXAny インスタンスを代入します。
`SFXAnyRef`	operator=( `SFXAnyConstRef` other ) 左側の SFXAny インスタンスに右側の T 型の値、もしくは SFXAny インスタンスを代入します。

SFXAny::SFXAny

SFXAny クラスのコンストラクタです。

[ public ]
SFXAny(Void);

[ public ]
SFXAny(
    T const & value   // T const 参照型の値
);

[ public ]
SFXAny(
    SFXAnyConstRef other   // 他の SFXAny インスタンス
);

解説

引数がない場合、型情報（SFXTypeInfo::TypeId）の値は null になります。

引数がある場合、参照元の型と値を格納します。

格納された値は内部でヒープとして保持されます。

使用例

SInt32 i(5);
SFXAny a;
SFXAny b(i);
SFXAny c(b);

a = i;

TRACE("a = %d", any_cast<SInt32>(a));
TRACE("b = %d", any_cast<SInt32>(b));
TRACE("c = %d", any_cast<SInt32>(c));

// [結果]
// a = 5
// b = 5
// c = 5

参照

SFXTypeInfo::TypeId

SFXAny::~SFXAny

SFXAny クラスのデストラクタです。

[ public ]
~SFXAny(Void);

解説

このデストラクタは、格納されていた値のヒープを解放します。

SFXAny::Contains

指定された SFXAny インスタンスに格納されている値の型が指定された値の型と同じであるかどうかを判定します。

[ public, static ]
Bool Contains<T>(
    SFXAnyConstRef ref   // 対象となる SFXAny const 参照型
    T * param = null     // 型を判定するための値（値は何でもよい）
);

戻り値

型が一致したとき: true
そうでないとき: false

解説

この関数は、指定された SFXAny インスタンスに格納されている値の型が指定された値の型と同じであるかどうかを判定します。

使用例

型の判別

SInt32 i;
SFXAny a;

i = 5;
a = i;

TRACE("a is SInt32 ?: %d", SFXAny::Contains(a, reinterpret_cast<SInt32Ptr>(null)));
TRACE("a is UInt32 ?: %d", SFXAny::Contains(a, reinterpret_cast<UInt32Ptr>(null)));

// VC2003 以上、RVCT for BREW 3.0 以上、GNUARM 4.1 、または YAGARTO 4.4 ではこちらも使用できる
#if !((defined TARGET_COMPILER_MSVCPP &&  TARGET_COMPILER_VERSION < 1300) || (defined TARGET_COMPILER_ARMCPP && TARGET_COMPILER_VERSION < 300000))
TRACE("Is a SInt32 ?: %d", SFXAny::Contains<SInt32>(a));
TRACE("Is a UInt32 ?: %d", SFXAny::Contains<UInt32>(a));
#endif

// 結果
// a is SInt32: 1
// a is UInt32: 0
// a is SInt32: 1
// a is UInt32: 0

SFXAny::GetType

格納されている値の型情報を取得します。

[ public, const ]
SFXTypeInfo::TypeId GetType(Void);

戻り値

格納されている値の型情報。

解説

この関数は、格納されている値の型情報を取得します。

	注意
	値を保持していない場合は、null が返されます。

参照

SFXTypeInfo::TypeId

SFXAny::any_cast

格納されている値を指定された型にキャストして取得します。

T const & any_cast<T>(
    SFXAnyConstRef ref   // const 参照型
);

T & any_cast<T>(
    SFXAnyRef ref   // 参照型 [RVCT for BREW 1.2 では使用できません]
);

T const* any_cast<T>(
    SFXAnyConstPtr ptr   // const ポインタ型 [RVCT for BREW 1.2 では使用できません]
);

T * any_cast<T>(
    SFXAnyPtr ptr   // ポインタ型
);

解説

この関数は、格納されている値を指定された型にキャストして取得します。

引数に参照型が渡された場合、格納されている値の元の型に関係なく強制的にテンプレート引数に指定された型に変換されます。

一方、引数にポインタ型が渡された場合、格納されている値の元の型とテンプレート引数とが適合すれば正常に型変換され、適合しなければ null ポインタに変換されます。

引数に参照型、ポインタ型のいずれを渡す場合でも、テンプレート引数には格納されている値の型（ポインタ型、参照型の修飾子は不要）を指定します。

	RVCT for BREW 1.2 の制約
	RVCT for BREW 1.2 の場合、参照型とconst ポインタ型の引数は指定できません。

使用例

SInt32 i;
SFXAnsiString str;
SFXAny a;

i = 5;
str = "abcde";
a = i;
TRACE("a = %d", any_cast<SInt32>(a));
TRACE("&&a = %X", any_cast<SInt32>(&a));
TRACE("&&a = %X", any_cast<UInt32>(&a));
a = str;
TRACE("a = %s", any_cast<SFXAnsiString>(a).GetCString());
TRACE("&&a = %X", any_cast<SFXAnsiString>(&a));
TRACE("&&a = %X", any_cast<SFXWideString>(&a));

// [結果]
// a = 5
// &a = 4CAB524 (アドレス値は実行環境に依存)
// &a = 0
// a = abcde
// &a = 4CD1E3C (アドレス値は実行環境に依存)
// &a = 0

SFXAny::operator=

左側の SFXAny インスタンスに右側の T 型の値、もしくは SFXAny インスタンスを代入します。

[ public ]
SFXAnyRef operator=(
    T const & value   // 設定する T const 参照型の値
);

[ public ]
SFXAnyRef operator=(
    SFXAnyConstRef other   // 設定する SFXAny const 参照型の値
);

戻り値

右側の値を代入した左側の SFXAny インスタンス。

解説

このオペレータは、左側の SFXAny インスタンスに右側の T 型の値、もしくは SFXAny インスタンスを代入します。

使用例

SInt32 i;
SFXAny a;
SFXAny b;

i = 5;
a = i;
b = a;

TRACE("a = %d", any_cast<SInt32>(a));
TRACE("b = %d", any_cast<SInt32>(b));

// [結果]
// a = 5
// b = 5

参照

SFXAny::SFXAny