#ifndef _THRIFT_TASYNC_BUFFER_PROCESSOR_H_
#define _THRIFT_TASYNC_BUFFER_PROCESSOR_H_ 1
-#include <tr1/functional>
+#include <thrift/cxxfunctional.h>
#include <boost/shared_ptr.hpp>
#include <thrift/transport/TBufferTransports.h>
// "in" and "out" should be TMemoryBuffer or similar,
// not a wrapper around a socket.
virtual void process(
- std::tr1::function<void(bool healthy)> _return,
+ apache::thrift::stdcxx::function<void(bool healthy)> _return,
boost::shared_ptr<apache::thrift::transport::TBufferBase> ibuf,
boost::shared_ptr<apache::thrift::transport::TBufferBase> obuf) = 0;
virtual ~TAsyncBufferProcessor() {}
*/
#include <thrift/async/TAsyncChannel.h>
-#include <tr1/functional>
+#include <thrift/cxxfunctional.h>
namespace apache { namespace thrift { namespace async {
void TAsyncChannel::sendAndRecvMessage(const VoidCallback& cob,
TMemoryBuffer* sendBuf,
TMemoryBuffer* recvBuf) {
- std::tr1::function<void()> send_done =
- std::tr1::bind(&TAsyncChannel::recvMessage, this, cob, recvBuf);
+ apache::thrift::stdcxx::function<void()> send_done =
+ apache::thrift::stdcxx::bind(&TAsyncChannel::recvMessage, this, cob, recvBuf);
sendMessage(send_done, sendBuf);
}
#ifndef _THRIFT_ASYNC_TASYNCCHANNEL_H_
#define _THRIFT_ASYNC_TASYNCCHANNEL_H_ 1
-#include <tr1/functional>
+#include <thrift/cxxfunctional.h>
#include <thrift/Thrift.h>
namespace apache { namespace thrift { namespace transport {
class TAsyncChannel {
public:
- typedef std::tr1::function<void()> VoidCallback;
+ typedef apache::thrift::stdcxx::function<void()> VoidCallback;
virtual ~TAsyncChannel() {}
template <class Protocol_>
class TAsyncDispatchProcessorT : public TAsyncProcessor {
public:
- virtual void process(std::tr1::function<void(bool success)> _return,
+ virtual void process(apache::thrift::stdcxx::function<void(bool success)> _return,
boost::shared_ptr<protocol::TProtocol> in,
boost::shared_ptr<protocol::TProtocol> out) {
protocol::TProtocol* inRaw = in.get();
return this->dispatchCall(_return, inRaw, outRaw, fname, seqid);
}
- void processFast(std::tr1::function<void(bool success)> _return,
+ void processFast(apache::thrift::stdcxx::function<void(bool success)> _return,
Protocol_* in, Protocol_* out) {
std::string fname;
protocol::TMessageType mtype;
return this->dispatchCallTemplated(_return, in, out, fname, seqid);
}
- virtual void dispatchCall(std::tr1::function<void(bool ok)> _return,
+ virtual void dispatchCall(apache::thrift::stdcxx::function<void(bool ok)> _return,
apache::thrift::protocol::TProtocol* in,
apache::thrift::protocol::TProtocol* out,
const std::string& fname, int32_t seqid) = 0;
- virtual void dispatchCallTemplated(std::tr1::function<void(bool ok)> _return,
+ virtual void dispatchCallTemplated(apache::thrift::stdcxx::function<void(bool ok)> _return,
Protocol_* in, Protocol_* out,
const std::string& fname,
int32_t seqid) = 0;
*/
class TAsyncDispatchProcessor : public TAsyncProcessor {
public:
- virtual void process(std::tr1::function<void(bool success)> _return,
+ virtual void process(apache::thrift::stdcxx::function<void(bool success)> _return,
boost::shared_ptr<protocol::TProtocol> in,
boost::shared_ptr<protocol::TProtocol> out) {
protocol::TProtocol* inRaw = in.get();
return dispatchCall(_return, inRaw, outRaw, fname, seqid);
}
- virtual void dispatchCall(std::tr1::function<void(bool ok)> _return,
+ virtual void dispatchCall(apache::thrift::stdcxx::function<void(bool ok)> _return,
apache::thrift::protocol::TProtocol* in,
apache::thrift::protocol::TProtocol* out,
const std::string& fname, int32_t seqid) = 0;
#ifndef _THRIFT_TASYNCPROCESSOR_H_
#define _THRIFT_TASYNCPROCESSOR_H_ 1
-#include <tr1/functional>
+#include <thrift/cxxfunctional.h>
#include <boost/shared_ptr.hpp>
#include <thrift/protocol/TProtocol.h>
#include <thrift/TProcessor.h>
public:
virtual ~TAsyncProcessor() {}
- virtual void process(std::tr1::function<void(bool success)> _return,
+ virtual void process(apache::thrift::stdcxx::function<void(bool success)> _return,
boost::shared_ptr<protocol::TProtocol> in,
boost::shared_ptr<protocol::TProtocol> out) = 0;
- void process(std::tr1::function<void(bool success)> _return,
+ void process(apache::thrift::stdcxx::function<void(bool success)> _return,
boost::shared_ptr<apache::thrift::protocol::TProtocol> io) {
return process(_return, io, io);
}
namespace apache { namespace thrift { namespace async {
void TAsyncProtocolProcessor::process(
- std::tr1::function<void(bool healthy)> _return,
+ apache::thrift::stdcxx::function<void(bool healthy)> _return,
boost::shared_ptr<TBufferBase> ibuf,
boost::shared_ptr<TBufferBase> obuf) {
boost::shared_ptr<TProtocol> iprot(pfact_->getProtocol(ibuf));
boost::shared_ptr<TProtocol> oprot(pfact_->getProtocol(obuf));
return underlying_->process(
- std::tr1::bind(
+ apache::thrift::stdcxx::bind(
&TAsyncProtocolProcessor::finish,
_return,
oprot,
- std::tr1::placeholders::_1),
+ apache::thrift::stdcxx::placeholders::_1),
iprot, oprot);
}
/* static */ void TAsyncProtocolProcessor::finish(
- std::tr1::function<void(bool healthy)> _return,
+ apache::thrift::stdcxx::function<void(bool healthy)> _return,
boost::shared_ptr<TProtocol> oprot,
bool healthy) {
(void) oprot;
{}
virtual void process(
- std::tr1::function<void(bool healthy)> _return,
+ apache::thrift::stdcxx::function<void(bool healthy)> _return,
boost::shared_ptr<apache::thrift::transport::TBufferBase> ibuf,
boost::shared_ptr<apache::thrift::transport::TBufferBase> obuf);
private:
static void finish(
- std::tr1::function<void(bool healthy)> _return,
+ apache::thrift::stdcxx::function<void(bool healthy)> _return,
boost::shared_ptr<apache::thrift::protocol::TProtocol> oprot,
bool healthy);
void TEvhttpServer::process(struct evhttp_request* req) {
RequestContext* ctx = new RequestContext(req);
return processor_->process(
- std::tr1::bind(
+ apache::thrift::stdcxx::bind(
&TEvhttpServer::complete,
this,
ctx,
- std::tr1::placeholders::_1),
+ apache::thrift::stdcxx::placeholders::_1),
ctx->ibuf,
ctx->obuf);
}
#ifndef _THRIFT_CONCURRENCY_FUNCTION_RUNNER_H
#define _THRIFT_CONCURRENCY_FUNCTION_RUNNER_H 1
-#include <tr1/functional>
+#include "thrift/cxxfunctional.h"
#include "thrift/lib/cpp/concurrency/Thread.h"
namespace apache { namespace thrift { namespace concurrency {
* A* a = new A();
* // To create a thread that executes a.foo() every 100 milliseconds:
* factory->newThread(FunctionRunner::create(
- * std::tr1::bind(&A::foo, a), 100))->start();
+ * apache::thrift::stdcxx::bind(&A::foo, a), 100))->start();
*
*/
// This is the type of callback 'pthread_create()' expects.
typedef void* (*PthreadFuncPtr)(void *arg);
// This a fully-generic void(void) callback for custom bindings.
- typedef std::tr1::function<void()> VoidFunc;
+ typedef apache::thrift::stdcxx::function<void()> VoidFunc;
- typedef std::tr1::function<bool()> BoolFunc;
+ typedef apache::thrift::stdcxx::function<bool()> BoolFunc;
/**
* Syntactic sugar to make it easier to create new FunctionRunner
* execute the given callback. Note that the 'void*' return value is ignored.
*/
FunctionRunner(PthreadFuncPtr func, void* arg)
- : func_(std::tr1::bind(func, arg)), repFunc_(0)
+ : func_(apache::thrift::stdcxx::bind(func, arg)), repFunc_(0)
{ }
/**
#define _THRIFT_CONCURRENCY_THREADMANAGER_H_ 1
#include <boost/shared_ptr.hpp>
-#include <tr1/functional>
+#include <thrift/cxxfunctional.h>
#include <sys/types.h>
#include "Thread.h"
public:
class Task;
- typedef std::tr1::function<void(boost::shared_ptr<Runnable>)> ExpireCallback;
+ typedef apache::thrift::stdcxx::function<void(boost::shared_ptr<Runnable>)> ExpireCallback;
virtual ~ThreadManager() {}
}
static void toTimeval(struct timeval& result, int64_t value) {
- result.tv_sec = (uint32_t)(value / MS_PER_S); // ms to s
- result.tv_usec = (value % MS_PER_S) * US_PER_MS; // ms to us
+ result.tv_sec = static_cast<uint32_t>(value / MS_PER_S); // ms to s
+ result.tv_usec = static_cast<uint32_t>((value % MS_PER_S) * US_PER_MS); // ms to us
}
static void toTicks(int64_t& result, int64_t secs, int64_t oldTicks,
--- /dev/null
+/*
+ * 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.
+ */
+
+#ifndef _THRIFT_CXXFUNCTIONAL_H_
+#define _THRIFT_CXXFUNCTIONAL_H_ 1
+
+/**
+ * Loads <functional> from the 'right' location, depending
+ * on compiler and whether or not it's using C++03 with TR1
+ * or C++11.
+ */
+
+/*
+ * MSVC 10 and 11 have the <functional> stuff at <functional>.
+ * In MSVC 10 all of the implementations live in std::tr1.
+ * In MSVC 11 all of the implementations live in std, with aliases
+ * in std::tr1 to point to the ones in std.
+ */
+#ifdef _WIN32
+ #define _THRIFT_USING_MICROSOFT_STDLIB 1
+#endif
+
+#ifdef __clang__
+ /* Clang has two options, depending on standard library:
+ * - no -stdlib or -stdlib=libstdc++ set; uses GNU libstdc++.
+ * <tr1/functional>
+ * - -stdlib=libc++; uses LLVM libc++.
+ * <functional>, no 'std::tr1'.
+ *
+ * The compiler itself doesn't define anything differently
+ * depending on the value of -stdlib, but the library headers
+ * will set different preprocessor options. In order to check,
+ * though, we have to pull in some library header.
+ */
+ #include <utility>
+
+ /* With LLVM libc++, utility pulls in __config, which sets
+ _LIBCPP_VERSION. */
+ #if defined(_LIBCPP_VERSION)
+ #define _THRIFT_USING_CLANG_LIBCXX 1
+
+ /* With GNU libstdc++, utility pulls in bits/c++config.h,
+ which sets __GLIBCXX__. */
+ #elif defined(__GLIBCXX__)
+ #define _THRIFT_USING_GNU_LIBSTDCXX 1
+
+ /* No idea. */
+ #else
+ #error Unable to detect which C++ standard library is in use.
+ #endif
+#elif __GNUC__
+ #define _THRIFT_USING_GNU_LIBSTDCXX 1
+#endif
+
+#if _THRIFT_USING_MICROSOFT_STDLIB
+ #include <functional>
+
+ namespace apache { namespace thrift { namespace stdcxx {
+ using ::std::tr1::function;
+ using ::std::tr1::bind;
+
+ namespace placeholders {
+ using ::std::tr1::placeholders::_1;
+ using ::std::tr1::placeholders::_2;
+ using ::std::tr1::placeholders::_3;
+ using ::std::tr1::placeholders::_4;
+ using ::std::tr1::placeholders::_5;
+ using ::std::tr1::placeholders::_6;
+ } // apache::thrift::stdcxx::placeholders
+ }}} // apache::thrift::stdcxx
+
+#elif _THRIFT_USING_CLANG_LIBCXX
+ #include <functional>
+
+ namespace apache { namespace thrift { namespace stdcxx {
+ using ::std::function;
+ using ::std::bind;
+
+ namespace placeholders {
+ using ::std::placeholders::_1;
+ using ::std::placeholders::_2;
+ using ::std::placeholders::_3;
+ using ::std::placeholders::_4;
+ using ::std::placeholders::_5;
+ using ::std::placeholders::_6;
+ } // apache::thrift::stdcxx::placeholders
+ }}} // apache::thrift::stdcxx
+
+#elif _THRIFT_USING_GNU_LIBSTDCXX
+ #include <tr1/functional>
+
+ namespace apache { namespace thrift { namespace stdcxx {
+ using ::std::tr1::function;
+ using ::std::tr1::bind;
+
+ namespace placeholders {
+ using ::std::tr1::placeholders::_1;
+ using ::std::tr1::placeholders::_2;
+ using ::std::tr1::placeholders::_3;
+ using ::std::tr1::placeholders::_4;
+ using ::std::tr1::placeholders::_5;
+ using ::std::tr1::placeholders::_6;
+ } // apache::thrift::stdcxx::placeholders
+ }}} // apache::thrift::stdcxx
+#endif
+
+#endif // #ifndef _THRIFT_CXXFUNCTIONAL_H_
// Back up one step before writing.
pos++;
- trans_->write(buf+pos, sizeof(buf) - pos);
- return sizeof(buf) - pos;
+ trans_->write(buf+pos, static_cast<uint32_t>(sizeof(buf) - pos));
+ return static_cast<uint32_t>(sizeof(buf) - pos);
}
# define ntohll(n) ( _byteswap_uint64((uint64_t)n) )
# define htonll(n) ( _byteswap_uint64((uint64_t)n) )
# else /* Not GNUC/GLIBC or MSVC */
-# define ntohll(n) ( (((uint64_t)ntohl(n)) << 32) + ntohl(n >> 32) )
-# define htonll(n) ( (((uint64_t)htonl(n)) << 32) + htonl(n >> 32) )
+# define ntohll(n) ( (((uint64_t)ntohl((uint32_t)n)) << 32) + ntohl((uint32_t)(n >> 32)) )
+# define htonll(n) ( (((uint64_t)htonl((uint32_t)n)) << 32) + htonl((uint32_t)(n >> 32)) )
# endif /* GNUC/GLIBC or MSVC or something else */
#else /* __THRIFT_BYTE_ORDER */
# error "Can't define htonll or ntohll!"
#include <QTcpSocket>
-#include <tr1/functional>
+#include <thrift/cxxfunctional.h>
#include <thrift/protocol/TProtocol.h>
#include <thrift/async/TAsyncProcessor.h>
using apache::thrift::transport::TTransport;
using apache::thrift::transport::TTransportException;
using apache::thrift::transport::TQIODeviceTransport;
-using std::tr1::function;
-using std::tr1::bind;
+using apache::thrift::stdcxx::function;
+using apache::thrift::stdcxx::bind;
QT_USE_NAMESPACE
try {
processor_->process(
bind(&TQTcpServer::finish, this,
- ctx, std::tr1::placeholders::_1),
+ ctx, apache::thrift::stdcxx::placeholders::_1),
ctx->iprot_, ctx->oprot_);
} catch(const TTransportException& ex) {
qWarning("[TQTcpServer] TTransportException during processing: '%s'",
void TNonblockingServer::setThreadManager(boost::shared_ptr<ThreadManager> threadManager) {
threadManager_ = threadManager;
if (threadManager != NULL) {
- threadManager->setExpireCallback(std::tr1::bind(&TNonblockingServer::expireClose, this, std::tr1::placeholders::_1));
+ threadManager->setExpireCallback(apache::thrift::stdcxx::bind(&TNonblockingServer::expireClose, this, apache::thrift::stdcxx::placeholders::_1));
threadPoolProcessing_ = true;
} else {
threadPoolProcessing_ = false;
uint32_t size_bytes_read = 0;
while (size_bytes_read < sizeof(sz)) {
uint8_t* szp = reinterpret_cast<uint8_t*>(&sz) + size_bytes_read;
- uint32_t bytes_read = transport_->read(szp, sizeof(sz) - size_bytes_read);
+ uint32_t bytes_read = transport_->read(
+ szp,
+ static_cast<uint32_t>(sizeof(sz)) - size_bytes_read);
if (bytes_read == 0) {
if (size_bytes_read == 0) {
// EOF before any data was read.
wBase_ = wBuf_.get() + sizeof(sz_nbo);
// Write size and frame body.
- transport_->write(wBuf_.get(), sizeof(sz_nbo)+sz_hbo);
+ transport_->write(
+ wBuf_.get(),
+ static_cast<uint32_t>(sizeof(sz_nbo))+sz_hbo);
}
// Flush the underlying transport.
#include <cstdlib>
#include <cstring>
#include <iostream>
+#include <limits>
#ifdef HAVE_SYS_STAT_H
#include <sys/stat.h>
#endif
if (readState_.bufferPtr_ == readState_.bufferLen_) {
// advance the offset pointer
offset_ += readState_.bufferLen_;
- readState_.bufferLen_ = ::read(fd_, readBuff_, readBuffSize_);
+ readState_.bufferLen_ = static_cast<uint32_t>(::read(fd_, readBuff_, readBuffSize_));
// if (readState_.bufferLen_) {
// T_DEBUG_L(1, "Amount read: %u (offset: %lu)", readState_.bufferLen_, offset_);
// }
// 3. size indicates that event crosses chunk boundary
T_ERROR("Read corrupt event. Event crosses chunk boundary. Event size:%u Offset:%lu",
readState_.event_->eventSize_,
- (offset_ + readState_.bufferPtr_ + 4));
+ static_cast<unsigned long>(offset_ + readState_.bufferPtr_ + 4));
return true;
}
currentEvent_ = NULL;
char errorMsg[1024];
sprintf(errorMsg, "TFileTransport: log file corrupted at offset: %lu",
- (offset_ + readState_.lastDispatchPtr_));
+ static_cast<unsigned long>(offset_ + readState_.lastDispatchPtr_));
GlobalOutput(errorMsg);
throw TTransportException(errorMsg);
}
if (f_info.st_size > 0) {
- return ((f_info.st_size)/chunkSize_) + 1;
+ size_t numChunks = ((f_info.st_size)/chunkSize_) + 1;
+ if (numChunks > (std::numeric_limits<uint32_t>::max)())
+ throw TTransportException("Too many chunks");
+ return static_cast<uint32_t>(numChunks);
}
// empty file has no chunks
}
uint32_t TFileTransport::getCurChunk() {
- return offset_/chunkSize_;
+ return static_cast<uint32_t>(offset_/chunkSize_);
}
// Utility Functions
#endif
#include <cstring>
#include <sstream>
-#ifdef HAVE_SYS_SOCKET_H
-#include <sys/socket.h>
-#endif
#ifdef HAVE_SYS_UN_H
#include <sys/un.h>
#endif
#include <sys/poll.h>
#endif
#include <sys/types.h>
-#ifdef HAVE_ARPA_INET_H
-#include <arpa/inet.h>
-#endif
#ifdef HAVE_NETINET_IN_H
#include <netinet/in.h>
#include <netinet/tcp.h>
return false;
}
uint8_t buf;
- int r = recv(socket_, cast_sockopt(&buf), 1, MSG_PEEK);
+ int r = static_cast<int>(recv(socket_, cast_sockopt(&buf), 1, MSG_PEEK));
if (r == -1) {
int errno_copy = errno;
#if defined __FreeBSD__ || defined __MACH__
// an EAGAIN is due to a timeout or an out-of-resource condition.
begin.tv_sec = begin.tv_usec = 0;
}
- int got = recv(socket_, cast_sockopt(buf), len, 0);
+ int got = static_cast<int>(recv(socket_, cast_sockopt(buf), len, 0));
int errno_copy = errno; //gettimeofday can change errno
++g_socket_syscalls;
// check if this is the lack of resources or timeout case
struct timeval end;
gettimeofday(&end, NULL);
- uint32_t readElapsedMicros = (((end.tv_sec - begin.tv_sec) * 1000 * 1000)
- + (((uint64_t)(end.tv_usec - begin.tv_usec))));
+ uint32_t readElapsedMicros = static_cast<uint32_t>(
+ ((end.tv_sec - begin.tv_sec) * 1000 * 1000)
+ + (((uint64_t)(end.tv_usec - begin.tv_usec))));
if (!eagainThresholdMicros || (readElapsedMicros < eagainThresholdMicros)) {
if (retries++ < maxRecvRetries_) {
flags |= MSG_NOSIGNAL;
#endif // ifdef MSG_NOSIGNAL
- int b = send(socket_, const_cast_sockopt(buf + sent), len - sent, flags);
+ int b = static_cast<int>(send(socket_, const_cast_sockopt(buf + sent), len - sent, flags));
++g_socket_syscalls;
if (b < 0) {
#include "TVirtualTransport.h"
#include "TServerSocket.h"
+#ifdef HAVE_ARPA_INET_H
+#include <arpa/inet.h>
+#endif
+#ifdef HAVE_SYS_SOCKET_H
+#include <sys/socket.h>
+#endif
#ifdef HAVE_SYS_TIME_H
#include <sys/time.h>
#endif
-/*
- * 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 <functional>
# THRIFT-847 Test Framework harmonization across all languages
# THRIFT-819 add Enumeration for protocol, transport and server types
+BASEDIR=$(dirname $0)
+echo $BASEDIR
+cd $BASEDIR
print_header() {
printf "%-16s %-11s %-17s %-s\n" "client-server:" "protocol:" "transport:" "result:"
print_header
+#TODO add enum for parameters
+#TODO align program arguments across languages
protocols="binary json"
transports="buffered framed http"
do_test "py-java" "binary" "buffered-ip" \
"py/TestClient.py --proto=binary --port=9090 --host=localhost --genpydir=py/gen-py" \
"ant -f ../lib/java/build.xml testserver" \
- "100"
+ "120"
do_test "py-java" "json" "buffered-ip" \
"py/TestClient.py --proto=json --port=9090 --host=localhost --genpydir=py/gen-py" \
"ant -f ../lib/java/build.xml testserver" \
- "100"
+ "120"
do_test "java-py" "binary" "buffered-ip" \
"ant -f ../lib/java/build.xml testclient" \
"py/TestServer.py --proto=binary --port=9090 --genpydir=py/gen-py TSimpleServer" \
do_test "java-java" "binary" "buffered-ip" \
"ant -f ../lib/java/build.xml testclient" \
"ant -f ../lib/java/build.xml testserver" \
- "100"
+ "120"
do_test "cpp-java" "binary" "buffered-ip" \
"cpp/TestClient" \
"ant -f ../lib/java/build.xml testserver" \
do_test "js-java" "json " "http-ip" \
"" \
"ant -f ../lib/js/test/build.xml unittest" \
- "100"
+ "120"
do_test "java-cpp" "binary" "buffered-ip" \
"ant -f ../lib/java/build.xml testclient" \
"cpp/TestServer" \
"cpp/TestClient --transport=framed" \
"make -C nodejs/ server" \
"1"
+
+cd -
Code Review / common / thrift.git / commitdiff
