cpp-software-patterns/BaseLib/Templates/TranslatorValidatorMethods.h at master · intact-software-systems/cpp-software-patterns · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
#ifndef BaseLib_Templates_TranslatorValidatorMethods_h_Included
#define BaseLib_Templates_TranslatorValidatorMethods_h_Included

#include"BaseLib/CommonDefines.h"
#include"BaseLib/Templates/StrategyMethods.h"

namespace BaseLib
{
namespace Templates
{

// --------------------------------------------
// Validation methods
// --------------------------------------------

template <typename Return>
class IsValidMethod
{
public:
    virtual ~IsValidMethod()
    { }

    virtual Return IsValid() const = 0;
};

template <typename Return>
class IsValidatedMethod
{
public:
    virtual ~IsValidatedMethod()
    { }

    virtual Return IsValidated() const = 0;
};

template <typename Return>
class ValidateMethod
{
public:
    virtual ~ValidateMethod()
    { }

    virtual Return Validate() const = 0;
};

template <typename Return>
class PreValidateMethod
{
public:
    virtual ~PreValidateMethod()
    { }

    virtual Return PreValidate() const = 0;
};

template <typename Return>
class PostValidateMethod
{
public:
    virtual ~PostValidateMethod()
    { }

    virtual Return PostValidate() const = 0;
};

// --------------------------------------------
// Translation methods
// --------------------------------------------

template <typename Return>
class TranslateMethod
{
public:
    virtual ~TranslateMethod()
    { }

    virtual Return Translate() const = 0;
};


// --------------------------------------------
// TranslatorTranslator methods
// --------------------------------------------


template <typename T, typename K>
class TranslatorValidator : public TranslateMethod<T>, ValidateMethod<K>
{
public:
    template <typename Arg1>
    TranslatorValidator(std::shared_ptr<StrategyConst1<T, Arg1>> translate,
                        std::shared_ptr<StrategyConst1<K, Arg1>> validate,
                        const Arg1& arg1)
        : translate_(new StrategyConst1Invoker<T, Arg1>(translate, arg1))
        , validate_(new StrategyConst1Invoker<T, Arg1>(validate, arg1))
    { }

    template <typename Arg1, typename Arg2>
    TranslatorValidator(std::shared_ptr<StrategyConst2<T, Arg1, Arg2>> translate,
                        std::shared_ptr<StrategyConst2<K, Arg1, Arg2>> validate,
                        const Arg1& arg1,
                        const Arg2& arg2)
        : translate_(new StrategyConst2Invoker<T, Arg1, Arg2>(translate, arg1, arg2))
        , validate_(new StrategyConst2Invoker<K, Arg1, Arg2>(validate, arg1, arg2))
    { }

//    template <typename Arg1>
//    TranslatorValidator(std::function<T (Arg1)> translate,
//                        std::function<K (Arg1)> validate,
//                        const Arg1& arg1)
//        : translate_(new StrategyConst1Invoker(translate, arg1))
//        , validate_(new StrategyConst1Invoker(validate, arg1))
//    { }
//
//    template <typename Arg1, typename Arg2>
//    TranslatorValidator(std::function<T (Arg1, Arg2)> translate,
//                        std::function<K (Arg1, Arg2)> validate,
//                        const Arg1& arg1,
//                        const Arg2& arg2)
//        : translateFun_(translate)
//        , validateFun_(validate)
//    {
//        std::mem_fn(translate);
//    }

    virtual T Translate() const
    {
        translate_->Perform();
    }

    virtual K Validate() const
    {
        validate_->Perform();
    }

private:
    std::shared_ptr<Strategy0<T>> translate_;
    std::shared_ptr<Strategy0<K>> validate_;

//    auto translateFun_;
//    auto validateFun_;
};

}}

#endif