C++ ListType::push_back方法代码示例

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);


    }

}