LoadDefaultsDecoder::LoadDefaultsDecoder(const std::string& filename) { std::fstream stream; stream.open(filename.c_str(), std::ios::in); if (!stream) { throw DefaultLoadingException("Failed to open file " + filename); } //replace following code with: //getCodecByName(const std::string& name, Stream& stream, Bridge* bridge) //typedef list<Atlas::Factory<Atlas::Codec<std::iostream> >*> FactoryCodecs; //FactoryCodecs *myCodecs = Factory<Codec<std::iostream> >::factories(); //FactoryCodecs::iterator i; //Atlas::Codec<std::iostream> *codec = NULL; //for (i = myCodecs->begin(); i != myCodecs->end(); ++i) //if((*i)->getName() == "XML") //codec = (*i)->New(Codec<std::iostream>::Parameters((iostream&)stream, this)); //end of replace Atlas::Codec *codec = new Atlas::Codecs::XML(stream, *this); while(stream) { codec->poll(); } delete codec; MapType anonymous_obj; m_objects["anonymous"] = anonymous_obj; MapType generic_obj; m_objects["generic"] = generic_obj; fillDefaults(); }
// This sends a very simple message to c void helloWorld(Atlas::Codec & c) { std::cout << "Sending hello world message... " << std::flush; c.streamMessage(); c.mapStringItem("hello", "world"); c.mapEnd(); std::cout << "done." << std::endl; }
std::string object2String(const Root& obj) { DebugBridge bridge; std::stringstream stream; Atlas::Codec *codec; codec = new Atlas::Codecs::XML(stream, bridge); assert(codec); codec->streamBegin(); Atlas::Objects::ObjectsEncoder eno(*codec); eno.streamObjectsMessage(obj); codec->streamEnd(); delete codec; return stream.str(); }
int main(int argc, char** argv) { // The socket that connects us to the server tcp_socket_stream connection; std::cout << "Connecting..." << std::flush; // Connect to the server if(argc>1) { connection.open(argv[1], 6767); } else { connection.open("127.0.0.1", 6767); } // The DebugBridge puts all that comes through the codec on cout DebugBridge bridge; // Do client negotiation with the server Atlas::Net::StreamConnect conn("simple_client", connection); std::cout << "Negotiating... " << std::flush; // conn.poll() does all the negotiation while (conn.getState() == Atlas::Net::StreamConnect::IN_PROGRESS) { conn.poll(); } std::cout << "done" << std::endl; // Check whether negotiation was successful if (conn.getState() == Atlas::Net::StreamConnect::FAILED) { std::cerr << "Failed to negotiate" << std::endl; return 2; } // Negotiation was successful // Get the codec that negotiation established Atlas::Codec * codec = conn.getCodec(bridge); // This should always be sent at the beginning of a session codec->streamBegin(); // Say hello to the server helloWorld(*codec); connection << std::flush; std::cout << "Sleeping for 2 seconds... " << std::flush; // Sleep a little sleep(2); std::cout << "done." << std::endl; // iosockinet::operator bool() returns false if the connection was broken if (!connection) { std::cout << "Server exited." << std::endl; } else { // It was not broken by the server, so we'll close ourselves std::cout << "Closing connection... " << std::flush; // This should always be sent at the end of a session codec->streamEnd(); connection << std::flush; // Close the socket connection.close(); std::cout << "done." << std::endl; } return 0; }
void testXML() { RootEntity human; human->setId("foo"); Move move_op; move_op->setFrom(std::string("bar")); std::vector<Root> move_args(1); move_args[0] = human; move_op->setArgs(move_args); Atlas::Message::ListType velocity; velocity.push_back(2.0); velocity.push_back(1.0); velocity.push_back(0.0); human->setVelocityAsList(velocity); // typedef BaseObjectData *(*alloc_func)(); // alloc_func alloc_entity = &Entity::RootEntityDataInstance::alloc; // BaseObjectData *bod = alloc_entity(); //Root human2(bod); Root human2 = Atlas::Objects::factory<Atlas::Objects::Entity::RootEntityData>("root_enitty", Atlas::Objects::Entity::RootEntity()->getClassNo()); std::cout<<"human.id="<<human->getId()<<std::endl; std::cout<<"human2.id="<<human2->getId()<<std::endl; #if 0 typedef std::list<Atlas::Factory<Atlas::Codec >*> FactoryCodecs; FactoryCodecs *myCodecs = &Factory<Codec >::factories(); FactoryCodecs::iterator i; std::cout<<"myCodecs: "<<myCodecs->size(); for (i = myCodecs->begin(); i != myCodecs->end(); ++i) std::cout<<":"<<(*i)->getName(); std::cout<<std::endl; #endif //DebugBridge bridge; TestDecoder bridge; #if USE_FILE fstream stream; 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"; stream.open(atlas_xml_path, std::ios::in); assert(!!stream); #else std::stringstream stream; #endif // typedef std::list<Atlas::Factory<Atlas::Codec >*> FactoryCodecs; // FactoryCodecs *myCodecs = &Factory<Codec >::factories(); // FactoryCodecs::iterator codec_i; // Atlas::Codec *codec = NULL; // for(codec_i = myCodecs->begin(); codec_i != myCodecs->end(); ++codec_i) // { // std::cout<<(*codec_i)->getName()<<std::endl; // if ((*codec_i)->getName() == "XML") { // codec = (*codec_i)->New(Codec::Parameters(stream, &bridge)); // } // } // assert(codec); Account account; Login l; account->setAttr("id", std::string("al")); account->setAttr("password", std::string("ping")); //list<Message::Object> args(1,account->asObject()); //l->setArgsAsList(args); std::vector<Root> args(1); args[0] = account; l->setArgs(args); //coder->streamObjectsMessage((Root&)l); //<map><list name="args"><map><std::string name="id">al</strin //g></map></list><list name="parents"><std::string>root</std::string></list><std::string name="ob //jtype">op_definition</std::string></map> Atlas::Codec *codec; #if USE_XML codec = new Atlas::Codecs::XML((std::iostream&)stream, bridge); #else codec = new Atlas::Codecs::Packed(stream, bridge); #endif assert(codec); #if USE_FILE while(stream) { codec->poll(); //std::cout<<"--------"<<std::endl; } #else codec->streamBegin(); Atlas::Objects::ObjectsEncoder eno(*codec); // eno.streamObjectsMessage(move_op); eno.streamObjectsMessage(l); Anonymous e; eno.streamObjectsMessage(e); e->setId("foo"); eno.streamObjectsMessage(e); // Atlas::Message::Encoder en(codec); // en.streamObjectsMessage(human->asObject()); codec->streamEnd(); std::cout<<std::endl<<stream.str()<<std::endl; //[$from=bar(args=[$id=foo])][$id=foo] //<atlas><map><std::string name="from">bar</std::string><list name="args"><map><std::string name="id">foo</std::string></map></list></map><map><std::string name="id">foo</std::string></map></atlas> #endif delete codec; }
int convert(const std::string & file_in, const std::string & codec_in, const std::string & file_out, const std::string & codec_out) { std::cout << "Convert " << codec_in << " to " << codec_out << std::endl; std::fstream in, out; in.open( file_in.c_str(), std::ios::in ); if (!in.is_open()) { std::cerr << "Unable to open " << file_in << " for input" << std::endl << std::flush; return 1; } out.open( file_out.c_str(), std::ios::out ); if (!out.is_open()) { std::cerr << "Unable to open " << file_out << " for output" << std::endl << std::flush; return 1; } std::cout << "Reading... "; Atlas::Message::QueuedDecoder decoder; Atlas::Codec *inCodec = getCodec(codec_in, in, decoder); while (!in.eof()) { inCodec->poll(true); } std::cout << "done." << std::endl; std::cout << "Writing... "; Atlas::Codec * outCodec = getCodec(codec_out, out, decoder); Atlas::Bridge * bridge; if (option_format) { Atlas::Formatter * format; bridge = format = new Atlas::Formatter(out, *outCodec); if (option_spacing != -1) { format->setSpacing(option_spacing); } } else { bridge = outCodec; } Atlas::Message::Encoder encoder(*bridge); encoder.streamBegin(); while (decoder.queueSize() > 0 ) { Atlas::Message::MapType msg(decoder.popMessage()); encoder.streamMessageElement(msg); } encoder.streamEnd(); std::cout << "done." << std::endl; out.close(); in.close(); return 0; }