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
|
/*
fuzzylite (R), a fuzzy logic control library in C++.
Copyright (C) 2010-2017 FuzzyLite Limited. All rights reserved.
Author: Juan Rada-Vilela, Ph.D. <jcrada@fuzzylite.com>
This file is part of fuzzylite.
fuzzylite is free software: you can redistribute it and/or modify it under
the terms of the FuzzyLite License included with the software.
You should have received a copy of the FuzzyLite License along with
fuzzylite. If not, see <http://www.fuzzylite.com/license/>.
fuzzylite is a registered trademark of FuzzyLite Limited.
*/
#include "fl/factory/FactoryManager.h"
namespace fl {
FactoryManager* FactoryManager::instance() {
static FL_ITHREAD_LOCAL FactoryManager _instance;
return &_instance;
}
FactoryManager::FactoryManager() :
_tnorm(new TNormFactory), _snorm(new SNormFactory), _activation(new ActivationFactory),
_defuzzifier(new DefuzzifierFactory), _term(new TermFactory),
_hedge(new HedgeFactory), _function(new FunctionFactory) { }
FactoryManager::FactoryManager(TNormFactory* tnorm, SNormFactory* snorm,
ActivationFactory* activation, DefuzzifierFactory* defuzzifier,
TermFactory* term, HedgeFactory* hedge, FunctionFactory* function) :
_tnorm(tnorm), _snorm(snorm), _activation(activation),
_defuzzifier(defuzzifier), _term(term), _hedge(hedge), _function(function) { }
FactoryManager::FactoryManager(const FactoryManager& other)
: _tnorm(fl::null), _snorm(fl::null), _activation(fl::null),
_defuzzifier(fl::null), _term(fl::null), _hedge(fl::null),
_function(fl::null) {
if (other._tnorm.get()) this->_tnorm.reset(new TNormFactory(*other._tnorm.get()));
if (other._snorm.get()) this->_snorm.reset(new SNormFactory(*other._snorm.get()));
if (other._activation.get()) this->_activation.reset(new ActivationFactory(*other._activation.get()));
if (other._defuzzifier.get()) this->_defuzzifier.reset(new DefuzzifierFactory(*other._defuzzifier.get()));
if (other._term.get()) this->_term.reset(new TermFactory(*other._term.get()));
if (other._hedge.get()) this->_hedge.reset(new HedgeFactory(*other._hedge.get()));
if (other._function.get()) this->_function.reset(new FunctionFactory(*other._function.get()));
}
FactoryManager& FactoryManager::operator=(const FactoryManager& other) {
if (this != &other) {
_tnorm.reset(fl::null);
_snorm.reset(fl::null);
_activation.reset(fl::null);
_defuzzifier.reset(fl::null);
_term.reset(fl::null);
_hedge.reset(fl::null);
_function.reset(fl::null);
if (other._tnorm.get()) this->_tnorm.reset(new TNormFactory(*other._tnorm.get()));
if (other._snorm.get()) this->_snorm.reset(new SNormFactory(*other._snorm.get()));
if (other._activation.get()) this->_activation.reset(new ActivationFactory(*other._activation.get()));
if (other._defuzzifier.get()) this->_defuzzifier.reset(new DefuzzifierFactory(*other._defuzzifier.get()));
if (other._term.get()) this->_term.reset(new TermFactory(*other._term.get()));
if (other._hedge.get()) this->_hedge.reset(new HedgeFactory(*other._hedge.get()));
if (other._function.get()) this->_function.reset(new FunctionFactory(*other._function.get()));
}
return *this;
}
FactoryManager::~FactoryManager() { }
void FactoryManager::setTnorm(TNormFactory* tnorm) {
this->_tnorm.reset(tnorm);
}
TNormFactory* FactoryManager::tnorm() const {
return this->_tnorm.get();
}
void FactoryManager::setSnorm(SNormFactory* snorm) {
this->_snorm.reset(snorm);
}
SNormFactory* FactoryManager::snorm() const {
return this->_snorm.get();
}
void FactoryManager::setActivation(ActivationFactory* activation) {
this->_activation.reset(activation);
}
ActivationFactory* FactoryManager::activation() const {
return this->_activation.get();
}
void FactoryManager::setDefuzzifier(DefuzzifierFactory* defuzzifier) {
this->_defuzzifier.reset(defuzzifier);
}
DefuzzifierFactory* FactoryManager::defuzzifier() const {
return this->_defuzzifier.get();
}
void FactoryManager::setTerm(TermFactory* term) {
this->_term.reset(term);
}
TermFactory* FactoryManager::term() const {
return this->_term.get();
}
void FactoryManager::setHedge(HedgeFactory* hedge) {
this->_hedge.reset(hedge);
}
HedgeFactory* FactoryManager::hedge() const {
return this->_hedge.get();
}
void FactoryManager::setFunction(FunctionFactory* function) {
this->_function.reset(function);
}
FunctionFactory* FactoryManager::function() const {
return this->_function.get();
}
}
|
