auser-poolparty 1.3.1 → 1.3.2

data/vendor/gems/thrift/lib/cpp/src/transport/TTransport.h

@@ -1,224 +0,0 @@
-/*
- * 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_TRANSPORT_TTRANSPORT_H_
-#define _THRIFT_TRANSPORT_TTRANSPORT_H_ 1
-
-#include <Thrift.h>
-#include <boost/shared_ptr.hpp>
-#include <transport/TTransportException.h>
-#include <string>
-
-namespace apache { namespace thrift { namespace transport {
-
-/**
- * Generic interface for a method of transporting data. A TTransport may be
- * capable of either reading or writing, but not necessarily both.
- *
- */
-class TTransport {
- public:
-  /**
-   * Virtual deconstructor.
-   */
-  virtual ~TTransport() {}
-
-  /**
-   * Whether this transport is open.
-   */
-  virtual bool isOpen() {
-    return false;
-  }
-
-  /**
-   * Tests whether there is more data to read or if the remote side is
-   * still open. By default this is true whenever the transport is open,
-   * but implementations should add logic to test for this condition where
-   * possible (i.e. on a socket).
-   * This is used by a server to check if it should listen for another
-   * request.
-   */
-  virtual bool peek() {
-    return isOpen();
-  }
-
-  /**
-   * Opens the transport for communications.
-   *
-   * @return bool Whether the transport was successfully opened
-   * @throws TTransportException if opening failed
-   */
-  virtual void open() {
-    throw TTransportException(TTransportException::NOT_OPEN, "Cannot open base TTransport.");
-  }
-
-  /**
-   * Closes the transport.
-   */
-  virtual void close() {
-    throw TTransportException(TTransportException::NOT_OPEN, "Cannot close base TTransport.");
-  }
-
-  /**
-   * Attempt to read up to the specified number of bytes into the string.
-   *
-   * @param buf  Reference to the location to write the data
-   * @param len  How many bytes to read
-   * @return How many bytes were actually read
-   * @throws TTransportException If an error occurs
-   */
-  virtual uint32_t read(uint8_t* /* buf */, uint32_t /* len */) {
-    throw TTransportException(TTransportException::NOT_OPEN, "Base TTransport cannot read.");
-  }
-
-  /**
-   * Reads the given amount of data in its entirety no matter what.
-   *
-   * @param s     Reference to location for read data
-   * @param len   How many bytes to read
-   * @return How many bytes read, which must be equal to size
-   * @throws TTransportException If insufficient data was read
-   */
-  virtual uint32_t readAll(uint8_t* buf, uint32_t len) {
-    uint32_t have = 0;
-    uint32_t get = 0;
-
-    while (have < len) {
-      get = read(buf+have, len-have);
-      if (get <= 0) {
-        throw TTransportException("No more data to read.");
-      }
-      have += get;
-    }
-
-    return have;
-  }
-
-  /**
-   * Called when read is completed.
-   * This can be over-ridden to perform a transport-specific action
-   * e.g. logging the request to a file
-   *
-   */
-  virtual void readEnd() {
-    // default behaviour is to do nothing
-    return;
-  }
-
-  /**
-   * Writes the string in its entirety to the buffer.
-   *
-   * @param buf  The data to write out
-   * @throws TTransportException if an error occurs
-   */
-  virtual void write(const uint8_t* /* buf */, uint32_t /* len */) {
-    throw TTransportException(TTransportException::NOT_OPEN, "Base TTransport cannot write.");
-  }
-
-  /**
-   * Called when write is completed.
-   * This can be over-ridden to perform a transport-specific action
-   * at the end of a request.
-   *
-   */
-  virtual void writeEnd() {
-    // default behaviour is to do nothing
-    return;
-  }
-
-  /**
-   * Flushes any pending data to be written. Typically used with buffered
-   * transport mechanisms.
-   *
-   * @throws TTransportException if an error occurs
-   */
-  virtual void flush() {}
-
-  /**
-   * Attempts to return a pointer to \c len bytes, possibly copied into \c buf.
-   * Does not consume the bytes read (i.e.: a later read will return the same
-   * data).  This method is meant to support protocols that need to read
-   * variable-length fields.  They can attempt to borrow the maximum amount of
-   * data that they will need, then consume (see next method) what they
-   * actually use.  Some transports will not support this method and others
-   * will fail occasionally, so protocols must be prepared to use read if
-   * borrow fails.
-   *
-   * @oaram buf  A buffer where the data can be stored if needed.
-   *             If borrow doesn't return buf, then the contents of
-   *             buf after the call are undefined.
-   * @param len  *len should initially contain the number of bytes to borrow.
-   *             If borrow succeeds, *len will contain the number of bytes
-   *             available in the returned pointer.  This will be at least
-   *             what was requested, but may be more if borrow returns
-   *             a pointer to an internal buffer, rather than buf.
-   *             If borrow fails, the contents of *len are undefined.
-   * @return If the borrow succeeds, return a pointer to the borrowed data.
-   *         This might be equal to \c buf, or it might be a pointer into
-   *         the transport's internal buffers.
-   * @throws TTransportException if an error occurs
-   */
-  virtual const uint8_t* borrow(uint8_t* /* buf */, uint32_t* /* len */) {
-    return NULL;
-  }
-
-  /**
-   * Remove len bytes from the transport.  This should always follow a borrow
-   * of at least len bytes, and should always succeed.
-   * TODO(dreiss): Is there any transport that could borrow but fail to
-   * consume, or that would require a buffer to dump the consumed data?
-   *
-   * @param len  How many bytes to consume
-   * @throws TTransportException If an error occurs
-   */
-  virtual void consume(uint32_t /* len */) {
-    throw TTransportException(TTransportException::NOT_OPEN, "Base TTransport cannot consume.");
-  }
-
- protected:
-  /**
-   * Simple constructor.
-   */
-  TTransport() {}
-};
-
-/**
- * Generic factory class to make an input and output transport out of a
- * source transport. Commonly used inside servers to make input and output
- * streams out of raw clients.
- *
- */
-class TTransportFactory {
- public:
-  TTransportFactory() {}
-
-  virtual ~TTransportFactory() {}
-
-  /**
-   * Default implementation does nothing, just returns the transport given.
-   */
-  virtual boost::shared_ptr<TTransport> getTransport(boost::shared_ptr<TTransport> trans) {
-    return trans;
-  }
-
-};
-
-}}} // apache::thrift::transport
-
-#endif // #ifndef _THRIFT_TRANSPORT_TTRANSPORT_H_

