simple_types.cc

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() {}