1 #include "Value.h"
2 
3 #include "stringutilities.h"
4 #include "mathutilities.h"
5 
6 using std::string;
7 using std::vector;
8 using namespace ProtoMol::Report;
9 
10 
11 namespace ProtoMol {
12 
13   //________________________________________________________ Value
14 
15   const Value::Undefined* Value::undefined(NULL);
16 
Value()17   Value::Value():myValue(NULL){}
~Value()18   Value::~Value(){delete myValue;}
19 
Value(const std::string & value)20   Value::Value(const std::string& value          ):myValue(new Holder<ValueTraits<std::string> >          (value)){}
Value(const char * value)21   Value::Value(const char* value                 ):myValue(new Holder<ValueTraits<std::string> >          (value)){}
Value(int value)22   Value::Value(int value                         ):myValue(new Holder<ValueTraits<int> >                  (value)){}
Value(unsigned int value)23   Value::Value(unsigned int value                ):myValue(new Holder<ValueTraits<unsigned int> >         (value)){}
Value(Real value)24   Value::Value(Real value                        ):myValue(new Holder<ValueTraits<Real> >                 (value)){}
Value(bool value)25   Value::Value(bool value                        ):myValue(new Holder<ValueTraits<bool> >                 (value)){}
Value(const Vector3D & value)26   Value::Value(const Vector3D& value             ):myValue(new Holder<ValueTraits<Vector3D> >             (value)){}
Value(const vector<Real> & value)27   Value::Value(const vector<Real>& value         ):myValue(new Holder<ValueTraits<vector<Real> > >        (value)){}
Value(const ValueType::Integrator & value)28   Value::Value(const ValueType::Integrator& value):myValue(new Holder<ValueTraits<ValueType::Integrator> >(value)){}
Value(const ValueType::Force & value)29   Value::Value(const ValueType::Force& value     ):myValue(new Holder<ValueTraits<ValueType::Force> >     (value)){}
30 
Value(const Value & other)31   Value::Value(const Value& other):myValue(other.myValue ? other.myValue->clone() : NULL){}
32 
Value(const std::string & value,const Undefined *)33   Value::Value(const std::string& value,           const Undefined*):myValue(new Holder<ValueTraits<std::string> >          (value,false)){}
Value(const char * value,const Undefined *)34   Value::Value(const char* value,                  const Undefined*):myValue(new Holder<ValueTraits<std::string> >          (value,false)){}
Value(int value,const Undefined *)35   Value::Value(int value,                          const Undefined*):myValue(new Holder<ValueTraits<int> >                  (value,false)){}
Value(unsigned int value,const Undefined *)36   Value::Value(unsigned int value,                 const Undefined*):myValue(new Holder<ValueTraits<unsigned int> >         (value,false)){}
Value(Real value,const Undefined *)37   Value::Value(Real value,                         const Undefined*):myValue(new Holder<ValueTraits<Real> >                 (value,false)){}
Value(bool value,const Undefined *)38   Value::Value(bool value,                         const Undefined*):myValue(new Holder<ValueTraits<bool> >                 (value,false)){}
Value(const Vector3D & value,const Undefined *)39   Value::Value(const Vector3D& value,              const Undefined*):myValue(new Holder<ValueTraits<Vector3D> >             (value,false)){}
Value(const vector<Real> & value,const Undefined *)40   Value::Value(const vector<Real>& value,          const Undefined*):myValue(new Holder<ValueTraits<vector<Real> > >        (value,false)){}
Value(const ValueType::Integrator & value,const Undefined *)41   Value::Value(const ValueType::Integrator& value, const Undefined*):myValue(new Holder<ValueTraits<ValueType::Integrator> >(value,false)){}
Value(const ValueType::Force & value,const Undefined *)42   Value::Value(const ValueType::Force& value,      const Undefined*):myValue(new Holder<ValueTraits<ValueType::Force> >     (value,false)){}
43 
Value(const Value & value,const Undefined *)44   Value::Value(const Value& value, const Undefined*):myValue(value.myValue ? value.myValue->clone() : NULL){clear();}
45 
operator =(const Value & rhs)46   Value & Value::operator=(const Value & rhs) {
47     Value(rhs).swap(*this);
48     return *this;
49   }
50 
operator std::string() const51   Value::operator std::string() const {
52     std::string val;
53     if(myValue != NULL)
54       myValue->get(val);
55     return val;
56   }
57 
operator int() const58   Value::operator int() const {
59     int val=0;
60     if(myValue != NULL)
61       myValue->get(val);
62     return val;
63   }
64 
operator unsigned int() const65   Value::operator unsigned int() const {
66     unsigned int val=0;
67     if(myValue != NULL)
68       myValue->get(val);
69     return val;
70   }
71 
operator Real() const72   Value::operator Real() const {
73     Real val=0.0;
74     if(myValue != NULL)
75       myValue->get(val);
76     return val;
77   }
78 
operator bool() const79   Value::operator bool() const {
80     bool val=false;
81     if(myValue != NULL)
82       myValue->get(val);
83     return val;
84   }
85 
operator Vector3D() const86   Value::operator Vector3D() const {
87     Vector3D val(0.0,0.0,0.0);
88     if(myValue != NULL)
89       myValue->get(val);
90     return val;
91   }
92 
operator vector<Real>() const93   Value::operator vector<Real>() const {
94     vector<Real> val;
95     if(myValue != NULL)
96       myValue->get(val);
97     return val;
98   }
99 
getString() const100   string Value::getString() const {
101     string tmp("");
102     if(myValue){
103       myValue->get(tmp);
104     }
105     return tmp;
106   }
107 
getDefinitionTypeString() const108   string Value::getDefinitionTypeString() const{
109     string res("<");
110     res +=getTypeString();
111     if(valid())
112       res += "="+getString();
113     if(getConstraintType() != ConstraintValueType::NOCONSTRAINTS && getConstraintType() != ConstraintValueType::UNDEFINED)
114       res += ","+getConstraintTypeString();
115     res +=">";
116     return res;
117   }
118 
set(Value v)119   bool  Value::set(Value v){
120     if(defined()){
121       myValue->set(v);
122     }
123     else {
124       Value(v).swap(*this);
125     }
126     return valid();
127   }
128 
swap(Value & rhs)129   Value & Value::swap(Value & rhs){
130     std::swap(myValue, rhs.myValue);
131     return *this;
132   }
133 
debug() const134   string Value::debug() const {
135     return getString()+","+(valid()?"true":"false")+","+getTypeString() +","+getConstraintTypeString();
136   }
137 
read(std::istream & is)138   void Value::read(std::istream& is){
139     if(defined()){
140       myValue->read(is);
141     }
142     else {
143       string str;
144       is >> str;
145       set(str);
146     }
147   }
148 
149   template<typename T>
equal(const Value & v1,const Value & v2)150   inline bool Value::equal(const Value& v1, const Value& v2){
151     T u1,u2;
152     if(v1.get(u1) && v2.get(u2)){
153       return u1 == u2;
154     }
155     return false;
156   }
157 
158   template<typename T>
less(const Value & v1,const Value & v2)159   inline bool Value::less(const Value& v1, const Value& v2){
160     T u1,u2;
161     if(v1.get(u1) && v2.get(u2)){
162       return (u1 < u2);
163     }
164     return false;
165   }
166 
167   template<typename T>
lessEqual(const Value & v1,const Value & v2)168   inline bool Value::lessEqual(const Value& v1, const Value& v2){
169     T u1,u2;
170     if(v1.get(u1) && v2.get(u2)){
171       return u1 <= u2;
172     }
173     return false;
174   }
175 
176   template<typename T>
greater(const Value & v1,const Value & v2)177   inline bool Value::greater(const Value& v1, const Value& v2){
178     T u1,u2;
179     if(v1.get(u1) && v2.get(u2)){
180       return u1 < u2;
181     }
182     return false;
183   }
184 
185   template<typename T>
greaterEqual(const Value & v1,const Value & v2)186   inline bool Value::greaterEqual(const Value& v1, const Value& v2){
187     T u1,u2;
188     if(v1.get(u1) && v2.get(u2)){
189       return u1 <= u2;
190     }
191     return false;
192   }
193 
194 
195   template<typename T>
equalType(const Value & v1,const Value & v2)196   inline bool Value::equalType(const Value& v1, const Value& v2){
197     T u1,u2;
198     return v1.get(u1) && v2.get(u2) && (v1.getType() == (ValueType::Enum)ValueTraits<T>::value || v2.getType() == (ValueType::Enum)ValueTraits<T>::value);
199   }
200 
201 
202   template<>
greaterEqual(const Value &,const Value &)203   inline bool Value::greaterEqual<Vector3D>(const Value&, const Value&){return false;}
204 
205   template<>
greater(const Value &,const Value &)206   inline bool Value::greater<Vector3D>(const Value&, const Value&){return false;}
207 
208   template<>
less(const Value &,const Value &)209   inline bool Value::less<Vector3D>(const Value&, const Value&){return false;}
210 
211   template<>
lessEqual(const Value &,const Value &)212   inline bool Value::lessEqual<Vector3D>(const Value&, const Value&){return false;}
213 
214 
215   template<>
greaterEqual(const Value &,const Value &)216   inline bool Value::greaterEqual<vector<Real> >(const Value&, const Value&){return false;}
217 
218   template<>
greater(const Value &,const Value &)219   inline bool Value::greater<vector<Real> >(const Value&, const Value&){return false;}
220 
221   template<>
less(const Value &,const Value &)222   inline bool Value::less<vector<Real> >(const Value&, const Value&){return false;}
223 
224   template<>
lessEqual(const Value &,const Value &)225   inline bool Value::lessEqual<vector<Real> >(const Value&, const Value&){return false;}
226 
227 
operator ==(const Value & v1,const Value & v2)228   bool operator==(const Value& v1, const Value& v2){
229     if(!v1.defined() && !v2.defined())
230       return true;
231     if(v1.valid() != v2.valid())
232       return false;
233     else if(!v1.valid())
234       return true;
235 
236     if(Value::equalType<Vector3D>(v1,v2))
237       return Value::equal<Vector3D>(v1,v2);
238     else if(Value::equalType<Real>(v1,v2))
239       return Value::equal<Real>(v1,v2);
240     else if(Value::equalType<int>(v1,v2))
241       return Value::equal<int>(v1,v2);
242     else if(Value::equalType<unsigned int>(v1,v2))
243       return Value::equal<unsigned int>(v1,v2);
244     else if(Value::equalType<bool>(v1,v2))
245       return Value::equal<bool>(v1,v2);
246 
247     return v1.getString() == v2.getString();
248   }
249 
operator <(const Value & v1,const Value & v2)250   bool operator<(const Value& v1, const Value& v2){
251     if(!v1.defined() && !v2.defined())
252       return true;
253     if(v1.valid() != v2.valid())
254       return false;
255     else if(!v1.valid())
256       return true;
257 
258     if(Value::equalType<Vector3D>(v1,v2))
259       return Value::less<Vector3D>(v1,v2);
260     else if(Value::equalType<Real>(v1,v2))
261       return Value::less<Real>(v1,v2);
262     else if(Value::equalType<int>(v1,v2))
263       return Value::less<int>(v1,v2);
264     else if(Value::equalType<unsigned int>(v1,v2))
265       return Value::less<unsigned int>(v1,v2);
266     else if(Value::equalType<bool>(v1,v2))
267       return Value::less<bool>(v1,v2);
268 
269     return v1.getString() < v2.getString();
270   }
271 
operator <=(const Value & v1,const Value & v2)272   bool operator<=(const Value& v1, const Value& v2){
273     if(!v1.defined() && !v2.defined())
274       return true;
275     if(v1.valid() != v2.valid())
276       return false;
277     else if(!v1.valid())
278       return true;
279 
280     if(Value::equalType<Vector3D>(v1,v2))
281       return Value::lessEqual<Vector3D>(v1,v2);
282     else if(Value::equalType<Real>(v1,v2))
283       return Value::lessEqual<Real>(v1,v2);
284     else if(Value::equalType<int>(v1,v2))
285       return Value::lessEqual<int>(v1,v2);
286     else if(Value::equalType<unsigned int>(v1,v2))
287       return Value::lessEqual<unsigned int>(v1,v2);
288     else if(Value::equalType<bool>(v1,v2))
289       return Value::lessEqual<bool>(v1,v2);
290 
291     return v1.getString() <= v2.getString();
292   }
293 
operator >(const Value & v1,const Value & v2)294   bool operator>(const Value& v1, const Value& v2){
295     if(!v1.defined() && !v2.defined())
296       return true;
297     if(v1.valid() != v2.valid())
298       return false;
299     else if(!v1.valid())
300       return true;
301 
302     if(Value::equalType<Vector3D>(v1,v2))
303       return Value::greater<Vector3D>(v1,v2);
304     else if(Value::equalType<Real>(v1,v2))
305       return Value::greater<Real>(v1,v2);
306     else if(Value::equalType<int>(v1,v2))
307       return Value::greater<int>(v1,v2);
308     else if(Value::equalType<unsigned int>(v1,v2))
309       return Value::greater<unsigned int>(v1,v2);
310     else if(Value::equalType<bool>(v1,v2))
311       return Value::greater<bool>(v1,v2);
312 
313     return v1.getString() > v2.getString();
314   }
315 
operator >=(const Value & v1,const Value & v2)316   bool operator>=(const Value& v1, const Value& v2){
317     if(!v1.defined() && !v2.defined())
318       return true;
319     if(v1.valid() != v2.valid())
320       return false;
321     else if(!v1.valid())
322       return true;
323 
324     if(Value::equalType<Vector3D>(v1,v2))
325       return Value::greaterEqual<Vector3D>(v1,v2);
326     else if(Value::equalType<Real>(v1,v2))
327       return Value::greaterEqual<Real>(v1,v2);
328     else if(Value::equalType<int>(v1,v2))
329       return Value::greaterEqual<int>(v1,v2);
330     else if(Value::equalType<unsigned int>(v1,v2))
331       return Value::greaterEqual<unsigned int>(v1,v2);
332     else if(Value::equalType<bool>(v1,v2))
333       return Value::greaterEqual<bool>(v1,v2);
334 
335     return v1.getString() >= v2.getString();
336   }
337 
operator <<(MyStreamer & OS,const Value & v)338   MyStreamer& operator<< (MyStreamer& OS, const Value & v) {
339     OS << v.getString();
340     return OS;
341   }
342 
343 }
344