Tekkotsu Homepage

Demos

Overview

Downloads

Dev. Resources

Reference

Credits

plistPrimitives.h Go to the documentation of this file. //-*-c++-*- #ifndef INCLUDED_plistPrimitives_h_ #define INCLUDED_plistPrimitives_h_ #include "plistBase.h" #include <map> extern "C" { //!@name libxml2 forward declarations //!forward declaration of the libxml2 struct of the same name xmlNode* xmlAddPrevSibling(xmlNode* node, xmlNode* sibling); xmlNode* xmlNewText(const xmlChar* s); xmlNode* xmlNewComment(const xmlChar* s); xmlNode* xmlAddChild(xmlNode * parent, xmlNode* child); xmlNode* xmlNewChild(xmlNode* parent, xmlNs* ns, const xmlChar * name, const xmlChar * content); int xmlStrEqual(const xmlChar* a, const xmlChar* b); xmlChar* xmlNodeGetContent(xmlNode* node); void xmlNodeSetContent(xmlNode* node, const xmlChar* content); xmlAttr* xmlHasProperty(xmlNode* node, const xmlChar* name); xmlChar* xmlGetProperty(xmlNode* node, const xmlChar* name); long xmlGetLineNo(xmlNode* node); extern void (*xmlFree)(void* ptr); void xmlNodeSetName(xmlNode* node, const xmlChar* name); void xmlFreeNode(xmlNode* node); void xmlUnlinkNode(xmlNode* node); //@} } namespace plist { //! returns a string indicating the plist entry type to use for the specified type /*! some primitives (bool, char) aren't handled because they require a specialization * of Primitive and won't use this function. If you want to use a plist Primitive of * some custom type, you might be able to just define a new specialization of * this function and provide iostream <</>> operators for your type... */ template<typename T> const char* getTypeName(); /// @cond INTERNAL template<> inline const char* getTypeName<short>() { return "integer"; } template<> inline const char* getTypeName<unsigned short>() { return "integer"; } template<> inline const char* getTypeName<int>() { return "integer"; } template<> inline const char* getTypeName<unsigned int>() { return "integer"; } template<> inline const char* getTypeName<long>() { return "integer"; } template<> inline const char* getTypeName<unsigned long>() { return "integer"; } template<> inline const char* getTypeName<long long>() { return "integer"; } template<> inline const char* getTypeName<unsigned long long>() { return "integer"; } template<> inline const char* getTypeName<float>() { return "real"; } template<> inline const char* getTypeName<double>() { return "real"; } /// @endcond //! Implements type-specific functionality through template specialization, mainly involving value conversion and stringification formatting /*! Provides smart-pointer style functionality for transparent * access to the value storage, as well as automatic casting * to and from the value type so you can almost always treat * the Primitive as if it was the value itself. */ template<typename T> class Primitive : public PrimitiveBase { public: template<typename U, typename V> struct conversion_policy { typedef typename U::template ConversionTo<V> value_conversion; }; //! constructor Primitive() : PrimitiveBase(), val(), prevVal() {} //! copy constructor, automatic conversion from value type Primitive(const T& v) : PrimitiveBase(), val(v), prevVal() {} //! assignment from value type (template specializations add in-place modiciation (e.g. +=, *=)) Primitive& operator=(const T& v) { if(&v==&prevVal) std::swap(val,prevVal); else { prevVal=val; val=v; } fireValueChanged(prevVal==val); return *this; } virtual Primitive& operator=(const PrimitiveBase& pb) { if(dynamic_cast<const Primitive*>(&pb)!=this) operator=(pb.to<T>()); return *this; } //! assignment from primitive of the same type (just assign value) Primitive& operator=(const Primitive& p) { operator=(p.val); return *this; } Primitive& operator+=(const T& v) { prevVal=val; val+=v; fireValueChanged(prevVal==val); return *this; } //!< add in-place Primitive& operator-=(const T& v) { prevVal=val; val-=v; fireValueChanged(prevVal==val); return *this; } //!< subtract in-place Primitive& operator*=(const T& v) { prevVal=val; val*=v; fireValueChanged(prevVal==val); return *this; } //!< multiply in-place Primitive& operator/=(const T& v) { prevVal=val; val/=v; fireValueChanged(prevVal==val); return *this; } //!< divide in-place //! smart pointer, dereference to access primitive storage const T& operator*() const { return val; } //! smart pointer, dereference to access primitive storage const T* operator->() const { return &val; } //! cast operator to automatically convert to value type operator T() const { return val; } //! interprets \a node as holding the specialization type void loadXML(xmlNode* node); //! saves #val into \a node void saveXML(xmlNode* node) const; void set(const std::string& str); using PrimitiveBase::set; std::string get() const { std::stringstream sstr; sstr <<std::setprecision(std::numeric_limits<T>::digits10)<< val; return sstr.str(); } virtual long toLong() const { return static_cast<long>(val); } virtual double toDouble() const { return static_cast<double>(val); } //! clone definition for Primitive<T> PLIST_CLONE_DEF(Primitive<T>,new Primitive<T>(val)); const T& getPreviousValue() const { return prevVal; } //!< returns the previously assigned value protected: T val; //!< storage of primitive value T prevVal; //!< following each assignment, this is the "old" value -- very handy for PrimitiveListeners }; template<typename T> void Primitive<T>::loadXML(xmlNode* node) { if(node==NULL) return; prevVal=val; bool bt=xNodeHasName(node,"true"); bool bf=xNodeHasName(node,"false"); if(!bt && !bf && !xNodeHasName(node,"integer") && !xNodeHasName(node,"real") && !xNodeHasName(node,"string")) { std::stringstream errstr; errstr << "Error: plist::Primitive<" << typeid(T).name() << "> expects " << getTypeName<T>() << ", got unknown type " << (const char*)xNodeGetName(node); throw bad_format(node,errstr.str()); } if(!xNodeHasName(node,getTypeName<T>())) std::cerr << "Warning: plist expected " << getTypeName<T>() << " got " << (const char*)xNodeGetName(node) << ", trying to convert. (line " << xmlGetLineNo(node) << ")" << std::endl; if(bt) val = true; else if(bf) val = false; else { xmlChar * cont=xmlNodeGetContent(node); std::stringstream str((const char*)cont); str >> val; xmlFree(cont); } fireValueChanged(prevVal==val); } template<typename T> void Primitive<T>::saveXML(xmlNode* node) const { if(node==NULL) return; xmlNodeSetName(node,(const xmlChar*)getTypeName<T>()); std::stringstream str; str <<std::setprecision(std::numeric_limits<T>::digits10)<< val; xmlNodeSetContent(node,(const xmlChar*)str.str().c_str()); } template<typename T> void Primitive<T>::set(const std::string& str) { prevVal=val; std::stringstream sstr(str); sstr >> val; while(sstr.good() && isspace(sstr.peek())) sstr.get(); if(sstr.fail()) { if(matchTrue(str)) val=true; else if(matchFalse(str)) val=false; else { std::string err="Expected "; err+=getTypeName<T>(); err+=" value, got '"+str+"'"; throw bad_format(NULL,err); } std::cerr << "Warning: expected " << getTypeName<T>() << " value, interpreting '" << str << "' as boolean (value of " << val << ")" << std::endl; } if(sstr.good()) { std::cerr << "Warning: expected " << getTypeName<T>() << " value, truncating remainder '"; char c=sstr.get(); while(sstr) { std::cerr << c; c=sstr.get(); } std::cerr << "'" << std::endl; } fireValueChanged(prevVal==val); } //! implements the clone function for Primitive<T> PLIST_CLONE_IMPT(T,Primitive,new Primitive<T>(val)); /// @cond SHOW_PLIST_OBJECT_SPECIALIZATION //! provides a @c bool specialization of Primitive<T> /*! A @c bool can be treated as either a string or an integer\n * When saving, "true" or "false" will be used, but users could * also specify "yes"/"no" or "on"/"off". If an integer is used, * it will be interpreted as usual: 0==false, otherwise true. */ template<> class Primitive<bool> : public PrimitiveBase { public: template<typename U, typename V> struct conversion_policy { typedef typename U::template ConversionTo<V> value_conversion; }; Primitive() : PrimitiveBase(), val(), prevVal() {} //!< constructor Primitive(const bool& v) : PrimitiveBase(), val(v), prevVal() {} //!< casting constructor Primitive& operator=(const bool& v) { if(&v==&prevVal) std::swap(val,prevVal); else { prevVal=val; val=v; } fireValueChanged(prevVal==val); return *this; } //!< assignment constructor virtual Primitive& operator=(const PrimitiveBase& pb) { if(dynamic_cast<const Primitive*>(&pb)!=this) operator=(pb.to<bool>()); return *this; } Primitive& operator=(const Primitive& p) { operator=(p.val); return *this; } //bool& operator*() { return val; } const bool& operator*() const { return val; } //!< dereference will return data storage //bool* operator->() { return &val; } const bool* operator->() const { return &val; } //!< can use -> to access members of data storage operator bool() const { return val; } //!< casting operator void loadXML(xmlNode* node); //!< interprets @a node as a bool void saveXML(xmlNode* node) const; //!< saves #val into @a node void set(const std::string& str); using PrimitiveBase::set; std::string get() const { return val?"true":"false"; } virtual long toLong() const { return static_cast<long>(val); } virtual double toDouble() const { return static_cast<double>(val); } //! clone definition for Primitive<bool> PLIST_CLONE_DEF(Primitive<bool>,new Primitive<bool>(val)); const bool& getPreviousValue() const { return prevVal; } //!< returns the previously assigned value protected: bool val; //!< the actual data storage bool prevVal; //!< following each assignment, this is the "old" value -- very handy for PrimitiveListeners }; /// @endcond //! provides a @c char specialization of plist::Primitive<T>, adds a unique #numeric property to the usual template implementation /*! A @c char can be treated as either a string or an integer, you can use * the setNumeric(bool) function to indicate which style to use when saving */ template<> class Primitive<char> : public PrimitiveBase { public: template<typename U, typename V> struct conversion_policy { typedef typename U::template ConversionTo<V> value_conversion; }; Primitive() : PrimitiveBase(), val(), prevVal(), numeric(false) {} //!< constructor Primitive(const char& v, bool isNum=false) : PrimitiveBase(), val(v), prevVal(), numeric(isNum) {} //!< casting constructor Primitive& operator=(char v) { if(&v==&prevVal) std::swap(val,prevVal); else { prevVal=val; val=v; } fireValueChanged(prevVal==val); return *this; } //!< assignment virtual Primitive& operator=(const PrimitiveBase& pb) { if(dynamic_cast<const Primitive*>(&pb)!=this) operator=(pb.to<char>()); return *this; } //! assignment from primitive of the same type (just assign value) Primitive& operator=(const Primitive& p) { operator=(p.val); return *this; } Primitive& operator+=(char v) { prevVal=val; val+=v; fireValueChanged(prevVal==val); return *this; } //!< add-assign Primitive& operator-=(char v) { prevVal=val; val-=v; fireValueChanged(prevVal==val); return *this; } //!< subtract-assign Primitive& operator*=(char v) { prevVal=val; val*=v; fireValueChanged(prevVal==val); return *this; } //!< multiply-assign Primitive& operator/=(char v) { prevVal=val; val/=v; fireValueChanged(prevVal==val); return *this; } //!< divide-assign //char& operator*() { return val; } const char& operator*() const { return val; } //!< dereference will return data storage //char* operator->() { return &val; } const char* operator->() const { return &val; } //!< can use -> to access members of data storage operator char() const { return val; } //!< casting operator void setNumeric(bool isNum) { numeric=isNum; } //!< sets #numeric bool getNumeric() const { return numeric; } //!< returns #numeric void loadXML(xmlNode* node); //!< interprets @a node as a char void saveXML(xmlNode* node) const; //! saves #val into @a node void set(const std::string& str); using PrimitiveBase::set; std::string get() const { if(numeric) { std::stringstream sstr; sstr << (int)val; return sstr.str(); } else return std::string(1,val); } virtual long toLong() const { return static_cast<long>(val); } virtual double toDouble() const { return static_cast<double>(val); } //! clone definition for Primitive<char> PLIST_CLONE_DEF(Primitive<char>,new Primitive<char>(val)); const char& getPreviousValue() const { return prevVal; } //!< returns the previously assigned value protected: char val; //!< data storage char prevVal; //!< following each assignment, this is the "old" value -- very handy for PrimitiveListeners bool numeric; //!< if true, requests that saves store the numeric value instead of corresponding character }; //! provides an @c unsigned @c char specialization of plist::Primitive<T>, adds a unique #numeric property to the usual template implementation /*! A @c char can be treated as either a string or an integer, you can use * the setNumeric(bool) function to indicate which style to use when saving */ template<> class Primitive<unsigned char> : public PrimitiveBase { public: template<typename U, typename V> struct conversion_policy { typedef typename U::template ConversionTo<V> value_conversion; }; Primitive() : PrimitiveBase(), val(), prevVal(), numeric(false) {} //!< constructor Primitive(const unsigned char& v, bool isNum=false) : PrimitiveBase(), val(v), prevVal(), numeric(isNum) {} //!< casting constructor Primitive& operator=(unsigned char v) { prevVal=val; val=v; fireValueChanged(prevVal==val); return *this; } //!< assignment virtual Primitive& operator=(const PrimitiveBase& pb) { if(dynamic_cast<const Primitive*>(&pb)!=this) operator=(pb.to<unsigned char>()); return *this; } //! assignment from primitive of the same type (just assign value) Primitive& operator=(const Primitive& p) { operator=(p.val); return *this; } Primitive& operator+=(unsigned char v) { prevVal=val; val+=v; fireValueChanged(prevVal==val); return *this; } //!< add-assign Primitive& operator-=(unsigned char v) { prevVal=val; val-=v; fireValueChanged(prevVal==val); return *this; } //!< subtract-assign Primitive& operator*=(unsigned char v) { prevVal=val; val*=v; fireValueChanged(prevVal==val); return *this; } //!< multiple-assign Primitive& operator/=(unsigned char v) { prevVal=val; val/=v; fireValueChanged(prevVal==val); return *this; } //!< divide-assign //unsigned char& operator*() { return val; } const unsigned char& operator*() const { return val; } //!< dereference will return data storage //unsigned char* operator->() { return &val; } const unsigned char* operator->() const { return &val; } //!< can use -> to access members of data storage operator unsigned char() const { return val; } //!< casting operator void setNumeric(bool isNum) { numeric=isNum; } //!< sets #numeric bool getNumeric() const { return numeric; } //!< returns #numeric void loadXML(xmlNode* node); //!< interprets @a node as a unsigned char void saveXML(xmlNode* node) const; //! saves #val into @a node void set(const std::string& str); using PrimitiveBase::set; std::string get() const { if(numeric) { std::stringstream sstr; sstr << (int)val; return sstr.str(); } else return std::string(1,val); } virtual long toLong() const { return static_cast<long>(val); } virtual double toDouble() const { return static_cast<double>(val); } //! clone definition for Primitive<unsigned char> PLIST_CLONE_DEF(Primitive<unsigned char>,new Primitive<unsigned char>(val)); const unsigned char& getPreviousValue() const { return prevVal; } //!< returns the previously assigned value protected: unsigned char val; //!< data storage unsigned char prevVal; //!< following each assignment, this is the "old" value -- very handy for PrimitiveListeners bool numeric; //!< if true, requests that saves store the numeric value instead of corresponding character }; //! Provides a @c std::string specialization of Primitive<T> /*! Doesn't need to provide a operator cast because we subclass std::string itself! */ template<> class Primitive<std::string> : public PrimitiveBase, public std::string { public: template<typename U, typename V> struct conversion_policy { typedef typename U::template ConversionTo<V> value_conversion; }; Primitive() : PrimitiveBase(), std::string(), prevVal() {} //!< constructor Primitive(const std::string& v) : PrimitiveBase(), std::string(v), prevVal() {} //!< casting constructor Primitive(const std::string& v, size_type off, size_type count=npos) : PrimitiveBase(), std::string(v,off,count), prevVal() {} //!< casting constructor Primitive(const char* v, size_type count) : PrimitiveBase(), std::string(v,count), prevVal() {} //!< casting constructor Primitive(const char* v) : PrimitiveBase(), std::string(v), prevVal() {} //!< casting constructor Primitive(size_type count, char v) : PrimitiveBase(), std::string(count,v), prevVal() {} //!< casting constructor Primitive& operator=(const std::string& v) { if(&v==&prevVal) std::string::swap(prevVal); else { prevVal=*this; std::string::operator=(v); } fireValueChanged(prevVal==*this); return *this; } //!< assignment Primitive& operator=(const char* v) { prevVal=*this; std::string::operator=(v); fireValueChanged(prevVal==*this); return *this; } //!< assignment Primitive& operator=(char v) { prevVal=*this; std::string::operator=(v); fireValueChanged(prevVal==*this); return *this; } //!< assignment