Kisaragi_Lib::Accessor< T > クラステンプレート

public空間に置くことで,T*のAccessorを提供します [詳解]

#include <Accessor.hpp>

公開メンバ関数
	Accessor (T *_variable)
T *	operator-> ()
	operator T () const
template<typename U = T>
std::enable_if< std::is_arithmetic< U >::value, U >::type	operator+ (U _plus) const
template<typename U = T>
std::enable_if< if_subtraction< U >::value, U >::type	operator- (U _index) const
template<typename U = T>
std::enable_if< if_multiplication< U >::value, U >::type	operator* (U _index) const
template<typename U = T>
std::enable_if< if_division< U >::value, U >::type	operator/ (U _index) const
template<typename U = T>
std::enable_if< if_remainder< U >::value, U >::type	operator% (U _index) const
void	operator= (T _set)
template<typename U = T>
std::enable_if< std::is_arithmetic< U >::value, void >::type	operator+= (T _index)
template<typename U = T>
std::enable_if< if_subtraction< U >::value, void >::type	operator-= (U _index)
template<typename U = T>
std::enable_if< if_multiplication< U >::value, void >::type	operator*= (U _index)
template<typename U = T>
std::enable_if< if_division< U >::value, void >::type	operator/= (U _index)
template<typename U = T>
std::enable_if< if_remainder< U >::value, void >::type	operator%= (U _index)

限定公開変数類
ReadOnly< T >	readOnly
WriteOnly< T >	writeOnly

詳解

template<class T>
class Kisaragi_Lib::Accessor< T >

public空間に置くことで,T*のAccessorを提供します

テンプレート引数

T	Accessorの型

構築子と解体子

Accessor()

template<class T>

Kisaragi_Lib::Accessor< T >::Accessor ( T * _variable )

inline

: readOnly(_variable),writeOnly(_variable){}

関数詳解

operator->()

template<class T>

T * Kisaragi_Lib::Accessor< T >::operator-> ( )

inline

        {
            return writeOnly.operator->();
        }

operator T()

template<class T>

Kisaragi_Lib::Accessor< T >::operator T ( ) const

inline

        {
            //多分暗黙的に変換されるはず...
            return readOnly.operator T();
        }

operator+()

template<class T>

template<typename U = T>

std::enable_if< std::is_arithmetic< U >::value, U >::type Kisaragi_Lib::Accessor< T >::operator+ ( U _plus ) const

inline

        {
            return readOnly.operator+(_plus);
        }

operator-()

template<class T>

template<typename U = T>

std::enable_if< if_subtraction< U >::value, U >::type Kisaragi_Lib::Accessor< T >::operator- ( U _index ) const

inline

        {
            return readOnly.operator- (_index);
        }

operator*()

template<class T>

template<typename U = T>

std::enable_if< if_multiplication< U >::value, U >::type Kisaragi_Lib::Accessor< T >::operator* ( U _index ) const

inline

        {
            return readOnly.operator* (_index);
        }

operator/()

template<class T>

template<typename U = T>

std::enable_if< if_division< U >::value, U >::type Kisaragi_Lib::Accessor< T >::operator/ ( U _index ) const

inline

        {
            return readOnly.operator/ (_index);
        }

operator%()

template<class T>

template<typename U = T>

std::enable_if< if_remainder< U >::value, U >::type Kisaragi_Lib::Accessor< T >::operator% ( U _index ) const

inline

        {
            return readOnly.operator% (_index);
        }

operator=()

template<class T>

void Kisaragi_Lib::Accessor< T >::operator= ( T _set )

inline

        {
            writeOnly.operator= (_set);
        }

operator+=()

template<class T>

template<typename U = T>

std::enable_if< std::is_arithmetic< U >::value, void >::type Kisaragi_Lib::Accessor< T >::operator+= ( T _index )

inline

        {
            writeOnly.operator+= (_index);
        }

operator-=()

template<class T>

template<typename U = T>

std::enable_if< if_subtraction< U >::value, void >::type Kisaragi_Lib::Accessor< T >::operator-= ( U _index )

inline

        {
            writeOnly.operator-= (_index);
        }

operator*=()

template<class T>

template<typename U = T>

std::enable_if< if_multiplication< U >::value, void >::type Kisaragi_Lib::Accessor< T >::operator*= ( U _index )

inline

        {
            writeOnly.operator*= (_index);
        }

operator/=()

template<class T>

template<typename U = T>

std::enable_if< if_division< U >::value, void >::type Kisaragi_Lib::Accessor< T >::operator/= ( U _index )

inline

        {
            writeOnly.operator/= (_index);
        }

operator%=()

template<class T>

template<typename U = T>

std::enable_if< if_remainder< U >::value, void >::type Kisaragi_Lib::Accessor< T >::operator%= ( U _index )

inline

        {
            writeOnly.operator%= (_index);
        }

メンバ詳解

readOnly

template<class T>

ReadOnly<T> Kisaragi_Lib::Accessor< T >::readOnly

protected

参照元 Accessor(), operator%(), operator*(), operator+(), operator-(), operator/().

writeOnly

template<class T>

WriteOnly<T> Kisaragi_Lib::Accessor< T >::writeOnly

protected

参照元 Accessor(), operator%=(), operator*=(), operator+=(), operator-=(), operator->(), operator/=(), operator=().

---

このクラス詳解は次のファイルから抽出されました:

• Accessor.hpp