data/vendor/gems/thrift/lib/cpp/src/transport/TTransportException.cpp

@@ -1,31 +0,0 @@
-/*
- * 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 <transport/TTransportException.h>
-#include <boost/lexical_cast.hpp>
-#include <cstring>
-#include <config.h>
-
-using std::string;
-using boost::lexical_cast;
-
-namespace apache { namespace thrift { namespace transport {
-
-}}} // apache::thrift::transport
-

data/vendor/gems/thrift/lib/cpp/src/transport/TTransportException.h

@@ -1,117 +0,0 @@
-/*
- * 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_TRANSPORT_TTRANSPORTEXCEPTION_H_
-#define _THRIFT_TRANSPORT_TTRANSPORTEXCEPTION_H_ 1
-
-#include <string>
-#include <Thrift.h>
-
-namespace apache { namespace thrift { namespace transport {
-
-/**
- * Class to encapsulate all the possible types of transport errors that may
- * occur in various transport systems. This provides a sort of generic
- * wrapper around the shitty UNIX E_ error codes that lets a common code
- * base of error handling to be used for various types of transports, i.e.
- * pipes etc.
- *
- */
-class TTransportException : public apache::thrift::TException {
- public:
-  /**
-   * Error codes for the various types of exceptions.
-   */
-  enum TTransportExceptionType
-  { UNKNOWN = 0
-  , NOT_OPEN = 1
-  , ALREADY_OPEN = 2
-  , TIMED_OUT = 3
-  , END_OF_FILE = 4
-  , INTERRUPTED = 5
-  , BAD_ARGS = 6
-  , CORRUPTED_DATA = 7
-  , INTERNAL_ERROR = 8
-  };
-
-  TTransportException() :
-    apache::thrift::TException(),
-    type_(UNKNOWN) {}
-
-  TTransportException(TTransportExceptionType type) :
-    apache::thrift::TException(),
-    type_(type) {}
-
-  TTransportException(const std::string& message) :
-    apache::thrift::TException(message),
-    type_(UNKNOWN) {}
-
-  TTransportException(TTransportExceptionType type, const std::string& message) :
-    apache::thrift::TException(message),
-    type_(type) {}
-
-  TTransportException(TTransportExceptionType type,
-                      const std::string& message,
-                      int errno_copy) :
-    apache::thrift::TException(message + ": " + TOutput::strerror_s(errno_copy)),
-    type_(type) {}
-
-  virtual ~TTransportException() throw() {}
-
-  /**
-   * Returns an error code that provides information about the type of error
-   * that has occurred.
-   *
-   * @return Error code
-   */
-  TTransportExceptionType getType() const throw() {
-    return type_;
-  }
-
-  virtual const char* what() const throw() {
-    if (message_.empty()) {
-      switch (type_) {
-        case UNKNOWN        : return "TTransportException: Unknown transport exception";
-        case NOT_OPEN       : return "TTransportException: Transport not open";
-        case ALREADY_OPEN   : return "TTransportException: Transport already open";
-        case TIMED_OUT      : return "TTransportException: Timed out";
-        case END_OF_FILE    : return "TTransportException: End of file";
-        case INTERRUPTED    : return "TTransportException: Interrupted";
-        case BAD_ARGS       : return "TTransportException: Invalid arguments";
-        case CORRUPTED_DATA : return "TTransportException: Corrupted Data";
-        case INTERNAL_ERROR : return "TTransportException: Internal error";
-        default             : return "TTransportException: (Invalid exception type)";
-      }
-    } else {
-      return message_.c_str();
-    }
-  }
-
- protected:
-  /** Just like strerror_r but returns a C++ string object. */
-  std::string strerror_s(int errno_copy);
-
-  /** Error code */
-  TTransportExceptionType type_;
-
-};
-
-}}} // apache::thrift::transport
-
-#endif // #ifndef _THRIFT_TRANSPORT_TTRANSPORTEXCEPTION_H_

