Accessor.hpp

[詳解]

#pragma once
 
 
#include <functional>
#include <type_traits>
#include <utility>
 
//TODO Accessor
//・インクリメント/デクリメント対応
//・ReadOnlyに関数を使えるvarの追加or変更
 
 
 
/*
*   CustomAccessorの使い方
*
*   CustomAccessorとCustomWriteOnlyは自分でセッタを定義できますが、
*   その代わりにコンストラクタで関数を渡す必要があります。
*   以下はその一例になります。
*/
 
/*
*   1. メンバ以外の関数または、静的なメンバ関数を渡す
*   int test (int _set)
*   {
*       int tmp = _set;
*       if(tmp > 10){ tmp = 10; }
*       return tmp;
*   }
*   int aa = 10;
*   CustomWriteOnly<int> bb(&aa, test);
*/
 
/*
*   2.メンバ関数を渡す
*   class hoge
*   {
*      private:
*       double Func(double _set);
*       double aa;
*      public:
*       CustomWriteOnly<double> bb(&aa, [this](double _set){ Func(_set); } );
*   }
*/
 
/*
*   3.ラムダ式を渡す
*   CustomWriteOnly<float> bb(&aa, [](float _set){ return _set + 10; } );
*/
 
 
 
namespace
{
    using std::function;
 
    // declval オブジェクトを生成しないで型を評価する
    // decltype 引数の結果が有効なら結果の型を返す。有効ならvoid_tが起動する
    // void_t 引数が有効ならならvoidを返す 失敗ならエラーが発生。
    // SFINAE は、テンプレートの特殊化が失敗した場合にコンパイルエラーを発生させず、
    // 代わりに他のテンプレートを選択できるようにします
    // 成功した場合は trueを継承 失敗ならば他tmplateの falseを継承 したobjになる。
 
    // 演算子+ はstd::内に使えるのがあったので省略
 
#pragma region - 演算子用
    // 演算子-が使えない場合はこちらが使われる
    template <typename T, typename = void>
    struct if_subtraction : std::false_type {};
 
    // 演算子-が使える場合こちらになる
    template <typename T>
    struct if_subtraction<T, std::void_t<decltype(std::declval<T>() - std::declval<T>())>> : std::true_type {};
#pragma endregion
 
#pragma region * 演算子用
    // 演算子-が使えない場合はこちらが使われる
    template <typename T, typename = void>
    struct if_multiplication : std::false_type {};
 
    // 演算子-が使える場合こちらになる
    template <typename T>
    struct if_multiplication<T, std::void_t<decltype(std::declval<T>()* std::declval<T>())>> : std::true_type {};
#pragma endregion
 
#pragma region / 演算子用
    // 演算子-が使えない場合はこちらが使われる
    template <typename T, typename = void>
    struct if_division : std::false_type {};
 
    // 演算子-が使える場合こちらになる
    template <typename T>
    struct if_division<T, std::void_t<decltype(std::declval<T>() / std::declval<T>())>> : std::true_type {};
#pragma endregion
 
#pragma region % 演算子用
    // 演算子-が使えない場合はこちらが使われる
    template <typename T, typename = void>
    struct if_remainder : std::false_type {};
 
    // 演算子-が使える場合こちらになる
    template <typename T>
    struct if_remainder<T, std::void_t<decltype(std::declval<T>() % std::declval<T>())>> : std::true_type {};
#pragma endregion
 
 
}
 
namespace Kisaragi_Lib
{
    /// <summary>
    /// public空間に置くことで,T*のSetterを提供します
    /// </summary>
    /// <typeparam name="T">Setterの型</typeparam>
    template <class T>
    class ReadOnly 
    {
    protected:
        T* variable;  // 基底クラスの変数をスコープに持ち込む
 
    public:
        ReadOnly(T* _variable)
        {
            variable = _variable;
        }
 
#pragma region Getter
        //Getter
        operator T() const
        {
            return *variable;
        }
 
