void ProvidersTest::test_OutfitProviders() { Atlas::Message::Element value; //Check if we get the right entity in outfit query auto provider = CreateProvider( { "entity", "outfit", "hands" }); provider->value(value, QueryContext { *m_ch1 }); assert(value.Ptr() == m_glovesEntity); //Check for outfit's property query provider = CreateProvider( { "entity", "outfit", "hands", "color" }); provider->value(value, QueryContext { *m_ch1 }); assert(value.String() == "brown"); //Check if we get the right entity in nested outfit query provider = CreateProvider( { "entity", "outfit", "hands", "outfit", "thumb" }); provider->value(value, QueryContext { *m_ch1 }); assert(value.Ptr() == m_cloth); //Check for nested outfit's property provider = CreateProvider( { "entity", "outfit", "hands", "outfit", "thumb", "color" }); provider->value(value, QueryContext { *m_ch1 }); assert(value.String() == "green"); }
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 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()); } }
Py::Object CyPy_Element::asPyObject(const Atlas::Message::Element& obj, bool useNativePythonType) { switch (obj.getType()) { case Element::TYPE_INT: return Py::Long(obj.Int()); case Element::TYPE_FLOAT: return Py::Float(obj.Float()); case Element::TYPE_STRING: return Py::String(obj.String()); case Element::TYPE_MAP: return mapAsPyObject(obj.Map(), useNativePythonType); case Element::TYPE_LIST: return listAsPyObject(obj.List(), useNativePythonType); default: break; } return Py::None(); }
void Property<std::string>::set(const Atlas::Message::Element & e) { if (e.isString()) { this->m_data = e.String(); } }
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); }
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)); } }