Main Page   Namespace List   Class Hierarchy   Compound List   File List   Namespace Members   Compound Members   Related Pages  

simpletype.h

Go to the documentation of this file.
00001 /* -*- c++ -*- */
00002 #ifndef AKAXISO2_FRAMEWORK_SIMPLETYPE_H__
00003 #define AKAXISO2_FRAMEWORK_SIMPLETYPE_H__
00004 
00010 #include <akaxiso2/framework/type_registry.h>
00011 #include <akaxiso2/framework/member.h>
00012 #include <akaxiso2/framework/operators.h>
00013 #include <akaxiso2/framework/xmltype.h>
00014 #include <akaxiso2/util/sstream.h>
00015 
00016 namespace aka2 {
00017 
00018   template<class V, class VL>
00019   struct default_value : public default_op {
00020     typedef V value_type;
00021 
00022     default_value() : has_default_(false) {}
00023     virtual ~default_value(){}
00024 
00025     virtual void set_default(const std::string &defval) {
00026       VL::read_text(&default_, defval, system_entity_complements());
00027       has_default_ = true;
00028     }
00029 
00030     virtual bool has_default() const {
00031       return has_default_;
00032     }
00033 
00034     virtual const void *value() const {
00035       assert(has_default_);
00036       return &default_;
00037     }
00038 
00039   private:
00040     V default_;
00041     bool has_default_;
00042   };
00043 
00044 
00045   template<class L>
00046   struct simpletype_op_dispatcher : public simpletype_op {
00047   public:
00048     virtual schematype_id get_schematype() const { return simpletype_id; }
00049     virtual std::string get_typename() const { return L::get_xmltype(); }
00050     virtual const attribute_types *get_attribute_types() const { return 0; }
00051     virtual const attribute_type *get_anyattr_type() const { return 0; }
00052 
00053     virtual void write_text(const void* elm,
00054                             std::ostream &ostm,
00055                             entity_complements &ecomp) const {
00056       L::write_text(elm, ostm, ecomp);
00057     }
00058 
00059     virtual void read_text(void* elm, const std::string &entity,
00060                            entity_complements &ecomp) const {
00061       L::read_text(elm, entity, ecomp);
00062     }
00063 
00064     virtual void construct(void *e) const {  L::construct(e); }
00065     virtual void copy_construct(void *e, const void *src) const { L::copy_construct(e, src); }
00066     virtual void destruct(void *e) const { L::destruct(e); }
00067     virtual size_t class_size() const { return L::class_size(); }
00068     virtual bool equals(const void *lhs, const void *rhs) const { return L::equals(lhs, rhs); }
00069   };
00070 
00071 
00072   template<class L>
00073   struct simpletype_statics {
00074     static simpletype_op_dispatcher<L> dispatcher_;
00075   };
00076 
00077   template<class L>
00078   simpletype_op_dispatcher<L> simpletype_statics<L>::dispatcher_;
00079 
00088   template<class V, class L=xiso::leaf<V> >
00089   class simpletype : public simpletype_statics<L>, 
00090                      public xmltype_statics<L> {
00091   public:
00092     virtual ~simpletype(){}
00093     typedef V value_type;
00094 
00095     static void initialize() {
00096       system_type_registry().add(L());
00097     }
00098     static void uninitialize() {}
00099 
00111     static void write_text(const void *elm, std::ostream &ostm,
00112                            entity_complements &ecomp) {
00113       const V &value = *reinterpret_cast<const V*>(elm);
00114       ostm << value;
00115     }
00116 
00128     static void read_text(void *elm, const std::string &entity,
00129                           entity_complements &ecomp) {
00130       V &value = *reinterpret_cast<V*>(elm);
00131       isstream istm(entity);
00132       istm >> value;
00133       if (istm.fail())
00134         throw error(std::string("Failed to parse simpletype value, \"")
00135                     + istm.rdbuf()->str() + "\".",
00136                     __FILE__, __LINE__);
00137     }
00138 
00139 
00140     static void construct(void *e) { new (e) V(); }
00141     static void copy_construct(void *e, const void *src) {
00142       new (e) V(*static_cast<const V*>(src));
00143     }
00144     static size_t class_size() { return sizeof(V); }
00145     static void destruct(void *elm) { static_cast<V*>(elm)->~V(); }
00146 
00147     static bool equals(const void *lhs, const void *rhs) {
00148       return *static_cast<const V*>(lhs) == *static_cast<const V*>(rhs);
00149     }
00150 
00151     static default_op* create_default_op() { return new default_value<V, L>; }
00152     static simpletype_op_dispatcher<L> *get_attribute_dispatcher() {
00153       return &L::dispatcher_;
00154     }
00155   };
00156 
00157 } // namespace aka2
00158 
00159 #endif

Generated on Sun Dec 19 22:58:57 2004 for akaxiso2 by doxygen1.2.18