        //メンバ選択演算子
        const T* operator->() const
        {
            return variable;
        }
#pragma endregion
 
        //TODO インクリメント2種 デクリメント2種
#pragma region 算術演算子
        //enabele_ifの引数がfalseならコンパイルされない、詳しくはSFINAE
 
        //算術型 + がオーバーロードされている型なら
        //typename std::enable_if<条件,戻り値の型>::type
        template<typename U = T>    //明示的にtemplateであることを宣言しないとエラーが発生しました。
        typename std::enable_if<std::is_arithmetic<U>::value, U>::type
            operator +(U _plus) const
        {
            return *variable + _plus;
        }
 
        //ロジックはif_subtractionを参照
        template<typename U = T>    //明示的にtemplateであることを宣言しないとエラーが発生しました。
        typename std::enable_if<if_subtraction<U>::value, U>::type
            operator -(U _index) const
        {
            return *variable - _index;
        }
 
        template<typename U = T>
        typename std::enable_if<if_multiplication<U>::value, U>::type
            operator *(U _index) const
        {
            return *variable * _index;
        }
 
        template<typename U = T>
        typename std::enable_if<if_division<U>::value, U>::type
            operator /(U _index) const
        {
            return *variable / _index;
        }
 
        template<typename U = T>
        typename std::enable_if<if_remainder<U>::value, U>::type
            operator %(U _index) const
        {
            return *variable % _index;
        }
 
#pragma endregion
 
 
 
    };
 
    /// <summary>
    /// public空間に置くことで,T*のGetterを提供します
    /// </summary>
    /// <typeparam name="T">Getterの型</typeparam>
    template <class T>
    class WriteOnly 
    {
    protected:
        T* variable;  // 基底クラスの変数をスコープに持ち込む
 
    public:
        WriteOnly(T* _variable)
        {
            variable = _variable;
        }
 
#pragma region  Setter
        //Setter
        void operator = (T _set)
        {
            *variable = _set;
        }
 
        //TODO 要素のGetは可能になる
        //要素の変更を許す 
        T* operator -> ()
        {
            return variable ;
        }
#pragma endregion
 
 
#pragma region 算術 =
        template<typename U = T>
        typename std::enable_if<std::is_arithmetic<U>::value, void>::type
            operator += (T _index)
        {
            *this = *variable + _index;
        }
 
        template<typename U = T>    //明示的にtemplateであることを宣言しないとエラーが発生しました。
        typename std::enable_if<if_subtraction<U>::value, void>::type
            operator -=(U _index)
        {
            *this = *variable - _index;
        }
 
        template<typename U = T>
        typename std::enable_if<if_multiplication<U>::value, void>::type
            operator *=(U _index)
        {
            *this = *variable * _index;
        }
 
        template<typename U = T>
        typename std::enable_if<if_division<U>::value, void>::type
            operator /=(U _index)
        {
            *this = *variable / _index;
        }
 
        template<typename U = T>
        typename std::enable_if<if_remainder<U>::value, void>::type
            operator %=(U _index)
        {
            *this = *variable % _index;
        }
#pragma endregion
 
 
    };
 
    /// <summary>
    /// public空間に置くことで,T*のAccessorを提供します
    /// </summary>
    /// <typeparam name="T">Accessorの型</typeparam>
    template<class T>
    class Accessor  
    {
    protected:
        ReadOnly<T> readOnly;
        WriteOnly<T> writeOnly;
 
    public:
        Accessor(T* _variable) : readOnly(_variable),writeOnly(_variable){}
 
#pragma region 要素アクセス子
        T* operator -> ()
        {
            return writeOnly.operator->();
        }
#pragma endregion
 
#pragma region Getter
        //Getter
        operator T() const
        {
            //多分暗黙的に変換されるはず...
            return readOnly.operator T();
        }
#pragma endregion
 
        //TODO インクリメント2種 デクリメント2種
#pragma region 算術演算子
        //enabele_ifの引数がfalseならコンパイルされない、詳しくはSFINAE
 
