This is a complete implementation of the Siena data model. In particular, this file shows how to implement the the siena::value, siena::attribute, siena::message, siena::constraint, siena::filter, and siena::predicate interfaces.
#include <list> #include <map> #include <siena/types.h> using namespace std; class simple_value: public siena::value { public: virtual siena::type_id type() const; virtual siena::int_t int_value() const; virtual siena::string_t string_value() const; virtual siena::bool_t bool_value() const; virtual siena::double_t double_value() const; simple_value(int x); simple_value(bool x); simple_value(double x); simple_value(const siena::string_t & x); private: siena::type_id t; union { siena::int_t i; siena::bool_t b; siena::double_t d; }; siena::string_t s; }; typedef map<siena::string_t, const simple_value *> attribute_map; class simple_attribute : public siena::message::iterator { public: virtual siena::string_t name() const; virtual siena::type_id type() const; virtual siena::int_t int_value() const; virtual siena::string_t string_value() const; virtual siena::bool_t bool_value() const; virtual siena::double_t double_value() const; virtual bool next(); simple_attribute(attribute_map::const_iterator b, attribute_map::const_iterator e); private: attribute_map::const_iterator i; attribute_map::const_iterator end; }; class simple_message: public siena::message { public: virtual iterator * first() const; virtual iterator * find(const siena::string_t & name) const; virtual bool contains(const siena::string_t & name) const; bool add(const siena::string_t & name, const simple_value * a); simple_message(); private: attribute_map attrs; }; class simple_op_value: public simple_value { public: virtual siena::operator_id op() const; simple_op_value(siena::operator_id xo, int x); simple_op_value(siena::operator_id xo, bool x); simple_op_value(siena::operator_id xo, double x); simple_op_value(siena::operator_id xo, const siena::string_t & x); private: siena::operator_id o; }; typedef multimap<siena::string_t, const simple_op_value *> constraint_map; class simple_constraint: public siena::filter::iterator { public: virtual siena::string_t name() const; virtual siena::type_id type() const; virtual siena::int_t int_value() const; virtual siena::string_t string_value() const; virtual siena::bool_t bool_value() const; virtual siena::double_t double_value() const; virtual siena::operator_id op() const; virtual bool next(); simple_constraint(constraint_map::const_iterator b, constraint_map::const_iterator e); private: constraint_map::const_iterator i; constraint_map::const_iterator end; }; class simple_filter: public siena::filter { public: virtual iterator * first() const; void add(const siena::string_t name, const simple_op_value * v); simple_filter(); private: constraint_map constraints; }; typedef list<simple_filter *> filter_list; class simple_predicate_i: public siena::predicate::iterator { public: virtual filter::iterator * first() const; virtual bool next(); simple_predicate_i(filter_list::const_iterator b, filter_list::const_iterator e); private: filter_list::const_iterator i; filter_list::const_iterator end; }; class simple_predicate : public siena::predicate { public: virtual iterator * first() const; void add(simple_filter * v); simple_filter * back(); simple_predicate(); private: filter_list filters; }; siena::type_id simple_value::type() const { return t; } siena::int_t simple_value::int_value() const { return i; } siena::string_t simple_value::string_value() const { return s; } siena::bool_t simple_value::bool_value() const { return b; } siena::double_t simple_value::double_value() const { return d; } simple_value::simple_value(int x) : t(siena::int_id), i(x) {} simple_value::simple_value(bool x) : t(siena::bool_id), b(x) {} simple_value::simple_value(double x) : t(siena::double_id), d(x) {} simple_value::simple_value(const siena::string_t & x) : t(siena::string_id), s(x) {} simple_attribute::simple_attribute(attribute_map::const_iterator b, attribute_map::const_iterator e) : i(b), end(e) {} siena::string_t simple_attribute::name() const { return (*i).first; } siena::type_id simple_attribute::type() const { return (*i).second->type(); } siena::int_t simple_attribute::int_value() const { return (*i).second->int_value(); } siena::string_t simple_attribute::string_value() const { return (*i).second->string_value(); } siena::bool_t simple_attribute::bool_value() const { return (*i).second->bool_value(); } siena::double_t simple_attribute::double_value() const { return (*i).second->double_value(); } bool simple_attribute::next() { if (i != end) ++i; return i != end; } simple_message::simple_message(): attrs() {} simple_message::iterator * simple_message::first() const { if (attrs.begin() == attrs.end()) { return 0; } else { return new simple_attribute(attrs.begin(), attrs.end()); } } simple_message::iterator * simple_message::find(const siena::string_t & name) const { attribute_map::const_iterator i = attrs.find(name); if (i == attrs.end()) { return 0; } else { new simple_attribute(i, attrs.end()); } } bool simple_message::contains(const siena::string_t & name) const { return attrs.find(name) != attrs.end(); } bool simple_message::add(const siena::string_t & name, const simple_value * a) { attrs.insert(attribute_map::value_type(name, a)); } simple_op_value::simple_op_value(siena::operator_id xo, int x) : simple_value(x), o(xo) {} simple_op_value::simple_op_value(siena::operator_id xo, bool x) : simple_value(x), o(xo) {} simple_op_value::simple_op_value(siena::operator_id xo, double x) : simple_value(x), o(xo) {} simple_op_value::simple_op_value(siena::operator_id xo, const siena::string_t & x) : simple_value(x), o(xo) {} siena::operator_id simple_op_value::op() const { return o; } siena::string_t simple_constraint::name() const { return (*i).first; } siena::type_id simple_constraint::type() const { return (*i).second->type(); } siena::int_t simple_constraint::int_value() const { return (*i).second->int_value(); } siena::string_t simple_constraint::string_value() const { return (*i).second->string_value(); } siena::bool_t simple_constraint::bool_value() const { return (*i).second->bool_value(); } siena::double_t simple_constraint::double_value() const { return (*i).second->double_value(); } siena::operator_id simple_constraint::op() const { return (*i).second->op(); } bool simple_constraint::next() { if (i != end) ++i; return i != end; } simple_constraint::simple_constraint(constraint_map::const_iterator b, constraint_map::const_iterator e) : i(b), end(e) {} simple_filter::iterator * simple_filter::first() const { if (constraints.begin() == constraints.end()) { return 0; } else { return new simple_constraint(constraints.begin(), constraints.end()); } } void simple_filter::add(const siena::string_t name, const simple_op_value * v) { constraints.insert(constraint_map::value_type(name, v)); } simple_filter::simple_filter(): constraints() {} filter::iterator * simple_predicate_i::first() const { return (*i)->first(); } bool simple_predicate_i::next() { if (i != end) ++i; return i != end; } simple_predicate_i::simple_predicate_i(filter_list::const_iterator b, filter_list::const_iterator e) : i(b), end(e) {} simple_predicate::iterator * simple_predicate::first() const { if (filters.begin() == filters.end()) { return 0; } else { return new simple_predicate_i(filters.begin(), filters.end()); } } void simple_predicate::add(simple_filter * v) { filters.push_back(v); } simple_filter * simple_predicate::back() { return filters.back(); } simple_predicate::simple_predicate(): filters() {}