data/vendor/gems/thrift/lib/cpp/src/transport/TTransportUtils.cpp

@@ -1,178 +0,0 @@
-/*
- * 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 <transport/TTransportUtils.h>
-
-using std::string;
-
-namespace apache { namespace thrift { namespace transport {
-
-uint32_t TPipedTransport::read(uint8_t* buf, uint32_t len) {
-  uint32_t need = len;
-
-  // We don't have enough data yet
-  if (rLen_-rPos_ < need) {
-    // Copy out whatever we have
-    if (rLen_-rPos_ > 0) {
-      memcpy(buf, rBuf_+rPos_, rLen_-rPos_);
-      need -= rLen_-rPos_;
-      buf += rLen_-rPos_;
-      rPos_ = rLen_;
-    }
-
-    // Double the size of the underlying buffer if it is full
-    if (rLen_ == rBufSize_) {
-      rBufSize_ *=2;
-      rBuf_ = (uint8_t *)std::realloc(rBuf_, sizeof(uint8_t) * rBufSize_);
-    }
-
-    // try to fill up the buffer
-    rLen_ += srcTrans_->read(rBuf_+rPos_, rBufSize_ - rPos_);
-  }
-
-
-  // Hand over whatever we have
-  uint32_t give = need;
-  if (rLen_-rPos_ < give) {
-    give = rLen_-rPos_;
-  }
-  if (give > 0) {
-    memcpy(buf, rBuf_+rPos_, give);
-    rPos_ += give;
-    need -= give;
-  }
-
-  return (len - need);
-}
-
-void TPipedTransport::write(const uint8_t* buf, uint32_t len) {
-  if (len == 0) {
-    return;
-  }
-
-  // Make the buffer as big as it needs to be
-  if ((len + wLen_) >= wBufSize_) {
-    uint32_t newBufSize = wBufSize_*2;
-    while ((len + wLen_) >= newBufSize) {
-      newBufSize *= 2;
-    }
-    wBuf_ = (uint8_t *)std::realloc(wBuf_, sizeof(uint8_t) * newBufSize);
-    wBufSize_ = newBufSize;
-  }
-
-  // Copy into the buffer
-  memcpy(wBuf_ + wLen_, buf, len);
-  wLen_ += len;
-}
-
-void TPipedTransport::flush()  {
-  // Write out any data waiting in the write buffer
-  if (wLen_ > 0) {
-    srcTrans_->write(wBuf_, wLen_);
-    wLen_ = 0;
-  }
-
-  // Flush the underlying transport
-  srcTrans_->flush();
-}
-
-TPipedFileReaderTransport::TPipedFileReaderTransport(boost::shared_ptr<TFileReaderTransport> srcTrans, boost::shared_ptr<TTransport> dstTrans)
-  : TPipedTransport(srcTrans, dstTrans),
-    srcTrans_(srcTrans) {
-}
-
-TPipedFileReaderTransport::~TPipedFileReaderTransport() {
-}
-
-bool TPipedFileReaderTransport::isOpen() {
-  return TPipedTransport::isOpen();
-}
-
-bool TPipedFileReaderTransport::peek() {
-  return TPipedTransport::peek();
-}
-
-void TPipedFileReaderTransport::open() {
-  TPipedTransport::open();
-}
-
-void TPipedFileReaderTransport::close() {
-  TPipedTransport::close();
-}
-
-uint32_t TPipedFileReaderTransport::read(uint8_t* buf, uint32_t len) {
-  return TPipedTransport::read(buf, len);
-}
-
-uint32_t TPipedFileReaderTransport::readAll(uint8_t* buf, uint32_t len) {
-  uint32_t have = 0;
-  uint32_t get = 0;
-
-  while (have < len) {
-    get = read(buf+have, len-have);
-    if (get <= 0) {
-      throw TEOFException();
-    }
-    have += get;
-  }
-
-  return have;
-}
-
-void TPipedFileReaderTransport::readEnd() {
-  TPipedTransport::readEnd();
-}
-
-void TPipedFileReaderTransport::write(const uint8_t* buf, uint32_t len) {
-  TPipedTransport::write(buf, len);
-}
-
-void TPipedFileReaderTransport::writeEnd() {
-  TPipedTransport::writeEnd();
-}
-
-void TPipedFileReaderTransport::flush() {
-  TPipedTransport::flush();
-}
-
-int32_t TPipedFileReaderTransport::getReadTimeout() {
-  return srcTrans_->getReadTimeout();
-}
-
-void TPipedFileReaderTransport::setReadTimeout(int32_t readTimeout) {
-  srcTrans_->setReadTimeout(readTimeout);
-}
-
-uint32_t TPipedFileReaderTransport::getNumChunks() {
-  return srcTrans_->getNumChunks();
-}
-
-uint32_t TPipedFileReaderTransport::getCurChunk() {
-  return srcTrans_->getCurChunk();
-}
-
-void TPipedFileReaderTransport::seekToChunk(int32_t chunk) {
-  srcTrans_->seekToChunk(chunk);
-}
-
-void TPipedFileReaderTransport::seekToEnd() {
-  srcTrans_->seekToEnd();
-}
-
-}}} // apache::thrift::transport