void ServerInfo::processServer(const RootEntity &svr)
{
Atlas::Message::Element element;
if (!svr->copyAttr("ruleset", element) && element.isString()) {
_ruleset = element.String();
} else {
return;
}
_name = svr->getName();
if (!svr->copyAttr("clients", element) && element.isInt()) {
_clients = (int)element.Int();
} else {
return;
}
if (!svr->copyAttr("server", element) && element.isString()) {
_server = element.String();
} else {
return;
}
if (!svr->copyAttr("uptime", element) && element.isFloat()) {
_uptime = element.Float();
} else {
return;
}
m_status = VALID;
if (!svr->copyAttr("entities", element) && element.isInt()) {
_entities = element.Int();
}
if (!svr->copyAttr("version", element) && element.isString()) {
m_version = element.String();
}
if (!svr->copyAttr("builddate", element) && element.isString()) {
m_buildDate = element.String();
}
if (!svr->copyAttr("assets", element) && element.isList()) {
for (auto& url : element.List()) {
if (url.isString()) {
m_assets.emplace_back(url.String());
}
}
}
}
void ServerInfo::processServer(const RootEntity &svr)
{
Atlas::Message::Element element;
if (!svr->copyAttr("ruleset", element) && element.isString()) {
_ruleset = element.asString();
} else {
return;
}
_name = svr->getName();
if (!svr->copyAttr("clients", element) && element.isInt()) {
_clients = element.asInt();
} else {
return;
}
if (!svr->copyAttr("server", element) && element.isString()) {
_server = element.asString();
} else {
return;
}
if (!svr->copyAttr("uptime", element) && element.isFloat()) {
_uptime = element.asFloat();
} else {
return;
}
m_status = VALID;
if (!svr->copyAttr("entities", element) && element.isInt()) {
_entities = element.asInt();
}
if (!svr->copyAttr("version", element) && element.isString()) {
m_version = element.asString();
}
if (!svr->copyAttr("builddate", element) && element.isString()) {
m_buildDate = element.asString();
}
}
void StaticAdapter::updateGui(const ::Atlas::Message::Element& element)
{
SelfUpdateContext context(*this);
if (mTextWindow) {
if (element.isString()) {
mTextWindow->setText(element.asString());
} else if (element.isNum()) {
std::stringstream ss;
ss << element.asNum();
mTextWindow->setText(ss.str());
}
}
}
void EmberEntity::onImaginary(const Atlas::Objects::Root& act)
{
Atlas::Message::Element attr;
if (act->copyAttr("description", attr) && attr.isString()) {
std::string message = getName() + " " + attr.asString() + ".";
ConsoleBackend::getSingletonPtr()->pushMessage(message, "info");
S_LOG_VERBOSE("Entity: " << this->getId() << " (" << this->getName() << ") imaginary: " << attr.String());
}
Entity::onImaginary(act);
}
void EntityProperty::set(const Atlas::Message::Element & val)
{
// INT id?
if (val.isString()) {
const std::string & id = val.String();
if (m_data.get() == 0 || m_data->getId() != id) {
debug(std::cout << "Assigning " << id << std::endl << std::flush;);
if (id.empty()) {
m_data = EntityRef(0);
} else {
LocatedEntity * e = BaseWorld::instance().getEntity(id);
if (e != 0) {
debug(std::cout << "Assigned" << std::endl << std::flush;);
m_data = EntityRef(e);
}
Py::Object CyPy_Element::wrap(Atlas::Message::Element value)
{
if (value.isNone()) {
return Py::None();
} else if (value.isString()) {
return Py::String(value.String());
} else if (value.isInt()) {
return Py::Long(value.Int());
} else if (value.isFloat()) {
return Py::Float(value.Float());
} else if (value.isList()) {
return CyPy_ElementList::wrap(value.List());
} else {
return CyPy_ElementMap::wrap(value.Map());
}
}
void Property<std::string>::set(const Atlas::Message::Element & e)
{
if (e.isString()) {
this->m_data = e.String();
}
}
void EntityImporterBase::errorArrived(const Operation & op, OpVector & res)
{
std::string errorMessage;
if (!op->getArgs().empty()) {
auto arg = op->getArgs().front();
if (arg->hasAttr("message")) {
const Atlas::Message::Element messageElem = arg->getAttr("message");
if (messageElem.isString()) {
errorMessage = messageElem.asString();
}
}
}
switch (m_state) {
case RULE_WALKING:
{
//An error here just means that the rule we asked for didn't exist on the server, and we need
//to create it. This is an expected result.
auto& current = mRuleStack.back();
auto definition = current.definition;
assert(definition.isValid());
createRule(definition, res);
}
break;
case RULE_CREATING:
{
mStats.rulesProcessedCount++;
mStats.rulesCreateErrorCount++;
//An error here means that something went wrong when trying to create a rule. This is wrong.
//It probably means that there's something wrong with the data we're sending.
auto& current = mRuleStack.back();
std::string ruleId = current.definition->getId();
S_LOG_FAILURE("Could not create rule with id '" << ruleId << "', continuing with next. Server message: " << errorMessage);
EventProgress.emit();
walkRules(res);
}
break;
case RULE_UPDATING:
{
mStats.rulesProcessedCount++;
//An error here means that something went wrong when trying to update a rule. This is wrong.
//It probably means that there's something wrong with the data we're sending.
auto& current = mRuleStack.back();
std::string ruleId = current.definition->getId();
S_LOG_FAILURE("Could not update rule with id '" << ruleId << "', continuing with next. Server message: " << errorMessage);
mStats.rulesCreateErrorCount++;
EventProgress.emit();
walkRules(res);
}
break;
case ENTITY_WALKING:
{
//An error here just means that the entity we asked for didn't exist on the server, and we need
//to create it. This is an expected result.
assert(!mTreeStack.empty());
StackEntry & current = mTreeStack.back();
const RootEntity& obj = current.obj;
assert(obj.isValid());
createEntity(obj, res);
}
break;
case ENTITY_CREATING:
{
//An error here means that something went wrong when trying to create an entity. This is wrong.
//It probably means that there's something wrong with the data we're sending. Either the
//persisted data is corrupt, or there have been changes on the server (for example entity types
//renamed or removed).
std::string entityType = "unknown";
auto I = mCreateEntityMapping.find(op->getRefno());
if (I != mCreateEntityMapping.end()) {
auto J = mPersistedEntities.find(I->second);
if (J != mPersistedEntities.end()) {
auto& entity = J->second;
entityType = entity->getParent();
}
}
S_LOG_FAILURE("Could not create entity of type '" << entityType << "', continuing with next. Server message: " << errorMessage);
mStats.entitiesCreateErrorCount++;
EventProgress.emit();
walkEntities(res);
}
break;
default:
S_LOG_FAILURE("Unexpected state in state machine: " << m_state << ". Server message: " << errorMessage);
break;
};
}
int main()
{
// Test constructor
{
new LocatedEntityTest("1", 1);
}
// Test destructor
{
LocatedEntityTest * e = new LocatedEntityTest("1", 1);
delete e;
}
// Test checkRef()
{
LocatedEntityTest * e = new LocatedEntityTest("1", 1);
assert(e->checkRef() == 0);
delete e;
}
// Test incRef()
{
LocatedEntityTest * e = new LocatedEntityTest("1", 1);
e->incRef();
assert(e->checkRef() == 1);
delete e;
}
// Test decRef()
{
LocatedEntityTest * e = new LocatedEntityTest("1", 1);
e->incRef();
e->decRef();
assert(e->checkRef() == 0);
delete e;
}
// Test decRef()
{
LocatedEntityTest * e = new LocatedEntityTest("1", 1);
e->decRef();
// Enitity deleted - verified as not leaked
}
// Test setAttr()
{
LocatedEntityTest * e = new LocatedEntityTest("1", 1);
e->setAttr("foo", "bar");
e->decRef();
}
// Test setAttr()
{
LocatedEntityTest * e = new LocatedEntityTest("1", 1);
e->setAttr("foo", "bar");
e->setAttr("foo", 23);
e->decRef();
}
// Test getAttr()
{
LocatedEntityTest * e = new LocatedEntityTest("1", 1);
Atlas::Message::Element val;
int ret = e->getAttr("foo", val);
assert(ret == -1);
assert(val.isNone());
e->decRef();
}
// Test getAttr()
{
LocatedEntityTest * e = new LocatedEntityTest("1", 1);
Atlas::Message::Element val;
e->setAttr("foo", "bar");
int ret = e->getAttr("foo", val);
assert(ret == 0);
assert(val.isString());
e->decRef();
}
// Test getAttrType()
{
LocatedEntityTest * e = new LocatedEntityTest("1", 1);
Atlas::Message::Element val;
int ret = e->getAttrType("foo", val, Element::TYPE_STRING);
assert(ret == -1);
assert(val.isNone());
e->decRef();
}
// Test getAttrType()
{
LocatedEntityTest * e = new LocatedEntityTest("1", 1);
Atlas::Message::Element val;
int ret = e->getAttrType("id", val, Element::TYPE_STRING);
assert(ret == 0);
assert(val.isString());
e->decRef();
}
// Test getAttrType()
{
LocatedEntityTest * e = new LocatedEntityTest("1", 1);
Atlas::Message::Element val;
int ret = e->getAttrType("id", val, Element::TYPE_FLOAT);
assert(ret != 0);
assert(val.isString());
e->decRef();
}
// Test hasAttr()
{
LocatedEntityTest * e = new LocatedEntityTest("1", 1);
Atlas::Message::Element val;
bool ret = e->hasAttr("foo");
assert(ret == false);
e->decRef();
}
// Test hasAttr()
{
LocatedEntityTest * e = new LocatedEntityTest("1", 1);
Atlas::Message::Element val;
e->setAttr("foo", "bar");
bool ret = e->hasAttr("foo");
assert(ret == true);
e->decRef();
}
LocatedEntitytest t;
return t.run();
}
int main(int argc, char ** argv)
{
loadConfig(argc, argv);
database_flag = false;
init_python_api();
int ret;
{
World e("1", 1);
TestWorld test_world(e);
Anonymous attributes;
EntityBuilder::init(test_world);
Ruleset::init();
assert(Ruleset::instance() != 0);
assert(EntityBuilder::instance() != 0);
assert(EntityBuilder::instance()->newEntity("1", 1, "world", attributes) == 0);
assert(EntityBuilder::instance()->newEntity("1", 1, "nonexistant", attributes) == 0);
assert(EntityBuilder::instance()->newEntity("1", 1, "thing", attributes) != 0);
Ruleset::del();
assert(Ruleset::instance() == 0);
EntityBuilder::del();
assert(EntityBuilder::instance() == 0);
Inheritance::clear();
}
{
World e("1", 1);
TestWorld test_world(e);
Anonymous attributes;
Atlas::Message::Element val;
EntityBuilder::init(test_world);
Ruleset::init();
assert(Ruleset::instance() != 0);
Entity * test_ent = EntityBuilder::instance()->newEntity("1", 1, "thing", attributes);
assert(test_ent != 0);
assert(!test_ent->getAttr("funky", val));
assert(val.isNone());
attributes->setAttr("funky", "true");
test_ent = EntityBuilder::instance()->newEntity("1", 1, "thing", attributes);
assert(test_ent != 0);
assert(test_ent->getAttr("funky", val));
assert(val.isString());
assert(val.String() == "true");
Ruleset::del();
assert(Ruleset::instance() == 0);
EntityBuilder::del();
assert(EntityBuilder::instance() == 0);
Inheritance::clear();
}
{
// Create a test world.
World e("1", 1);
TestWorld test_world(e);
Atlas::Message::Element val;
// Instance of EntityBuilder with all protected methods exposed
// for testing
ExposedEntityBuilder * entity_factory = new ExposedEntityBuilder(test_world);
// Instance of Ruleset with all protected methods exposed
// for testing
EntityBuilder * test_eb = EntityBuilder::instance();
assert(test_eb == entity_factory);
ExposedRuleset test_ruleset(test_eb);
// Attributes for test entities being created
Anonymous attributes;
// Create an entity which is an instance of one of the core classes
Entity * test_ent = test_eb->newEntity("1", 1, "thing", attributes);
assert(test_ent != 0);
// Check the created entity does not have the attribute values we
// will be testing later
assert(!test_ent->getAttr("funky", val));
assert(val.isNone());
// Set a test attribute
attributes->setAttr("funky", "true");
// Create another entity, and check that it has picked up the new
// attribute value
test_ent = test_eb->newEntity("1", 1, "thing", attributes);
assert(test_ent != 0);
assert(test_ent->getAttr("funky", val));
assert(val.isString());
assert(val.String() == "true");
// Check that creating an entity of a type we know we have not yet
// installed results in a null pointer.
assert(test_eb->newEntity("1", 1, "custom_type", attributes) == 0);
// Set up a type description for a new type, and install it.
{
Root custom_type_description;
MapType attrs;
MapType test_custom_type_attr;
test_custom_type_attr["default"] = "test_value";
test_custom_type_attr["visibility"] = "public";
attrs["test_custom_type_attr"] = test_custom_type_attr;
custom_type_description->setAttr("attributes", attrs);
custom_type_description->setId("custom_type");
custom_type_description->setParents(std::list<std::string>(1, "thing"));
std::string dependent, reason;
ret = test_ruleset.installEntityClass("custom_type", "thing", custom_type_description, dependent, reason);
assert(ret == 0);
assert(dependent.empty());
assert(reason.empty());
}
// Check that the factory dictionary now contains a factory for
// the custom type we just installed.
EntityKit * custom_type_factory = test_eb->getClassFactory("custom_type");
assert(custom_type_factory != 0);
// Check the factory has the attributes we described on the custom
// type.
MapType::const_iterator J = custom_type_factory->m_attributes.find("test_custom_type_attr");
assert(J != custom_type_factory->m_attributes.end());
assert(J->second.isString());
assert(J->second.String() == "test_value");
// Create an instance of our custom type, ensuring that it works.
test_ent = test_eb->newEntity("1", 1, "custom_type", attributes);
assert(test_ent != 0);
// Reset val.
val = Atlas::Message::Element();
assert(val.isNone());
// Check the custom type has the attribute we passed in when creating
// the instance.
assert(test_ent->getAttr("funky", val));
assert(val.isString());
assert(val.String() == "true");
// Reset val.
val = Atlas::Message::Element();
assert(val.isNone());
// Check the custom type has the attribute described when the
// custom type was installed.
assert(test_ent->getAttr("test_custom_type_attr", val));
assert(val.isString());
assert(val.String() == "test_value");
// Check that creating an entity of a type we know we have not yet
// installed results in a null pointer.
assert(test_eb->newEntity("1", 1, "custom_inherited_type", attributes) == 0);
// Set up a type description for a second new type which inherits
// from the first, and install it.
{
Root custom_inherited_type_description;
MapType attrs;
MapType test_custom_type_attr;
test_custom_type_attr["default"] = "test_inherited_value";
test_custom_type_attr["visibility"] = "public";
attrs["test_custom_inherited_type_attr"] = test_custom_type_attr;
custom_inherited_type_description->setAttr("attributes", attrs);
custom_inherited_type_description->setId("custom_inherited_type");
custom_inherited_type_description->setParents(std::list<std::string>(1, "custom_type"));
std::string dependent, reason;
ret = test_ruleset.installEntityClass("custom_inherited_type", "custom_type", custom_inherited_type_description, dependent, reason);
assert(ret == 0);
assert(dependent.empty());
assert(reason.empty());
}
// Check that the factory dictionary does contain the factory for
// the second newly installed type
EntityKit * custom_inherited_type_factory = test_eb->getClassFactory("custom_inherited_type");
assert(custom_inherited_type_factory != 0);
// Check that the factory has inherited the attributes from the
// first custom type
J = custom_inherited_type_factory->m_attributes.find("test_custom_type_attr");
assert(J != custom_inherited_type_factory->m_attributes.end());
assert(J->second.isString());
assert(J->second.String() == "test_value");
// Check that the factory has the attributes specified when installing
// it
J = custom_inherited_type_factory->m_attributes.find("test_custom_inherited_type_attr");
assert(J != custom_inherited_type_factory->m_attributes.end());
assert(J->second.isString());
assert(J->second.String() == "test_inherited_value");
// Creat an instance of the second custom type, ensuring it works.
test_ent = test_eb->newEntity("1", 1, "custom_inherited_type", attributes);
assert(test_ent != 0);
// Reset val.
val = Atlas::Message::Element();
assert(val.isNone());
// Check the custom type has the attribute we passed in when creating
// the instance.
assert(test_ent->getAttr("funky", val));
assert(val.isString());
assert(val.String() == "true");
// Reset val.
val = Atlas::Message::Element();
assert(val.isNone());
// Check the instance of the second custom type has the attribute
// described when the first custom type was installed.
assert(test_ent->getAttr("test_custom_type_attr", val));
assert(val.isString());
assert(val.String() == "test_value");
// Reset val.
val = Atlas::Message::Element();
assert(val.isNone());
// Check the custom type has the attribute described when the
// second custom type was installed
assert(test_ent->getAttr("test_custom_inherited_type_attr", val));
assert(val.isString());
assert(val.String() == "test_inherited_value");
// FIXME TODO Modify a type, and ensure attribute propagate to inherited types.
// Make sure than attempting to modify a non-existant type fails
{
Anonymous nonexistant_description;
MapType attrs;
MapType test_custom_type_attr;
test_custom_type_attr["default"] = "no_value";
test_custom_type_attr["visibility"] = "public";
attrs["no_custom_type_attr"] = test_custom_type_attr;
nonexistant_description->setId("nonexistant");
nonexistant_description->setAttr("attributes", attrs);
ret = test_ruleset.modifyRule("nonexistant", nonexistant_description);
assert(ret != 0);
}
// Modify the second custom type removing its custom attribute
{
Anonymous new_custom_inherited_type_description;
new_custom_inherited_type_description->setId("custom_inherited_type");
new_custom_inherited_type_description->setAttr("attributes", MapType());
// No parents
ret = test_ruleset.modifyRule("custom_inherited_type",
new_custom_inherited_type_description);
assert(ret != 0);
// empty parents
new_custom_inherited_type_description->setParents(std::list<std::string>());
ret = test_ruleset.modifyRule("custom_inherited_type",
new_custom_inherited_type_description);
assert(ret != 0);
// wrong parents
new_custom_inherited_type_description->setParents(std::list<std::string>(1, "wrong_parent"));
ret = test_ruleset.modifyRule("custom_inherited_type",
new_custom_inherited_type_description);
assert(ret != 0);
new_custom_inherited_type_description->setParents(std::list<std::string>(1, "custom_type"));
ret = test_ruleset.modifyRule("custom_inherited_type",
new_custom_inherited_type_description);
assert(ret == 0);
}
// Check that the factory dictionary does contain the factory for
// the second newly installed type
custom_inherited_type_factory = test_eb->getClassFactory("custom_inherited_type");
assert(custom_inherited_type_factory != 0);
// Check that the factory has inherited the attributes from the
// first custom type
J = custom_inherited_type_factory->m_attributes.find("test_custom_type_attr");
assert(J != custom_inherited_type_factory->m_attributes.end());
assert(J->second.isString());
assert(J->second.String() == "test_value");
// Check that the factory no longer has the attributes we removed
J = custom_inherited_type_factory->m_attributes.find("test_custom_inherited_type_attr");
assert(J == custom_inherited_type_factory->m_attributes.end());
// Creat an instance of the second custom type, ensuring it works.
test_ent = test_eb->newEntity("1", 1, "custom_inherited_type", attributes);
assert(test_ent != 0);
// Reset val.
val = Atlas::Message::Element();
assert(val.isNone());
// Make sure test nonexistant attribute isn't present
assert(!test_ent->getAttr("nonexistant", val));
// Make sure nonexistant attribute isn't present
assert(!test_ent->getAttr("nonexistant_attribute", val));
// Reset val.
val = Atlas::Message::Element();
assert(val.isNone());
// Check the custom type has the attribute we passed in when creating
// the instance.
assert(test_ent->getAttr("funky", val));
assert(val.isString());
assert(val.String() == "true");
// Reset val.
val = Atlas::Message::Element();
assert(val.isNone());
// Check the instance of the second custom type has the attribute
// described when the first custom type was installed.
assert(test_ent->getAttr("test_custom_type_attr", val));
assert(val.isString());
assert(val.String() == "test_value");
// Reset val.
val = Atlas::Message::Element();
assert(val.isNone());
// Check the custom type has the attribute described when the
// second custom type was installed
assert(!test_ent->getAttr("test_custom_inherited_type_attr", val));
// Modify the first custom type removing its custom attribute
{
Anonymous new_custom_type_description;
new_custom_type_description->setId("custom_type");
new_custom_type_description->setAttr("attributes", MapType());
new_custom_type_description->setParents(std::list<std::string>(1, "thing"));
ret = test_ruleset.modifyRule("custom_type", new_custom_type_description);
assert(ret == 0);
}
// Check that the factory dictionary now contains a factory for
// the custom type we just installed.
custom_type_factory = test_eb->getClassFactory("custom_type");
assert(custom_type_factory != 0);
// Check the factory has the attributes we described on the custom
// type.
J = custom_type_factory->m_attributes.find("test_custom_type_attr");
assert(J == custom_type_factory->m_attributes.end());
// Create an instance of our custom type, ensuring that it works.
test_ent = test_eb->newEntity("1", 1, "custom_type", attributes);
assert(test_ent != 0);
// Reset val.
val = Atlas::Message::Element();
assert(val.isNone());
// Check the custom type has the attribute we passed in when creating
// the instance.
assert(test_ent->getAttr("funky", val));
assert(val.isString());
assert(val.String() == "true");
// Reset val.
val = Atlas::Message::Element();
assert(val.isNone());
// Check the custom type no longer has the custom attribute
assert(!test_ent->getAttr("test_custom_type_attr", val));
// Check that the factory dictionary does contain the factory for
// the second newly installed type
custom_inherited_type_factory = test_eb->getClassFactory("custom_inherited_type");
assert(custom_inherited_type_factory != 0);
// Check that the factory no longer has inherited the attributes
// from the first custom type which we removed
J = custom_inherited_type_factory->m_attributes.find("test_custom_type_attr");
assert(J == custom_inherited_type_factory->m_attributes.end());
// Check that the factory no longer has the attributes we removed
J = custom_inherited_type_factory->m_attributes.find("test_custom_inherited_type_attr");
assert(J == custom_inherited_type_factory->m_attributes.end());
// Creat an instance of the second custom type, ensuring it works.
test_ent = test_eb->newEntity("1", 1, "custom_inherited_type", attributes);
assert(test_ent != 0);
// Reset val.
val = Atlas::Message::Element();
assert(val.isNone());
// Make sure test nonexistant attribute isn't present
assert(!test_ent->getAttr("nonexistant", val));
// Make sure nonexistant attribute isn't present
assert(!test_ent->getAttr("nonexistant_attribute", val));
// Reset val.
val = Atlas::Message::Element();
assert(val.isNone());
// Check the custom type has the attribute we passed in when creating
// the instance.
assert(test_ent->getAttr("funky", val));
assert(val.isString());
assert(val.String() == "true");
// Reset val.
val = Atlas::Message::Element();
assert(val.isNone());
// Check the instance of the second custom type has the attribute
// described when the first custom type was installed.
assert(!test_ent->getAttr("test_custom_type_attr", val));
// Reset val.
val = Atlas::Message::Element();
assert(val.isNone());
// Check the custom type has the attribute described when the
// second custom type was installed
assert(!test_ent->getAttr("test_custom_inherited_type_attr", val));
// Add more custom attributes to the first type
{
Anonymous new_custom_type_description;
MapType attrs;
MapType test_custom_type_attr;
test_custom_type_attr["default"] = "test_value";
test_custom_type_attr["visibility"] = "public";
attrs["test_custom_type_attr"] = test_custom_type_attr;
MapType new_custom_type_attr;
new_custom_type_attr["default"] = "new_value";
new_custom_type_attr["visibility"] = "public";
attrs["new_custom_type_attr"] = new_custom_type_attr;
new_custom_type_description->setId("custom_type");
new_custom_type_description->setAttr("attributes", attrs);
new_custom_type_description->setParents(std::list<std::string>(1, "thing"));
ret = test_ruleset.modifyRule("custom_type", new_custom_type_description);
assert(ret == 0);
}
// Check that the factory dictionary now contains a factory for
// the custom type we just installed.
custom_type_factory = test_eb->getClassFactory("custom_type");
// Check the factory has the attributes we described on the custom
// type.
J = custom_type_factory->m_attributes.find("test_custom_type_attr");
assert(J != custom_type_factory->m_attributes.end());
assert(J->second.isString());
assert(J->second.String() == "test_value");
J = custom_type_factory->m_attributes.find("new_custom_type_attr");
assert(J != custom_type_factory->m_attributes.end());
assert(J->second.isString());
assert(J->second.String() == "new_value");
// Create an instance of our custom type, ensuring that it works.
test_ent = test_eb->newEntity("1", 1, "custom_type", attributes);
assert(test_ent != 0);
// Reset val.
val = Atlas::Message::Element();
assert(val.isNone());
// Check the custom type has the attribute we passed in when creating
// the instance.
assert(test_ent->getAttr("funky", val));
assert(val.isString());
assert(val.String() == "true");
// Reset val.
val = Atlas::Message::Element();
assert(val.isNone());
// Check the custom type now has the custom attributes
assert(test_ent->getAttr("test_custom_type_attr", val));
assert(val.isString());
assert(val.String() == "test_value");
assert(test_ent->getAttr("new_custom_type_attr", val));
assert(val.isString());
assert(val.String() == "new_value");
// Check that the factory dictionary does contain the factory for
// the second newly installed type
custom_inherited_type_factory = test_eb->getClassFactory("custom_inherited_type");
assert(custom_inherited_type_factory != 0);
// Check that the factory now has inherited the attributes
// from the first custom type
J = custom_inherited_type_factory->m_attributes.find("test_custom_type_attr");
assert(J != custom_inherited_type_factory->m_attributes.end());
assert(J->second.isString());
assert(J->second.String() == "test_value");
J = custom_inherited_type_factory->m_attributes.find("new_custom_type_attr");
assert(J != custom_inherited_type_factory->m_attributes.end());
assert(J->second.isString());
assert(J->second.String() == "new_value");
// Check that the factory no longer has the attributes we removed
J = custom_inherited_type_factory->m_attributes.find("test_custom_inherited_type_attr");
assert(J == custom_inherited_type_factory->m_attributes.end());
// Creat an instance of the second custom type, ensuring it works.
test_ent = test_eb->newEntity("1", 1, "custom_inherited_type", attributes);
assert(test_ent != 0);
// Reset val.
val = Atlas::Message::Element();
assert(val.isNone());
// Make sure test nonexistant attribute isn't present
assert(!test_ent->getAttr("nonexistant", val));
// Make sure nonexistant attribute isn't present
assert(!test_ent->getAttr("nonexistant_attribute", val));
// Reset val.
val = Atlas::Message::Element();
assert(val.isNone());
// Check the custom type has the attribute we passed in when creating
// the instance.
assert(test_ent->getAttr("funky", val));
assert(val.isString());
assert(val.String() == "true");
// Reset val.
val = Atlas::Message::Element();
assert(val.isNone());
// Check the instance of the second custom type has the attribute
// described when the first custom type was installed.
assert(test_ent->getAttr("test_custom_type_attr", val));
assert(val.isString());
assert(val.String() == "test_value");
assert(test_ent->getAttr("new_custom_type_attr", val));
assert(val.isString());
assert(val.String() == "new_value");
// Reset val.
val = Atlas::Message::Element();
assert(val.isNone());
// Check the custom type no longer has the attribute described when the
// second custom type was installed
assert(!test_ent->getAttr("test_custom_inherited_type_attr", val));
}
}