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