        //算術型 + がオーバーロードされている型なら
        //typename std::enable_if<条件,戻り値の型>::type
        template<typename U = T>    //明示的にtemplateであることを宣言しないとエラーが発生しました。
        typename std::enable_if<std::is_arithmetic<U>::value, U>::type
            operator +(U _plus) const
        {
            return readOnly.operator+(_plus);
        }
 
        //ロジックはif_subtractionを参照
        template<typename U = T>    //明示的にtemplateであることを宣言しないとエラーが発生しました。
        typename std::enable_if<if_subtraction<U>::value, U>::type
            operator -(U _index) const
        {
            return readOnly.operator- (_index);
        }
 
        template<typename U = T>
        typename std::enable_if<if_multiplication<U>::value, U>::type
            operator *(U _index) const
        {
            return readOnly.operator* (_index);
        }
 
        template<typename U = T>
        typename std::enable_if<if_division<U>::value, U>::type
            operator /(U _index) const
        {
            return readOnly.operator/ (_index);
        }
 
        template<typename U = T>
        typename std::enable_if<if_remainder<U>::value, U>::type
            operator %(U _index) const
        {
            return readOnly.operator% (_index);
        }
 
#pragma endregion
 
#pragma region  Setter
        //Setter
        void operator = (T _set)
        {
            writeOnly.operator= (_set);
        }
#pragma endregion
 
 
#pragma region 算術 =
        template<typename U = T>
        typename std::enable_if<std::is_arithmetic<U>::value, void>::type
            operator += (T _index)
        {
            writeOnly.operator+= (_index);
        }
 
        template<typename U = T>    //明示的にtemplateであることを宣言しないとエラーが発生しました。
        typename std::enable_if<if_subtraction<U>::value, void>::type
            operator -=(U _index)
        {
            writeOnly.operator-= (_index);
        }
 
        template<typename U = T>
        typename std::enable_if<if_multiplication<U>::value, void>::type
            operator *=(U _index)
        {
            writeOnly.operator*= (_index);
        }
 
        template<typename U = T>
        typename std::enable_if<if_division<U>::value, void>::type
            operator /=(U _index)
        {
            writeOnly.operator/= (_index);
        }
 
        template<typename U = T>
        typename std::enable_if<if_remainder<U>::value, void>::type
            operator %=(U _index)
        {
            writeOnly.operator%= (_index);
        }
#pragma endregion
 
    };
 
    /// <summary>
    /// public空間に置くことで,自らが定義したT*のSetterを提供します
    /// </summary>
    /// <typeparam name="T">Setterの型</typeparam>
    template <class T>
    class CustomWriteOnly
    {
    private:
        T* variable;
        function<T(T)> SetFunc;
    public:
        /// <summary>
        /// コンストラクタ
        /// </summary>
        /// <param name="_variable">Accessorがほしい変数</param>
        /// <param name="_setFunc">セッタの代入の代わりに行う関数</param>
        CustomWriteOnly(T* _variable, function<T(T)> _setFunc) : variable(_variable)
        {
            SetFunc = _setFunc;
        }
 
        void operator = (T _set)
        {
            *variable = SetFunc(_set);
        }
 
 
        //TODO 要素のGetは可能になる
        //要素の変更を許す 
        T* operator -> ()
        {
            return variable;
        }
 
 
#pragma region 算術 =
        template<typename U = T>
        typename std::enable_if<std::is_arithmetic<U>::value, void>::type
            operator += (T _index)
        {
            *this = *variable + _index;
        }
 
        template<typename U = T>    //明示的にtemplateであることを宣言しないとエラーが発生しました。
        typename std::enable_if<if_subtraction<U>::value, void>::type
            operator -=(U _index)
        {
            *this = *variable - _index;
        }
 
        template<typename U = T>
        typename std::enable_if<if_multiplication<U>::value, void>::type
            operator *=(U _index)
        {
            *this = *variable * _index;
        }
 
