mirror of
https://github.com/valitydev/thrift.git
synced 2024-11-07 02:45:22 +00:00
49ff8b123a
To ensure there are no include path collisions the C and C++ header include paths should include 'thrift' as the root leaf. This will prevent having to place /usr/include/thrift into the compilers include header search path, which might otherwise result in the compiler accidentally picking up headers that it shouldn't. e.g. #include <foo/bar.h> should be #include <thrift/foo/bar.h> Change-Id: I48f2b0f549bda0fc81e85506ac857adc800b98a1 git-svn-id: https://svn.apache.org/repos/asf/thrift/trunk@1325674 13f79535-47bb-0310-9956-ffa450edef68
155 lines
4.2 KiB
C++
155 lines
4.2 KiB
C++
/*
|
|
* Licensed to the Apache Software Foundation (ASF) under one
|
|
* or more contributor license agreements. See the NOTICE file
|
|
* distributed with this work for additional information
|
|
* regarding copyright ownership. The ASF licenses this file
|
|
* to you under the Apache License, Version 2.0 (the
|
|
* "License"); you may not use this file except in compliance
|
|
* with the License. You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing,
|
|
* software distributed under the License is distributed on an
|
|
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
|
|
* KIND, either express or implied. See the License for the
|
|
* specific language governing permissions and limitations
|
|
* under the License.
|
|
*/
|
|
|
|
#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/Calculator.h"
|
|
|
|
using namespace std;
|
|
using namespace apache::thrift;
|
|
using namespace apache::thrift::protocol;
|
|
using namespace apache::thrift::transport;
|
|
using namespace apache::thrift::server;
|
|
|
|
using namespace tutorial;
|
|
using namespace shared;
|
|
|
|
using namespace boost;
|
|
|
|
class CalculatorHandler : public CalculatorIf {
|
|
public:
|
|
CalculatorHandler() {}
|
|
|
|
void ping() {
|
|
printf("ping()\n");
|
|
}
|
|
|
|
int32_t add(const int32_t n1, const int32_t n2) {
|
|
printf("add(%d,%d)\n", n1, n2);
|
|
return n1 + n2;
|
|
}
|
|
|
|
int32_t calculate(const int32_t logid, const Work &work) {
|
|
printf("calculate(%d,{%d,%d,%d})\n", logid, work.op, work.num1, work.num2);
|
|
int32_t val;
|
|
|
|
switch (work.op) {
|
|
case Operation::ADD:
|
|
val = work.num1 + work.num2;
|
|
break;
|
|
case Operation::SUBTRACT:
|
|
val = work.num1 - work.num2;
|
|
break;
|
|
case Operation::MULTIPLY:
|
|
val = work.num1 * work.num2;
|
|
break;
|
|
case Operation::DIVIDE:
|
|
if (work.num2 == 0) {
|
|
InvalidOperation io;
|
|
io.what = work.op;
|
|
io.why = "Cannot divide by 0";
|
|
throw io;
|
|
}
|
|
val = work.num1 / work.num2;
|
|
break;
|
|
default:
|
|
InvalidOperation io;
|
|
io.what = work.op;
|
|
io.why = "Invalid Operation";
|
|
throw io;
|
|
}
|
|
|
|
SharedStruct ss;
|
|
ss.key = logid;
|
|
char buffer[12];
|
|
snprintf(buffer, sizeof(buffer), "%d", val);
|
|
ss.value = buffer;
|
|
|
|
log[logid] = ss;
|
|
|
|
return val;
|
|
}
|
|
|
|
void getStruct(SharedStruct &ret, const int32_t logid) {
|
|
printf("getStruct(%d)\n", logid);
|
|
ret = log[logid];
|
|
}
|
|
|
|
void zip() {
|
|
printf("zip()\n");
|
|
}
|
|
|
|
protected:
|
|
map<int32_t, SharedStruct> log;
|
|
|
|
};
|
|
|
|
int main(int argc, char **argv) {
|
|
|
|
shared_ptr<TProtocolFactory> protocolFactory(new TBinaryProtocolFactory());
|
|
shared_ptr<CalculatorHandler> handler(new CalculatorHandler());
|
|
shared_ptr<TProcessor> processor(new CalculatorProcessor(handler));
|
|
shared_ptr<TServerTransport> serverTransport(new TServerSocket(9090));
|
|
shared_ptr<TTransportFactory> transportFactory(new TBufferedTransportFactory());
|
|
|
|
TSimpleServer server(processor,
|
|
serverTransport,
|
|
transportFactory,
|
|
protocolFactory);
|
|
|
|
|
|
/**
|
|
* Or you could do one of these
|
|
|
|
shared_ptr<ThreadManager> threadManager =
|
|
ThreadManager::newSimpleThreadManager(workerCount);
|
|
shared_ptr<PosixThreadFactory> threadFactory =
|
|
shared_ptr<PosixThreadFactory>(new PosixThreadFactory());
|
|
threadManager->threadFactory(threadFactory);
|
|
threadManager->start();
|
|
TThreadPoolServer server(processor,
|
|
serverTransport,
|
|
transportFactory,
|
|
protocolFactory,
|
|
threadManager);
|
|
|
|
TThreadedServer server(processor,
|
|
serverTransport,
|
|
transportFactory,
|
|
protocolFactory);
|
|
|
|
*/
|
|
|
|
printf("Starting the server...\n");
|
|
server.serve();
|
|
printf("done.\n");
|
|
return 0;
|
|
}
|