#include "simple_attributes_types.h"
return t;
}
return i;
}
return s;
}
return b;
}
return d;
}
simple_value::simple_value()
: t(siena::
BOOL), b(x) {}
simple_attribute::simple_attribute(attribute_map::const_iterator b,
attribute_map::const_iterator e)
: i(b), end(e) {}
return (*i).first;
}
return (*i).second->type();
}
return (*i).second->int_value();
}
return (*i).second->string_value();
}
return (*i).second->bool_value();
}
return (*i).second->double_value();
}
bool simple_attribute::next() {
if (i != end) ++i;
return i != end;
}
simple_message::simple_message()
: attrs() {}
if (attrs.begin() == attrs.end()) {
return 0;
} else {
return new simple_attribute(attrs.begin(), attrs.end());
}
}
attribute_map::const_iterator i = attrs.find(name);
if (i == attrs.end()) {
return 0;
} else {
return new simple_attribute(i, attrs.end());
}
}
bool simple_message::contains(
const siena::String & name)
const {
return attrs.find(name) != attrs.end();
}
const simple_value * a) {
return attrs.insert(attribute_map::value_type(name, a)).second;
}
: simple_value(), o(xo) {}
: simple_value(x), o(xo) {}
: simple_value(x), o(xo) {}
: simple_value(x), o(xo) {}
: simple_value(x), o(xo) {}
return o;
}
return (*i).first;
}
return (*i).second->type();
}
return (*i).second->int_value();
}
return (*i).second->string_value();
}
return (*i).second->bool_value();
}
return (*i).second->double_value();
}
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) {}
if (constraints.begin() == constraints.end()) {
return 0;
} else {
return new simple_constraint(constraints.begin(),
constraints.end());
}
}
const simple_op_value * v) {
constraints.insert(constraint_map::value_type(name, v));
}
simple_filter::simple_filter() : constraints() {}
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) {}
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::last_filter() {
return filters.back();
}
simple_predicate::simple_predicate() : filters() {}
simple_message::~simple_message() {
for (attribute_map::const_iterator i = attrs.begin(); i != attrs.end(); ++i)
if (i->second) delete(i->second);
}
simple_filter::~simple_filter() {
for (constraint_map::const_iterator i = constraints.begin();
i != constraints.end(); ++i)
if (i->second) delete(i->second);
}
simple_predicate::~simple_predicate() {
for (filter_list::const_iterator i = filters.begin(); i != filters.end(); ++i)
if (*i) delete(*i);
}