Value.h

Go to the documentation of this file.
00001 #ifndef __VALUE_H__
00002 #define __VALUE_H__
00003 
00004 /*
00005 
00006 $Header$
00007 
00008 */
00009 
00010 #include "Error.h"
00011 #include "String.h"
00012 #include "ValueBase.h"
00013 #include "Validator.h"
00014 #include "S11n.h"
00015 
00016 // Messages.
00017 static const char *const MSG_VALUE_TYPE_MISMATCH = "Trying to set mismatched type value.";
00018 static const char *const MSG_VALUE_STRING        = "Cannot get value of type '%s' from the string '%s'.";
00019 static const char *const MSG_VALUE_INVALID       = "Trying to assign an invalid value.";
00020 
00021 using namespace std;
00022 
00023 // Declaration.
00024 
00025 template<class T>
00026 class Value : public ValueBase
00027 {
00028 
00029 public:
00030 
00031   Value(Validator<T> *validator = NULL);
00032   Value(const T &value, Validator<T> *validator = NULL);
00033   virtual ~Value();
00034 
00035   virtual int set(const ValueBase *value);
00036   int set(const T &value);
00037   T get() const;
00038 
00039   int setValidator(Validator<T> *validator);
00040 
00041   virtual int toString(String &) const;
00042   virtual int fromString(const String &);
00043 
00044 protected:
00045 
00046   inline const T &value() const;
00047 
00048 private:
00049 
00050   T _value;
00051   Validator<T> *_validator;
00052 
00053 };
00054 
00055 typedef Value<bool> ValueBool;
00056 typedef Value<char> ValueChar;
00057 typedef Value<double> ValueDouble;
00058 typedef Value<int> ValueInt;
00059 typedef Value<Object *> ValueObject;
00060 typedef Value<void *> ValuePointer;
00061 typedef Value<String> ValueString;
00062 typedef Value<unsigned int> ValueUint;
00063 typedef Value<StringList> ValueStringList;
00064 
00065 // Implementation.
00066 
00067 template<class T>
00068 Value<T>::Value(Validator<T> *validator) : ValueBase(),
00069   _validator(validator)
00070 {
00071 }
00072 
00073 template<class T>
00074 Value<T>::Value(const T &value, Validator<T> *validator) : ValueBase(),
00075   _validator(validator)
00076 {
00077   if (_validator)
00078     if (!_validator->valid(value)) {
00079       failure(ERROR(MSG_VALUE_INVALID));
00080       return;
00081     }
00082 
00083   _value = value;
00084 }
00085 
00086 template<class T>
00087 Value<T>::~Value()
00088 {
00089 }
00090 
00091 template<class T>
00092 int Value<T>::set(const ValueBase *value)
00093 {
00094   const Value<T> *v = dynamic_cast<const Value<T>* >(value);
00095 
00096   if (!v)
00097     return ERROR(MSG_VALUE_TYPE_MISMATCH);
00098 
00099   T v1 = v->get();
00100   if (_validator)
00101     if (!_validator->valid(v1))
00102       return ERROR(MSG_VALUE_INVALID);
00103 
00104   _value = v1;
00105 
00106   return OK;
00107 }
00108 
00109 template<class T>
00110 int Value<T>::set(const T &value)
00111 {
00112   if (_validator)
00113     if (!_validator->valid(value))
00114       return ERROR(MSG_VALUE_INVALID);
00115 
00116   _value = value;
00117   return OK;
00118 }
00119 
00120 template<class T>
00121 T Value<T>::get() const
00122 {
00123   return _value;
00124 }
00125 
00126 template<class T>
00127 int Value<T>::setValidator(Validator<T> *validator)
00128 {
00129   _validator = validator;
00130   return OK;
00131 }
00132 
00133 template<class T>
00134 int Value<T>::toString(String &str) const
00135 {
00136   int res;
00137 
00138   if (FAILED(res = S11n<T>::toString(_value, str)))
00139     return ERROR_BACKTRACE(res);
00140 
00141   return OK;
00142 }
00143 
00144 template<class T>
00145 int Value<T>::fromString(const String &str)
00146 {
00147   T v;
00148   int res;
00149 
00150   if (FAILED(res = S11n<T>::fromString(str, v)))
00151     return ERROR_BACKTRACE(res);
00152   if (FAILED(res = set(v)))
00153     return ERROR_BACKTRACE(res);
00154 
00155   return OK;
00156 }
00157 
00158 // Protected methods.
00159 
00160 template<class T>
00161 inline const T &Value<T>::value() const
00162 {
00163   return _value;
00164 }
00165 
00166 #endif

Generated on Thu Sep 6 20:11:25 2007 for Pylon Application Platform by  doxygen 1.5.1