Apache Thrift: return list / container

Question

I made a simple similar file:

thrifttest.thrift

namespace cpp thrifttest namespace d thrifttest namespace java thrifttest namespace php thrifttest namespace perl thrifttest service Test { list<i64> ping(); } 

and in the shell runs "trift -gen cpp thrifttest.thrift"

However, when I looked at gen-cpp / Test_server.skeleton.cpp, it made the i64 list a parameter, not a return type:

Test_server.skeleton.cpp (excerpt)

 void ping(std::vector<int64_t> & _return) { // Your implementation goes here printf("ping\n"); } 

and in my server.cpp program, after creating the ping () function, which returns "std :: vector &", the compiler complains that

error: cannot allocate an object of abstract type 'TestHandler server.cpp: 30: 7: note: because the following virtual functions are pure in "TestHandler":

this is the complete code for server.cpp server.cpp

 #include <thrift/concurrency/ThreadManager.h> #include <thrift/concurrency/PosixThreadFactory.h> #include <thrift/protocol/TBinaryProtocol.h> #include <thrift/server/TSimpleServer.h> #include <thrift/server/TThreadPoolServer.h> #include <thrift/server/TThreadedServer.h> #include <thrift/transport/TServerSocket.h> #include <thrift/transport/TTransportUtils.h> #include <iostream> #include <stdexcept> #include <sstream> #include "gen-cpp/Test.h" using namespace std; using namespace apache::thrift; using namespace apache::thrift::protocol; using namespace apache::thrift::transport; using namespace apache::thrift::server; using boost::shared_ptr; using namespace thrifttest; using namespace boost; unsigned long giant[100]; class TestHandler : virtual public TestIf { public: TestHandler() { for (int i = 0; i < 100; i++) { giant[i] = -1; } } std::vector<int64_t> & ping() { return (std::vector<int64_t> &)giant; } void ping(std::vector<int64_t> & bla) {} }; int main(int argc, char **argv) { shared_ptr<TestHandler> handler(new TestHandler()); shared_ptr<TProcessor> processor(new TestProcessor(handler)); shared_ptr<TServerTransport> serverTransport(new TServerSocket(port)); shared_ptr<TTransportFactory> transportFactory(new TBufferedTransportFactory()); shared_ptr<TProtocolFactory> protocolFactory(new TBinaryProtocolFactory()); TSimpleServer server(processor, serverTransport, transportFactory, protocolFactory); printf("Starting the server...\n"); server.serve(); printf("done.\n"); return 0; } 

Answer 1

I accidentally stumbled upon an article ( fooobar.com/questions/1490614 / ... ) that discussed this exact problem (although the answer didn’t work in my case). It turns out thrift uses the pass-by-reference syntax, although "Thrift uses the pass-by-value model" - Gupta . So here is an example:

.thrift file

 service Test { list<string> ping(); } 

Server side

 void ping(std::vector<string> & _return) { _return.push_back("hello"); //initialize the vector _return with values "hello","world" _return.push_back("world"); } 

Client side

 std::vector<string> result; //create vector "result" for storing the values client.ping(result); printf("%s %s!\n", result[0].c_str(), result[1].c_str()); //c_str() turns the vector string into a C-style string 

Client exit (after starting the server)

Hello World!

and thank you for the lack of documentation, I had an explosion! # 4hoursgoogling & crying

Answer 2

Apart from your question, there are a few drawbacks with returning a container class directly.

Instead, I would pack the container into a struct and return it. Thus, you can add any fields later without the need for a new service method. Moreover, the container itself can be omitted if it becomes necessary - you cannot return a NULL container for technical reasons using Thrift.