        template<typename U = T>
        typename std::enable_if<if_division<U>::value, void>::type
            operator /=(U _index)
        {
            *this = *variable / _index;
        }
 
        template<typename U = T>
        typename std::enable_if<if_remainder<U>::value, void>::type
            operator %=(U _index)
        {
            *this = *variable % _index;
        }
#pragma endregion
    };
 
    /// <summary>
    /// public空間に置くことで,T*のAccessorを提供します,
    /// 自らがSetterを定義します
    /// </summary>
    /// <typeparam name="T">Accessorの型</typeparam>
    template <class T>
    class CustomAccessor
    {
    private:
    protected:
        ReadOnly<T> readOnly;
        CustomWriteOnly<T> writeOnly;
    public:
        /// <summary>
        /// コンストラクタ
        /// </summary>
        /// <param name="_variable">Accessorがほしい変数</param>
        /// <param name="_setFunc">セッタの代入の代わりに行う関数</param>
        CustomAccessor(T* _variable, function<T(T)> _setFunc) : readOnly(_variable), writeOnly(_variable, _setFunc) {}
 
 
#pragma region 要素アクセス子
        T* operator -> ()
        {
            return writeOnly.operator->();
        }
#pragma endregion
 
#pragma region Getter
        //Getter
        operator T() const
        {
            //多分暗黙的に変換されるはず...
            return readOnly.operator T();
        }
#pragma endregion
 
        //TODO インクリメント2種 デクリメント2種
#pragma region 算術演算子
        //enabele_ifの引数がfalseならコンパイルされない、詳しくはSFINAE
 
        //算術型 + がオーバーロードされている型なら
        //typename std::enable_if<条件,戻り値の型>::type
        template<typename U = T>    //明示的にtemplateであることを宣言しないとエラーが発生しました。
        typename std::enable_if<std::is_arithmetic<U>::value, U>::type
            operator +(U _plus) const
        {
            return readOnly.operator+(_plus);
        }
 
        //ロジックはif_subtractionを参照
        template<typename U = T>    //明示的にtemplateであることを宣言しないとエラーが発生しました。
        typename std::enable_if<if_subtraction<U>::value, U>::type
            operator -(U _index) const
        {
            return readOnly.operator- (_index);
        }
 
        template<typename U = T>
        typename std::enable_if<if_multiplication<U>::value, U>::type
            operator *(U _index) const
        {
            return readOnly.operator* (_index);
        }
 
        template<typename U = T>
        typename std::enable_if<if_division<U>::value, U>::type
            operator /(U _index) const
        {
            return readOnly.operator/ (_index);
        }
 
        template<typename U = T>
        typename std::enable_if<if_remainder<U>::value, U>::type
            operator %(U _index) const
        {
            return readOnly.operator% (_index);
        }
 
#pragma endregion
 
#pragma region  Setter
        //Setter
        void operator = (T _set)
        {
            writeOnly.operator= (_set);
        }
#pragma endregion
 
 
#pragma region 算術 =
        template<typename U = T>
        typename std::enable_if<std::is_arithmetic<U>::value, void>::type
            operator += (T _index)
        {
            writeOnly.operator+= (_index);
        }
 
        template<typename U = T>    //明示的にtemplateであることを宣言しないとエラーが発生しました。
        typename std::enable_if<if_subtraction<U>::value, void>::type
            operator -=(U _index)
        {
            writeOnly.operator-= (_index);
        }
 
        template<typename U = T>
        typename std::enable_if<if_multiplication<U>::value, void>::type
            operator *=(U _index)
        {
            writeOnly.operator*= (_index);
        }
 
        template<typename U = T>
        typename std::enable_if<if_division<U>::value, void>::type
            operator /=(U _index)
        {
            writeOnly.operator/= (_index);
        }
 
        template<typename U = T>
        typename std::enable_if<if_remainder<U>::value, void>::type
            operator %=(U _index)
        {
            writeOnly.operator%= (_index);
        }
#pragma endregion
 
    };
}