cpp-software-patterns/BaseLib/Templates/FactoryTypes.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
#ifndef BaseLib_Templates_FactoryTypes_h_Included
#define BaseLib_Templates_FactoryTypes_h_Included

#include"BaseLib/CommonDefines.h"

#include"BaseLib/Templates/BaseTypes.h"
#include"BaseLib/Templates/MethodInterfaces.h"
#include"BaseLib/Templates/Synchronization.h"
#include"BaseLib/Templates/Lifecycle.h"
#include"BaseLib/Templates/DoubleCheckedLocking.h"

namespace BaseLib { namespace Templates
{

/**
 * @brief The FactoryDisposeType class
 */
template <typename T, typename Lock = Mutex>
class FactoryDisposeType : public ComparableMutableType<T, Lock>
{
public:
    FactoryDisposeType(T &t) : ComparableMutableType<T,Lock>(t)
    {}
    virtual ~FactoryDisposeType()
    {}

    bool Dispose()  { return this->t_.Dispose(); }
    T Create()      { return this->t_.Create(); }
};

/** TODO: Introduce Factory/Builder for construction as a static
 *  - Factory factory();
 *  - Builder builder();
 */
template <typename T, typename Lock = Mutex>
class FactorySingleton
        : public StaticSingleton<T>
        , public Templates::NoCopy<T>
        , public Templates::LockableType<T, Mutex>
{
public:
    virtual ~FactorySingleton() {}

    static T& Factory()
    {
        return StaticSingleton<T>::Instance();
    }
};

template <typename T, typename Lock = Mutex>
class BuilderTypeSingleton
        : public StaticSingleton<T>
        , public Templates::NoCopy<T>
        , public Templates::LockableType<T, Mutex>
{
public:
    virtual ~BuilderTypeSingleton() {}

    static T& Builder()
    {
        return StaticSingleton<T>::Instance();
    }
};

template <typename T, typename Lock = Mutex>
class SupervisorSingleton
        : public StaticSingletonPtr<T>
        , public Templates::NoCopy<T>
        , public Templates::LockableType<T, Mutex>
        , public Templates::InitializeMethods
{
public:
    virtual ~SupervisorSingleton() {}

    static T& Supervisor()
    {
        DoubleCheckedLocking::Initialize<T>(StaticSingletonPtr<T>::InstancePtr().get());
        return StaticSingletonPtr<T>::Instance();
    }

    static std::shared_ptr<T> SupervisorPtr()
    {
        DoubleCheckedLocking::Initialize<T>(StaticSingletonPtr<T>::InstancePtr().get());
        return StaticSingletonPtr<T>::InstancePtr();
    }
};

template <typename T>
class FactoryFunction0
{
public:
    virtual ~FactoryFunction0() {}

    static T* CreatePtr()
    {
        return new T;
    }

    static std::shared_ptr<T> CreateSharedPtr()
    {
        return std::shared_ptr<T>(new T);
    }
};

template <typename T, typename Arg1>
class FactoryFunction1
{
public:
    virtual ~FactoryFunction1() {}

    static T* CreatePtr(Arg1 arg1)
    {
        return new T(arg1);
    }

    static std::shared_ptr<T> CreateSharedPtr(Arg1 arg1)
    {
        return std::shared_ptr<T>(new T(arg1));
    }
};

template <typename T, typename Arg1, typename Arg2>
class FactoryFunction2
{
public:
    virtual ~FactoryFunction2() {}

    static T* CreatePtr(Arg1 arg1, Arg2 arg2)
    {
        return new T(arg1, arg2);
    }

    static std::shared_ptr<T> CreateSharedPtr(Arg1 arg1, Arg2 arg2)
    {
        return std::shared_ptr<T>(new T(arg1, arg2));
    }
};

}}

#endif