bool DirectedGraph::addEdge(int fromNodeId, int toNodeId) {
if (hasEdge(fromNodeId, toNodeId))
return false;
if (!hasNode(fromNodeId))
addNode(fromNodeId);
if (!hasNode(toNodeId))
addNode(toNodeId);
ListType* fromNeighbors = inNeighborsTable[toNodeId];
fromNeighbors->push_back(fromNodeId);
ListType* toNeighbors = outNeighborsTable[fromNodeId];
toNeighbors->push_back(toNodeId);
edgeCount++;
return true;
}
static void addTypeToList(const Root & type, ListType & typeList)
{
typeList.push_back(type->getId());
Element children;
if (type->copyAttr("children", children) != 0) {
return;
}
if (!children.isList()) {
log(ERROR, compose("Type %1 children attribute has type %2 instead of "
"string.", type->getId(),
Element::typeName(children.getType())));
return;
}
ListType::const_iterator I = children.List().begin();
ListType::const_iterator Iend = children.List().end();
for (; I != Iend; ++I) {
Root child = Inheritance::instance().getClass(I->asString());
if (!child.isValid()) {
log(ERROR, compose("Unable to find %1 in inheritance table",
I->asString()));
continue;
}
addTypeToList(child, typeList);
}
}
Atlas::Message::Element EntityEditor::createPosition2dElement()
{
ListType list;
list.push_back(createFloatElement());
list.push_back(createFloatElement());
return Element(list);
}
ListType CyPy_Element::sequenceAsElement(const Py::Sequence& sequence)
{
ListType res;
for (auto& entry : sequence) {
res.push_back(asElement(entry));
}
return res;
}
ListType CyPy_Element::listAsElement(const Py::List& list)
{
ListType res;
for (auto& entry : list) {
res.push_back(asElement(entry));
}
return res;
}
int PyListObject_asElement(PyObject * list, ListType & res)
{
PyMessage * item;
int len = PyList_Size(list);
for(int i = 0; i < len; i++) {
item = (PyMessage *)PyList_GetItem(list, i);
if (PyMessage_Check(item)) {
res.push_back(*(item->m_obj));
} else {
Element o;
if (PyObject_asMessageElement((PyObject*)item, o) == 0) {
res.push_back(o);
} else {
debug( std::cout << "Python to atlas conversion failed on element " << i << " of list" << std::endl << std::flush; );
return -1;
}
}
}
int Gear_OscInput::configuredOscHandler(const char *path, const char *types, lo_arg **argv, int argc, void *data, void *user_data)
{
Gear_OscInput *gearOscInput = (Gear_OscInput*)user_data;
std::cout << "Osc message received : " << std::endl;
std::cout << "path: " << path << std::endl;
OscMessageType message;
ListType list;
message.setPath(std::string(path));
for (int i=0; i<argc; i++)
{
std::cout << "arg " << i << " " << types[i] << std::endl;
if (types[i]==LO_FLOAT)
{
ValueType *valuet = new ValueType();
valuet->setValue((float)argv[i]->f);
list.push_back(valuet);
} else if (types[i]==LO_INT32)
{
ValueType *valuet = new ValueType();
valuet->setValue((float)argv[i]->i32);
list.push_back(valuet);
} else if (types[i]==LO_DOUBLE)
{
ValueType *valuet = new ValueType();
valuet->setValue((float)argv[i]->d);
list.push_back(valuet);
} else if (types[i]==LO_STRING)
{
StringType *stringt = new StringType();
stringt->setValue(argv[i]->s);
list.push_back(stringt);
}
}
message.setArgs(list);
ScopedLock scopedLock(gearOscInput->_mutex);
gearOscInput->_messages.push_back(message);
return 0;
}
void Player::addToEntity(const Atlas::Objects::Entity::RootEntity & ent) const
{
Account::addToEntity(ent);
ListType typeList;
std::set<std::string>::const_iterator I = Player::playableTypes.begin();
std::set<std::string>::const_iterator Iend = Player::playableTypes.end();
for (; I != Iend; ++I) {
typeList.push_back(Element(*I));
}
ent->setAttr("character_types", typeList);
}
Element CyPy_Element::asElement(const Py::Object& o)
{
if (o.isLong()) {
return Py::Long(o).as_long();
}
if (o.isFloat()) {
return Py::Float(o).as_double();
}
if (o.isString()) {
return o.as_string();
}
if (CyPy_ElementList::check(o)) {
return CyPy_ElementList::value(o);
}
if (CyPy_ElementMap::check(o)) {
return CyPy_ElementMap::value(o);
}
if (CyPy_Operation::check(o)) {
return CyPy_Operation::value(o)->asMessage();
}
if (CyPy_RootEntity::check(o)) {
return CyPy_RootEntity::value(o)->asMessage();
}
if (CyPy_Root::check(o)) {
return CyPy_Root::value(o)->asMessage();
}
if (CyPy_Oplist::check(o)) {
auto& oplist = CyPy_Oplist::value(o);
ListType list;
for (auto& entry : oplist) {
list.push_back(entry->asMessage());
}
return list;
}
if (CyPy_Location::check(o)) {
MapType map;
CyPy_Location::value(o).addToMessage(map);
return map;
}
if (o.isList()) {
return listAsElement(Py::List(o));
}
if (o.isDict()) {
return dictAsElement(Py::Dict(o));
}
if (o.isSequence()) {
return sequenceAsElement(Py::Sequence(o));
}
if (o.isNone()) {
return Element();
}
throw Py::TypeError(String::compose("Contained object (of type %1) could not be converted to an Element.", o.type().as_string()));
}
void Gear_PackList::runVideo()
{
ListType *listType = _LIST_OUT->type();
if (_LIST_IN->connected())
listType->assign(_LIST_IN->type()->begin(), _LIST_IN->type()->end());
else
clearList();
listType->push_back(_STR1->type());
}
bool ParseResult::append(ParseResult &&p) {
ListType* vect;
if (isEmpty()) {
assert(result_ == nullptr);
resultKind_ = p.resultKind_;
isList_ = true;
vect = new ListType();
result_ = vect;
}
else {
assert(isList_);
vect = reinterpret_cast<ListType*>(result_);
}
if (p.isList_ || p.resultKind_ != resultKind_)
return false;
vect->push_back(p.result_);
p.release();
return true;
}
void Gear_UnpackList::runVideo()
{
//std::cout << name() << "::: size:: " << _LIST_IN->type()->size() << std::endl;
if (!_LIST_IN->connected() ||
_LIST_IN->type()->empty())
{
_LIST_OUT->sleeping(true); // TODO: the sleeping mechanism just doesn't work
return;
}
_LIST_OUT->sleeping(false);
ListType *listType = _LIST_OUT->type();
const AbstractType *type = _LIST_IN->type()->front();
// XXX Maybe there's a more efficient way than clearing/populating each time but this
// is safe memory-wise.
clearList();
// Copy
const ListType* inputList = _LIST_IN->type();
for(ListType::const_iterator it=inputList->begin() + 1; it!=inputList->end(); ++it)
listType->push_back( (*it)->clone() );
//std::cout << "got something " << type->typeName() << std::endl;
//for (ListType::const_iterator it = _LIST_IN->type()->begin(); it != _LIST_IN->type()->end(); ++it)
//listType->assign(_LIST_IN->type()->begin(), _LIST_IN->type()->end());
if ((_STR_OUT->connected()) && type->typeName() == StringType().typeName())
{
//std::cout << "sending str out: " << ((StringType*)type)->value() << std::endl;
_STR_OUT->type()->copyFrom(*type);
return;
}
else if ((_VAL_OUT->connected()) && type->typeName() == ValueType().typeName())
{
//std::cout << "sending val out: " << ((ValueType*)type)->value() << std::endl;
_VAL_OUT->type()->copyFrom(*type);
return;
}
else if ((_ENUM_OUT->connected()) && type->typeName() == EnumType().typeName())
{
//std::cout << "sending val out: " << ((ValueType*)type)->value() << std::endl;
_ENUM_OUT->type()->copyFrom(*type);
return;
}
else if ((_CHANNEL_OUT->connected()) && type->typeName() == VideoChannelType().typeName())
{
//std::cout << "sending val out: " << ((ValueType*)type)->value() << std::endl;
_CHANNEL_OUT->type()->copyFrom(*type);
return;
}
else if ((_VIDEO_OUT->connected()) && type->typeName() == VideoRGBAType().typeName())
{
//std::cout << "sending val out: " << ((ValueType*)type)->value() << std::endl;
_VIDEO_OUT->type()->copyFrom(*type);
return;
}
else if ((_AREA_OUT->connected()) && type->typeName() == AreaType().typeName())
{
//std::cout << "sending val out: " << ((ValueType*)type)->value() << std::endl;
_AREA_OUT->type()->copyFrom(*type);
return;
}
}
int main(int argc, char** argv)
{
std::string atlas_xml_path;
char * srcdir_env = getenv("srcdir");
if (srcdir_env != 0) {
atlas_xml_path = srcdir_env;
atlas_xml_path += "/";
}
atlas_xml_path += "../../protocol/spec/atlas.xml";
try {
Atlas::Objects::loadDefaults(atlas_xml_path);
} catch(Atlas::Objects::DefaultLoadingException e) {
std::cout << "DefaultLoadingException: "
<< e.getDescription() << std::endl;
}
Root root = Atlas::Objects::objectDefinitions.find("root")->second;
Root root_inst;
root_inst->setAttr("id", std::string("root_instantiation"));
assert(root->getAttr("id").asString() == "root");
assert(root_inst->getAttr("id").asString() == "root_instantiation");
assert(root->getAttr("parents").asList().size() == 0);
assert(root_inst->getAttr("parents").asList().size() == 1);
assert((*root_inst->getAttr("parents").asList().begin()).asString() ==
"root");
Look look = smart_dynamic_cast<Look>(objectDefinitions.find("look")->second);
Look look_inst;
look_inst->setAttr("id", std::string("look_instantiation"));
assert(look->getAttr("id").asString() == "look");
assert(look_inst->getAttr("id").asString() == "look_instantiation");
assert(look->getAttr("parents").asList().size() == 1);
assert((*look->getAttr("parents").asList().begin()).asString() ==
"perceive");
assert(look_inst->getAttr("parents").asList().size() == 1);
assert((*look_inst->getAttr("parents").asList().begin()).asString() ==
"look");
Account acct = smart_dynamic_cast<Account>(objectDefinitions.find("account")->second);
Account acct_inst;
acct_inst->setAttr("id", std::string("account_instantiation"));
assert(acct->getAttr("id").asString() == "account");
assert(acct_inst->getAttr("id").asString() == "account_instantiation");
assert(acct->getAttr("parents").asList().size() == 1);
assert((*acct->getAttr("parents").asList().begin()).asString() ==
"admin_entity");
assert(acct_inst->getAttr("parents").asList().size() == 1);
assert((*acct_inst->getAttr("parents").asList().begin()).asString() ==
"account");
{
Atlas::Objects::Entity::Anonymous anon;
anon->setLoc("12345");
ListType velocity;
velocity.push_back(1.4);
velocity.push_back(2.4);
velocity.push_back(3.4);
anon->setVelocityAsList(velocity);
ListType bbox;
bbox.push_back(1.4);
bbox.push_back(2.4);
bbox.push_back(3.4);
bbox.push_back(2.4);
anon->setAttr("bbox", bbox);
Atlas::Objects::Operation::Move move;
move->setFrom("123456");
move->setTo("123456");
move->setSeconds(12345678);
move->setId("123456");
move->setArgs1(anon);
Atlas::Objects::Operation::Sight sight;
sight->setFrom("123456");
sight->setTo("123456");
sight->setSeconds(12345678);
sight->setId("123456");
sight->setArgs1(move);
Atlas::Message::MapType map;
sight->addToMessage(map);
std::cout << map.size() << std::flush;
assert(map.size() == 7);
assert(map["objtype"].String() == "op");
assert(map["from"].String() == "123456");
assert(map["to"].String() == "123456");
assert(map["seconds"].Float() == 12345678);
assert(map["id"].String() == "123456");
assert(map["args"].List().size() == 1);
}
}
