Subversion Repositories SmartDukaan

/*

 * 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 <concurrency/ThreadManager.h>

#include <concurrency/PosixThreadFactory.h>

#include <protocol/TBinaryProtocol.h>

#include <server/TSimpleServer.h>

#include <server/TThreadPoolServer.h>

#include <server/TThreadedServer.h>

#include <transport/TServerSocket.h>

#include <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 ADD:

      val = work.num1 + work.num2;

      break;

    case SUBTRACT:

      val = work.num1 - work.num2;

      break;

    case MULTIPLY:

      val = work.num1 * work.num2;

      break;

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

}