00001
00002 #ifndef AKAXISO2_FRAMEWORK_SIMPLECONTENT_H__
00003 #define AKAXISO2_FRAMEWORK_SIMPLECONTENT_H__
00004
00010 #include <akaxiso2/framework/operators.h>
00011 #include <akaxiso2/framework/simpletype.h>
00012 #include <akaxiso2/framework/attribute.h>
00013 #include <akaxiso2/framework/construct.h>
00014 #include <akaxiso2/framework/xmltype.h>
00015 #include <akaxiso2/builtin/builtin_xiso.h>
00016
00017 namespace aka2 {
00018
00019 template<class L>
00020 class simplecontent_op_dispatcher : public simplecontent_op {
00021 public:
00022 virtual schematype_id get_schematype() const { return simplecontent_id; }
00023 virtual std::string get_typename() const { return L::get_xmltype(); }
00025 virtual void construct(void *e) const { L::construct(e); }
00026 virtual void copy_construct(void *e, const void *src) const { L::copy_construct(e, src); }
00027 virtual void destruct(void *e) const { L::destruct(e); }
00028 virtual size_t class_size() const { return L::class_size(); }
00029 virtual bool equals(const void *lhs, const void *rhs) const {
00030 return L::equals(lhs, rhs);
00031 }
00032
00034 virtual const attribute_types *get_attribute_types() const {
00035 return &L::attribute_types_;
00036 }
00037 virtual const attribute_type *get_anyattr_type() const {
00038 return L::get_anyattr_type();
00039 }
00040 virtual const member_type& get_valuetype() const { return L::value_type_; }
00041
00042 };
00043
00044 template<class L>
00045 struct simplecontent_statics {
00046 static member_type value_type_;
00047 static simplecontent_op_dispatcher<L> dispatcher_;
00048 static aka2::occurrence occ_;
00049 };
00050
00051 template<class L>
00052 member_type simplecontent_statics<L>::value_type_;
00053
00054 template<class L>
00055 aka2::occurrence simplecontent_statics<L>::occ_;
00056
00057 template<class L>
00058 simplecontent_op_dispatcher<L> simplecontent_statics<L>::dispatcher_;
00059
00060
00070 template<class T, class L=xiso::leaf<T> >
00071 class simplecontent : public attributes<L, T>,
00072 public simplecontent_statics<L>,
00073 public xmltype_statics<L> {
00074 public:
00075 typedef T value_type;
00076
00077 virtual ~simplecontent(){}
00078
00079 static void initialize() {
00080 if (!system_type_registry().add(L()))
00081 return;
00082 L::attribute_types_.clear();
00083 member_getter *getter = new null_getter();
00084 L::value_type_ = member_type(getter,
00085 nill_leaf::dispatcher_,
00086 false);
00087 L l; l.model();
00088 }
00089 static void uninitialize() {
00090 L::attribute_types_.clear();
00091 }
00092
00093
00094 static void construct(void *e) {
00095 new (e) T();
00096 simplecontent_construct(e, L::dispatcher_);
00097 }
00098 static void copy_construct(void *e, const void *src) {
00099 new (e) T(*static_cast<const T*>(src));
00100 }
00101 static size_t class_size() { return sizeof(T); }
00102 static void destruct(void *elm) { static_cast<T*>(elm)->~T(); }
00103
00104
00105 static bool equals(const void *lhs, const void *rhs) {
00106 return simplecontent_equals(lhs, rhs, L::dispatcher_);
00107 }
00108
00109 static element_op* get_attribute_dispatcher() { return &L::dispatcher_; }
00110 static default_op* create_default_op() { return 0; }
00111
00117 template<class V, class P, class VL>
00118 static void value(V P::* m, const VL& vl) {
00119 VL::initialize();
00120 member_getter *getter =
00121 create_ptr_getter(reinterpret_cast<T*>(0), m);
00122 L::value_type_ = member_type(getter, VL::dispatcher_, false);
00123 default_op *defop = VL::create_default_op();
00124 if (defop != 0)
00125 L::value_type_.set_default_op(defop);
00126 }
00127
00132 template<class V, class P>
00133 static void value(V P::* m) {
00134 value(m, xiso::leaf<V>());
00135 }
00136
00141 template<class V>
00142 struct fixed_value {
00147 fixed_value(const std::string &fixed) {
00148 new_member(fixed, xiso::leaf<V>());
00149 }
00155 template<class VL>
00156 fixed_value(const std::string &fixed, const VL &vl) {
00157 new_member(fixed, VL());
00158 }
00159 private:
00160 template<class VL>
00161 void new_member(const std::string &fixed, const VL&) {
00162 VL::initialize();
00163
00164 if (VL::dispatcher_.get_schematype() != simpletype_id)
00165 throw tagged_error("simpleContent", L::get_xmltype(),
00166 "fixed value should be a simpleType.",
00167 __FILE__, __LINE__);
00168
00169 L::value_type_ = aka2::member_type(new null_getter(),
00170 aka2::fixed<VL>::dispatcher_,
00171 false);
00172 L::value_type_.set_name(aka2::qname("&value"));
00173 default_op *defop = VL::create_default_op();
00174 if (defop != 0)
00175 L::value_type_.set_default_op(defop);
00176 L::value_type_.setup_default_value(fixed);
00177 }
00178 };
00179
00184 static void set_default(const std::string &defval) {
00185 if (L::value_type_.get_schematype() != simpletype_id)
00186 throw tagged_error("simpleContent", L::get_xmltype(),
00187 "default value should be a simpleType.",
00188 __FILE__, __LINE__);
00189 L::value_type_.set_default(defval);
00190 }
00191 };
00192
00193 }
00194
00195 #endif