package.xml 0000664 0001750 0001750 00000021160 12453742644 011312 0 ustar jan jan
Horde_Thrift
pear.horde.org
Thrift
Packaged version of the PHP Thrift client
Chuck Hagenbuch
chuck
chuck@horde.org
yes
2015-01-09
2.0.2
1.0.0
stable
stable
Apache 2.0
* [jan] Add Composer definition.
5.3.0
6.0.0alpha1
6.0.0alpha1
1.7.0
1.0.0
1.0.0
stable
stable
2011-07-27
Apache 2.0
* First stable release for Horde 4.
1.0.1
1.0.0
stable
stable
2012-04-10
Apache 2.0
* [rla] Add license file.
2.0.0alpha1
1.0.0
alpha
stable
2012-07-06
Apache 2.0
* First alpha release for Horde 5.
2.0.0beta1
1.0.0
beta
stable
2012-07-19
Apache 2.0
* First beta release for Horde 5.
2.0.0
1.0.0
stable
stable
2012-10-30
Apache 2.0
* First stable release for Horde 5.
2.0.1
1.0.0
stable
stable
2012-11-22
Apache 2.0
* [jan] Re-packaged 2.0.0 release.
2.0.2
1.0.0
stable
stable
2015-01-09
Apache 2.0
* [jan] Add Composer definition.
Horde_Thrift-2.0.2/doc/Horde/Thrift/COPYING 0000664 0001750 0001750 00000004136 12453742644 016320 0 ustar jan jan Version 1.0
Copyright 1999-2015 Horde LLC. All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are
met:
1. Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
3. The end-user documentation included with the redistribution, if
any, must include the following acknowledgment:
"This product includes software developed by Horde LLC
(http://www.horde.org/)."
Alternately, this acknowledgment may appear in the software itself, if
and wherever such third-party acknowledgments normally appear.
4. The names "Horde" and "Horde LLC" must not be used to
endorse or promote products derived from this software without prior
written permission. For written permission, please contact
core@horde.org.
5. Products derived from this software may not be called "Horde", nor
may "Horde" appear in their name, without prior written permission of
Horde LLC.
THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESSED OR IMPLIED
WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
IN NO EVENT SHALL THE HORDE PROJECT OR ITS CONTRIBUTORS BE LIABLE FOR
ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
POSSIBILITY OF SUCH DAMAGE.
This software consists of voluntary contributions made by many
individuals on behalf of Horde LLC. For more information on
Horde LLC, please see .
Horde_Thrift-2.0.2/lib/Horde/Thrift/thrift_root/packages/fb303/FacebookBase.php 0000664 0001750 0001750 00000002477 12453742644 025247 0 ustar jan jan
*/
/**
* Abstract Class providing null implementation for FacebookService
* methods.
*/
class FacebookBase implements FacebookServiceIf {
protected $name_ = '';
public function __construct($name) {
$this->name_ = $name;
}
public function getName() {
return $this->name_;
}
public function getVersion() {
return '';
}
public function getStatus() {
return null;
}
public function getStatusDetails() {
return '';
}
public function getCounters() {
return array();
}
public function getCounter($key) {
return null;
}
public function setOption($key, $value) {
return;
}
public function getOption($key) {
return '';
}
public function getOptions() {
return array();
}
public function aliveSince() {
return 0;
}
public function getCpuProfile($duration) {
return '';
}
public function getLimitedReflection() {
return array();
}
public function reinitialize() {
return;
}
public function shutdown() {
return;
}
}
Horde_Thrift-2.0.2/lib/Horde/Thrift/thrift_root/packages/fb303/FacebookService.php 0000664 0001750 0001750 00000205326 12453742644 025773 0 ustar jan jan input_ = $input;
$this->output_ = $output ? $output : $input;
}
public function getName()
{
$this->send_getName();
return $this->recv_getName();
}
public function send_getName()
{
$args = new FacebookService_getName_args();
$bin_accel = ($this->output_ instanceof TProtocol::$TBINARYPROTOCOLACCELERATED) && function_exists('thrift_protocol_write_binary');
if ($bin_accel)
{
thrift_protocol_write_binary($this->output_, 'getName', TMessageType::CALL, $args, $this->seqid_, $this->output_->isStrictWrite());
}
else
{
$this->output_->writeMessageBegin('getName', TMessageType::CALL, $this->seqid_);
$args->write($this->output_);
$this->output_->writeMessageEnd();
$this->output_->getTransport()->flush();
}
}
public function recv_getName()
{
$bin_accel = ($this->input_ instanceof TProtocol::$TBINARYPROTOCOLACCELERATED) && function_exists('thrift_protocol_read_binary');
if ($bin_accel) $result = thrift_protocol_read_binary($this->input_, 'FacebookService_getName_result', $this->input_->isStrictRead());
else
{
$rseqid = 0;
$fname = null;
$mtype = 0;
$this->input_->readMessageBegin($fname, $mtype, $rseqid);
if ($mtype == TMessageType::EXCEPTION) {
$x = new TApplicationException();
$x->read($this->input_);
$this->input_->readMessageEnd();
throw $x;
}
$result = new FacebookService_getName_result();
$result->read($this->input_);
$this->input_->readMessageEnd();
}
if ($result->success !== null) {
return $result->success;
}
throw new Exception("getName failed: unknown result");
}
public function getVersion()
{
$this->send_getVersion();
return $this->recv_getVersion();
}
public function send_getVersion()
{
$args = new FacebookService_getVersion_args();
$bin_accel = ($this->output_ instanceof TProtocol::$TBINARYPROTOCOLACCELERATED) && function_exists('thrift_protocol_write_binary');
if ($bin_accel)
{
thrift_protocol_write_binary($this->output_, 'getVersion', TMessageType::CALL, $args, $this->seqid_, $this->output_->isStrictWrite());
}
else
{
$this->output_->writeMessageBegin('getVersion', TMessageType::CALL, $this->seqid_);
$args->write($this->output_);
$this->output_->writeMessageEnd();
$this->output_->getTransport()->flush();
}
}
public function recv_getVersion()
{
$bin_accel = ($this->input_ instanceof TProtocol::$TBINARYPROTOCOLACCELERATED) && function_exists('thrift_protocol_read_binary');
if ($bin_accel) $result = thrift_protocol_read_binary($this->input_, 'FacebookService_getVersion_result', $this->input_->isStrictRead());
else
{
$rseqid = 0;
$fname = null;
$mtype = 0;
$this->input_->readMessageBegin($fname, $mtype, $rseqid);
if ($mtype == TMessageType::EXCEPTION) {
$x = new TApplicationException();
$x->read($this->input_);
$this->input_->readMessageEnd();
throw $x;
}
$result = new FacebookService_getVersion_result();
$result->read($this->input_);
$this->input_->readMessageEnd();
}
if ($result->success !== null) {
return $result->success;
}
throw new Exception("getVersion failed: unknown result");
}
public function getStatus()
{
$this->send_getStatus();
return $this->recv_getStatus();
}
public function send_getStatus()
{
$args = new FacebookService_getStatus_args();
$bin_accel = ($this->output_ instanceof TProtocol::$TBINARYPROTOCOLACCELERATED) && function_exists('thrift_protocol_write_binary');
if ($bin_accel)
{
thrift_protocol_write_binary($this->output_, 'getStatus', TMessageType::CALL, $args, $this->seqid_, $this->output_->isStrictWrite());
}
else
{
$this->output_->writeMessageBegin('getStatus', TMessageType::CALL, $this->seqid_);
$args->write($this->output_);
$this->output_->writeMessageEnd();
$this->output_->getTransport()->flush();
}
}
public function recv_getStatus()
{
$bin_accel = ($this->input_ instanceof TProtocol::$TBINARYPROTOCOLACCELERATED) && function_exists('thrift_protocol_read_binary');
if ($bin_accel) $result = thrift_protocol_read_binary($this->input_, 'FacebookService_getStatus_result', $this->input_->isStrictRead());
else
{
$rseqid = 0;
$fname = null;
$mtype = 0;
$this->input_->readMessageBegin($fname, $mtype, $rseqid);
if ($mtype == TMessageType::EXCEPTION) {
$x = new TApplicationException();
$x->read($this->input_);
$this->input_->readMessageEnd();
throw $x;
}
$result = new FacebookService_getStatus_result();
$result->read($this->input_);
$this->input_->readMessageEnd();
}
if ($result->success !== null) {
return $result->success;
}
throw new Exception("getStatus failed: unknown result");
}
public function getStatusDetails()
{
$this->send_getStatusDetails();
return $this->recv_getStatusDetails();
}
public function send_getStatusDetails()
{
$args = new FacebookService_getStatusDetails_args();
$bin_accel = ($this->output_ instanceof TProtocol::$TBINARYPROTOCOLACCELERATED) && function_exists('thrift_protocol_write_binary');
if ($bin_accel)
{
thrift_protocol_write_binary($this->output_, 'getStatusDetails', TMessageType::CALL, $args, $this->seqid_, $this->output_->isStrictWrite());
}
else
{
$this->output_->writeMessageBegin('getStatusDetails', TMessageType::CALL, $this->seqid_);
$args->write($this->output_);
$this->output_->writeMessageEnd();
$this->output_->getTransport()->flush();
}
}
public function recv_getStatusDetails()
{
$bin_accel = ($this->input_ instanceof TProtocol::$TBINARYPROTOCOLACCELERATED) && function_exists('thrift_protocol_read_binary');
if ($bin_accel) $result = thrift_protocol_read_binary($this->input_, 'FacebookService_getStatusDetails_result', $this->input_->isStrictRead());
else
{
$rseqid = 0;
$fname = null;
$mtype = 0;
$this->input_->readMessageBegin($fname, $mtype, $rseqid);
if ($mtype == TMessageType::EXCEPTION) {
$x = new TApplicationException();
$x->read($this->input_);
$this->input_->readMessageEnd();
throw $x;
}
$result = new FacebookService_getStatusDetails_result();
$result->read($this->input_);
$this->input_->readMessageEnd();
}
if ($result->success !== null) {
return $result->success;
}
throw new Exception("getStatusDetails failed: unknown result");
}
public function getCounters()
{
$this->send_getCounters();
return $this->recv_getCounters();
}
public function send_getCounters()
{
$args = new FacebookService_getCounters_args();
$bin_accel = ($this->output_ instanceof TProtocol::$TBINARYPROTOCOLACCELERATED) && function_exists('thrift_protocol_write_binary');
if ($bin_accel)
{
thrift_protocol_write_binary($this->output_, 'getCounters', TMessageType::CALL, $args, $this->seqid_, $this->output_->isStrictWrite());
}
else
{
$this->output_->writeMessageBegin('getCounters', TMessageType::CALL, $this->seqid_);
$args->write($this->output_);
$this->output_->writeMessageEnd();
$this->output_->getTransport()->flush();
}
}
public function recv_getCounters()
{
$bin_accel = ($this->input_ instanceof TProtocol::$TBINARYPROTOCOLACCELERATED) && function_exists('thrift_protocol_read_binary');
if ($bin_accel) $result = thrift_protocol_read_binary($this->input_, 'FacebookService_getCounters_result', $this->input_->isStrictRead());
else
{
$rseqid = 0;
$fname = null;
$mtype = 0;
$this->input_->readMessageBegin($fname, $mtype, $rseqid);
if ($mtype == TMessageType::EXCEPTION) {
$x = new TApplicationException();
$x->read($this->input_);
$this->input_->readMessageEnd();
throw $x;
}
$result = new FacebookService_getCounters_result();
$result->read($this->input_);
$this->input_->readMessageEnd();
}
if ($result->success !== null) {
return $result->success;
}
throw new Exception("getCounters failed: unknown result");
}
public function getCounter($key)
{
$this->send_getCounter($key);
return $this->recv_getCounter();
}
public function send_getCounter($key)
{
$args = new FacebookService_getCounter_args();
$args->key = $key;
$bin_accel = ($this->output_ instanceof TProtocol::$TBINARYPROTOCOLACCELERATED) && function_exists('thrift_protocol_write_binary');
if ($bin_accel)
{
thrift_protocol_write_binary($this->output_, 'getCounter', TMessageType::CALL, $args, $this->seqid_, $this->output_->isStrictWrite());
}
else
{
$this->output_->writeMessageBegin('getCounter', TMessageType::CALL, $this->seqid_);
$args->write($this->output_);
$this->output_->writeMessageEnd();
$this->output_->getTransport()->flush();
}
}
public function recv_getCounter()
{
$bin_accel = ($this->input_ instanceof TProtocol::$TBINARYPROTOCOLACCELERATED) && function_exists('thrift_protocol_read_binary');
if ($bin_accel) $result = thrift_protocol_read_binary($this->input_, 'FacebookService_getCounter_result', $this->input_->isStrictRead());
else
{
$rseqid = 0;
$fname = null;
$mtype = 0;
$this->input_->readMessageBegin($fname, $mtype, $rseqid);
if ($mtype == TMessageType::EXCEPTION) {
$x = new TApplicationException();
$x->read($this->input_);
$this->input_->readMessageEnd();
throw $x;
}
$result = new FacebookService_getCounter_result();
$result->read($this->input_);
$this->input_->readMessageEnd();
}
if ($result->success !== null) {
return $result->success;
}
throw new Exception("getCounter failed: unknown result");
}
public function setOption($key, $value)
{
$this->send_setOption($key, $value);
$this->recv_setOption();
}
public function send_setOption($key, $value)
{
$args = new FacebookService_setOption_args();
$args->key = $key;
$args->value = $value;
$bin_accel = ($this->output_ instanceof TProtocol::$TBINARYPROTOCOLACCELERATED) && function_exists('thrift_protocol_write_binary');
if ($bin_accel)
{
thrift_protocol_write_binary($this->output_, 'setOption', TMessageType::CALL, $args, $this->seqid_, $this->output_->isStrictWrite());
}
else
{
$this->output_->writeMessageBegin('setOption', TMessageType::CALL, $this->seqid_);
$args->write($this->output_);
$this->output_->writeMessageEnd();
$this->output_->getTransport()->flush();
}
}
public function recv_setOption()
{
$bin_accel = ($this->input_ instanceof TProtocol::$TBINARYPROTOCOLACCELERATED) && function_exists('thrift_protocol_read_binary');
if ($bin_accel) $result = thrift_protocol_read_binary($this->input_, 'FacebookService_setOption_result', $this->input_->isStrictRead());
else
{
$rseqid = 0;
$fname = null;
$mtype = 0;
$this->input_->readMessageBegin($fname, $mtype, $rseqid);
if ($mtype == TMessageType::EXCEPTION) {
$x = new TApplicationException();
$x->read($this->input_);
$this->input_->readMessageEnd();
throw $x;
}
$result = new FacebookService_setOption_result();
$result->read($this->input_);
$this->input_->readMessageEnd();
}
return;
}
public function getOption($key)
{
$this->send_getOption($key);
return $this->recv_getOption();
}
public function send_getOption($key)
{
$args = new FacebookService_getOption_args();
$args->key = $key;
$bin_accel = ($this->output_ instanceof TProtocol::$TBINARYPROTOCOLACCELERATED) && function_exists('thrift_protocol_write_binary');
if ($bin_accel)
{
thrift_protocol_write_binary($this->output_, 'getOption', TMessageType::CALL, $args, $this->seqid_, $this->output_->isStrictWrite());
}
else
{
$this->output_->writeMessageBegin('getOption', TMessageType::CALL, $this->seqid_);
$args->write($this->output_);
$this->output_->writeMessageEnd();
$this->output_->getTransport()->flush();
}
}
public function recv_getOption()
{
$bin_accel = ($this->input_ instanceof TProtocol::$TBINARYPROTOCOLACCELERATED) && function_exists('thrift_protocol_read_binary');
if ($bin_accel) $result = thrift_protocol_read_binary($this->input_, 'FacebookService_getOption_result', $this->input_->isStrictRead());
else
{
$rseqid = 0;
$fname = null;
$mtype = 0;
$this->input_->readMessageBegin($fname, $mtype, $rseqid);
if ($mtype == TMessageType::EXCEPTION) {
$x = new TApplicationException();
$x->read($this->input_);
$this->input_->readMessageEnd();
throw $x;
}
$result = new FacebookService_getOption_result();
$result->read($this->input_);
$this->input_->readMessageEnd();
}
if ($result->success !== null) {
return $result->success;
}
throw new Exception("getOption failed: unknown result");
}
public function getOptions()
{
$this->send_getOptions();
return $this->recv_getOptions();
}
public function send_getOptions()
{
$args = new FacebookService_getOptions_args();
$bin_accel = ($this->output_ instanceof TProtocol::$TBINARYPROTOCOLACCELERATED) && function_exists('thrift_protocol_write_binary');
if ($bin_accel)
{
thrift_protocol_write_binary($this->output_, 'getOptions', TMessageType::CALL, $args, $this->seqid_, $this->output_->isStrictWrite());
}
else
{
$this->output_->writeMessageBegin('getOptions', TMessageType::CALL, $this->seqid_);
$args->write($this->output_);
$this->output_->writeMessageEnd();
$this->output_->getTransport()->flush();
}
}
public function recv_getOptions()
{
$bin_accel = ($this->input_ instanceof TProtocol::$TBINARYPROTOCOLACCELERATED) && function_exists('thrift_protocol_read_binary');
if ($bin_accel) $result = thrift_protocol_read_binary($this->input_, 'FacebookService_getOptions_result', $this->input_->isStrictRead());
else
{
$rseqid = 0;
$fname = null;
$mtype = 0;
$this->input_->readMessageBegin($fname, $mtype, $rseqid);
if ($mtype == TMessageType::EXCEPTION) {
$x = new TApplicationException();
$x->read($this->input_);
$this->input_->readMessageEnd();
throw $x;
}
$result = new FacebookService_getOptions_result();
$result->read($this->input_);
$this->input_->readMessageEnd();
}
if ($result->success !== null) {
return $result->success;
}
throw new Exception("getOptions failed: unknown result");
}
public function getCpuProfile($profileDurationInSec)
{
$this->send_getCpuProfile($profileDurationInSec);
return $this->recv_getCpuProfile();
}
public function send_getCpuProfile($profileDurationInSec)
{
$args = new FacebookService_getCpuProfile_args();
$args->profileDurationInSec = $profileDurationInSec;
$bin_accel = ($this->output_ instanceof TProtocol::$TBINARYPROTOCOLACCELERATED) && function_exists('thrift_protocol_write_binary');
if ($bin_accel)
{
thrift_protocol_write_binary($this->output_, 'getCpuProfile', TMessageType::CALL, $args, $this->seqid_, $this->output_->isStrictWrite());
}
else
{
$this->output_->writeMessageBegin('getCpuProfile', TMessageType::CALL, $this->seqid_);
$args->write($this->output_);
$this->output_->writeMessageEnd();
$this->output_->getTransport()->flush();
}
}
public function recv_getCpuProfile()
{
$bin_accel = ($this->input_ instanceof TProtocol::$TBINARYPROTOCOLACCELERATED) && function_exists('thrift_protocol_read_binary');
if ($bin_accel) $result = thrift_protocol_read_binary($this->input_, 'FacebookService_getCpuProfile_result', $this->input_->isStrictRead());
else
{
$rseqid = 0;
$fname = null;
$mtype = 0;
$this->input_->readMessageBegin($fname, $mtype, $rseqid);
if ($mtype == TMessageType::EXCEPTION) {
$x = new TApplicationException();
$x->read($this->input_);
$this->input_->readMessageEnd();
throw $x;
}
$result = new FacebookService_getCpuProfile_result();
$result->read($this->input_);
$this->input_->readMessageEnd();
}
if ($result->success !== null) {
return $result->success;
}
throw new Exception("getCpuProfile failed: unknown result");
}
public function aliveSince()
{
$this->send_aliveSince();
return $this->recv_aliveSince();
}
public function send_aliveSince()
{
$args = new FacebookService_aliveSince_args();
$bin_accel = ($this->output_ instanceof TProtocol::$TBINARYPROTOCOLACCELERATED) && function_exists('thrift_protocol_write_binary');
if ($bin_accel)
{
thrift_protocol_write_binary($this->output_, 'aliveSince', TMessageType::CALL, $args, $this->seqid_, $this->output_->isStrictWrite());
}
else
{
$this->output_->writeMessageBegin('aliveSince', TMessageType::CALL, $this->seqid_);
$args->write($this->output_);
$this->output_->writeMessageEnd();
$this->output_->getTransport()->flush();
}
}
public function recv_aliveSince()
{
$bin_accel = ($this->input_ instanceof TProtocol::$TBINARYPROTOCOLACCELERATED) && function_exists('thrift_protocol_read_binary');
if ($bin_accel) $result = thrift_protocol_read_binary($this->input_, 'FacebookService_aliveSince_result', $this->input_->isStrictRead());
else
{
$rseqid = 0;
$fname = null;
$mtype = 0;
$this->input_->readMessageBegin($fname, $mtype, $rseqid);
if ($mtype == TMessageType::EXCEPTION) {
$x = new TApplicationException();
$x->read($this->input_);
$this->input_->readMessageEnd();
throw $x;
}
$result = new FacebookService_aliveSince_result();
$result->read($this->input_);
$this->input_->readMessageEnd();
}
if ($result->success !== null) {
return $result->success;
}
throw new Exception("aliveSince failed: unknown result");
}
public function getLimitedReflection()
{
$this->send_getLimitedReflection();
return $this->recv_getLimitedReflection();
}
public function send_getLimitedReflection()
{
$args = new FacebookService_getLimitedReflection_args();
$bin_accel = ($this->output_ instanceof TProtocol::$TBINARYPROTOCOLACCELERATED) && function_exists('thrift_protocol_write_binary');
if ($bin_accel)
{
thrift_protocol_write_binary($this->output_, 'getLimitedReflection', TMessageType::CALL, $args, $this->seqid_, $this->output_->isStrictWrite());
}
else
{
$this->output_->writeMessageBegin('getLimitedReflection', TMessageType::CALL, $this->seqid_);
$args->write($this->output_);
$this->output_->writeMessageEnd();
$this->output_->getTransport()->flush();
}
}
public function recv_getLimitedReflection()
{
$bin_accel = ($this->input_ instanceof TProtocol::$TBINARYPROTOCOLACCELERATED) && function_exists('thrift_protocol_read_binary');
if ($bin_accel) $result = thrift_protocol_read_binary($this->input_, 'FacebookService_getLimitedReflection_result', $this->input_->isStrictRead());
else
{
$rseqid = 0;
$fname = null;
$mtype = 0;
$this->input_->readMessageBegin($fname, $mtype, $rseqid);
if ($mtype == TMessageType::EXCEPTION) {
$x = new TApplicationException();
$x->read($this->input_);
$this->input_->readMessageEnd();
throw $x;
}
$result = new FacebookService_getLimitedReflection_result();
$result->read($this->input_);
$this->input_->readMessageEnd();
}
if ($result->success !== null) {
return $result->success;
}
throw new Exception("getLimitedReflection failed: unknown result");
}
public function reinitialize()
{
$this->send_reinitialize();
}
public function send_reinitialize()
{
$args = new FacebookService_reinitialize_args();
$bin_accel = ($this->output_ instanceof TProtocol::$TBINARYPROTOCOLACCELERATED) && function_exists('thrift_protocol_write_binary');
if ($bin_accel)
{
thrift_protocol_write_binary($this->output_, 'reinitialize', TMessageType::CALL, $args, $this->seqid_, $this->output_->isStrictWrite());
}
else
{
$this->output_->writeMessageBegin('reinitialize', TMessageType::CALL, $this->seqid_);
$args->write($this->output_);
$this->output_->writeMessageEnd();
$this->output_->getTransport()->flush();
}
}
public function shutdown()
{
$this->send_shutdown();
}
public function send_shutdown()
{
$args = new FacebookService_shutdown_args();
$bin_accel = ($this->output_ instanceof TProtocol::$TBINARYPROTOCOLACCELERATED) && function_exists('thrift_protocol_write_binary');
if ($bin_accel)
{
thrift_protocol_write_binary($this->output_, 'shutdown', TMessageType::CALL, $args, $this->seqid_, $this->output_->isStrictWrite());
}
else
{
$this->output_->writeMessageBegin('shutdown', TMessageType::CALL, $this->seqid_);
$args->write($this->output_);
$this->output_->writeMessageEnd();
$this->output_->getTransport()->flush();
}
}
}
// HELPER FUNCTIONS AND STRUCTURES
class FacebookService_getName_args {
static $_TSPEC;
public function __construct() {
if (!isset(self::$_TSPEC)) {
self::$_TSPEC = array(
);
}
}
public function getName() {
return 'FacebookService_getName_args';
}
public function read($input)
{
$xfer = 0;
$fname = null;
$ftype = 0;
$fid = 0;
$xfer += $input->readStructBegin($fname);
while (true)
{
$xfer += $input->readFieldBegin($fname, $ftype, $fid);
if ($ftype == TType::STOP) {
break;
}
switch ($fid)
{
default:
$xfer += $input->skip($ftype);
break;
}
$xfer += $input->readFieldEnd();
}
$xfer += $input->readStructEnd();
return $xfer;
}
public function write($output) {
$xfer = 0;
$xfer += $output->writeStructBegin('FacebookService_getName_args');
$xfer += $output->writeFieldStop();
$xfer += $output->writeStructEnd();
return $xfer;
}
}
class FacebookService_getName_result {
static $_TSPEC;
public $success = null;
public function __construct($vals=null) {
if (!isset(self::$_TSPEC)) {
self::$_TSPEC = array(
0 => array(
'var' => 'success',
'type' => TType::STRING,
),
);
}
if (is_array($vals)) {
if (isset($vals['success'])) {
$this->success = $vals['success'];
}
}
}
public function getName() {
return 'FacebookService_getName_result';
}
public function read($input)
{
$xfer = 0;
$fname = null;
$ftype = 0;
$fid = 0;
$xfer += $input->readStructBegin($fname);
while (true)
{
$xfer += $input->readFieldBegin($fname, $ftype, $fid);
if ($ftype == TType::STOP) {
break;
}
switch ($fid)
{
case 0:
if ($ftype == TType::STRING) {
$xfer += $input->readString($this->success);
} else {
$xfer += $input->skip($ftype);
}
break;
default:
$xfer += $input->skip($ftype);
break;
}
$xfer += $input->readFieldEnd();
}
$xfer += $input->readStructEnd();
return $xfer;
}
public function write($output) {
$xfer = 0;
$xfer += $output->writeStructBegin('FacebookService_getName_result');
if ($this->success !== null) {
$xfer += $output->writeFieldBegin('success', TType::STRING, 0);
$xfer += $output->writeString($this->success);
$xfer += $output->writeFieldEnd();
}
$xfer += $output->writeFieldStop();
$xfer += $output->writeStructEnd();
return $xfer;
}
}
class FacebookService_getVersion_args {
static $_TSPEC;
public function __construct() {
if (!isset(self::$_TSPEC)) {
self::$_TSPEC = array(
);
}
}
public function getName() {
return 'FacebookService_getVersion_args';
}
public function read($input)
{
$xfer = 0;
$fname = null;
$ftype = 0;
$fid = 0;
$xfer += $input->readStructBegin($fname);
while (true)
{
$xfer += $input->readFieldBegin($fname, $ftype, $fid);
if ($ftype == TType::STOP) {
break;
}
switch ($fid)
{
default:
$xfer += $input->skip($ftype);
break;
}
$xfer += $input->readFieldEnd();
}
$xfer += $input->readStructEnd();
return $xfer;
}
public function write($output) {
$xfer = 0;
$xfer += $output->writeStructBegin('FacebookService_getVersion_args');
$xfer += $output->writeFieldStop();
$xfer += $output->writeStructEnd();
return $xfer;
}
}
class FacebookService_getVersion_result {
static $_TSPEC;
public $success = null;
public function __construct($vals=null) {
if (!isset(self::$_TSPEC)) {
self::$_TSPEC = array(
0 => array(
'var' => 'success',
'type' => TType::STRING,
),
);
}
if (is_array($vals)) {
if (isset($vals['success'])) {
$this->success = $vals['success'];
}
}
}
public function getName() {
return 'FacebookService_getVersion_result';
}
public function read($input)
{
$xfer = 0;
$fname = null;
$ftype = 0;
$fid = 0;
$xfer += $input->readStructBegin($fname);
while (true)
{
$xfer += $input->readFieldBegin($fname, $ftype, $fid);
if ($ftype == TType::STOP) {
break;
}
switch ($fid)
{
case 0:
if ($ftype == TType::STRING) {
$xfer += $input->readString($this->success);
} else {
$xfer += $input->skip($ftype);
}
break;
default:
$xfer += $input->skip($ftype);
break;
}
$xfer += $input->readFieldEnd();
}
$xfer += $input->readStructEnd();
return $xfer;
}
public function write($output) {
$xfer = 0;
$xfer += $output->writeStructBegin('FacebookService_getVersion_result');
if ($this->success !== null) {
$xfer += $output->writeFieldBegin('success', TType::STRING, 0);
$xfer += $output->writeString($this->success);
$xfer += $output->writeFieldEnd();
}
$xfer += $output->writeFieldStop();
$xfer += $output->writeStructEnd();
return $xfer;
}
}
class FacebookService_getStatus_args {
static $_TSPEC;
public function __construct() {
if (!isset(self::$_TSPEC)) {
self::$_TSPEC = array(
);
}
}
public function getName() {
return 'FacebookService_getStatus_args';
}
public function read($input)
{
$xfer = 0;
$fname = null;
$ftype = 0;
$fid = 0;
$xfer += $input->readStructBegin($fname);
while (true)
{
$xfer += $input->readFieldBegin($fname, $ftype, $fid);
if ($ftype == TType::STOP) {
break;
}
switch ($fid)
{
default:
$xfer += $input->skip($ftype);
break;
}
$xfer += $input->readFieldEnd();
}
$xfer += $input->readStructEnd();
return $xfer;
}
public function write($output) {
$xfer = 0;
$xfer += $output->writeStructBegin('FacebookService_getStatus_args');
$xfer += $output->writeFieldStop();
$xfer += $output->writeStructEnd();
return $xfer;
}
}
class FacebookService_getStatus_result {
static $_TSPEC;
public $success = null;
public function __construct($vals=null) {
if (!isset(self::$_TSPEC)) {
self::$_TSPEC = array(
0 => array(
'var' => 'success',
'type' => TType::I32,
),
);
}
if (is_array($vals)) {
if (isset($vals['success'])) {
$this->success = $vals['success'];
}
}
}
public function getName() {
return 'FacebookService_getStatus_result';
}
public function read($input)
{
$xfer = 0;
$fname = null;
$ftype = 0;
$fid = 0;
$xfer += $input->readStructBegin($fname);
while (true)
{
$xfer += $input->readFieldBegin($fname, $ftype, $fid);
if ($ftype == TType::STOP) {
break;
}
switch ($fid)
{
case 0:
if ($ftype == TType::I32) {
$xfer += $input->readI32($this->success);
} else {
$xfer += $input->skip($ftype);
}
break;
default:
$xfer += $input->skip($ftype);
break;
}
$xfer += $input->readFieldEnd();
}
$xfer += $input->readStructEnd();
return $xfer;
}
public function write($output) {
$xfer = 0;
$xfer += $output->writeStructBegin('FacebookService_getStatus_result');
if ($this->success !== null) {
$xfer += $output->writeFieldBegin('success', TType::I32, 0);
$xfer += $output->writeI32($this->success);
$xfer += $output->writeFieldEnd();
}
$xfer += $output->writeFieldStop();
$xfer += $output->writeStructEnd();
return $xfer;
}
}
class FacebookService_getStatusDetails_args {
static $_TSPEC;
public function __construct() {
if (!isset(self::$_TSPEC)) {
self::$_TSPEC = array(
);
}
}
public function getName() {
return 'FacebookService_getStatusDetails_args';
}
public function read($input)
{
$xfer = 0;
$fname = null;
$ftype = 0;
$fid = 0;
$xfer += $input->readStructBegin($fname);
while (true)
{
$xfer += $input->readFieldBegin($fname, $ftype, $fid);
if ($ftype == TType::STOP) {
break;
}
switch ($fid)
{
default:
$xfer += $input->skip($ftype);
break;
}
$xfer += $input->readFieldEnd();
}
$xfer += $input->readStructEnd();
return $xfer;
}
public function write($output) {
$xfer = 0;
$xfer += $output->writeStructBegin('FacebookService_getStatusDetails_args');
$xfer += $output->writeFieldStop();
$xfer += $output->writeStructEnd();
return $xfer;
}
}
class FacebookService_getStatusDetails_result {
static $_TSPEC;
public $success = null;
public function __construct($vals=null) {
if (!isset(self::$_TSPEC)) {
self::$_TSPEC = array(
0 => array(
'var' => 'success',
'type' => TType::STRING,
),
);
}
if (is_array($vals)) {
if (isset($vals['success'])) {
$this->success = $vals['success'];
}
}
}
public function getName() {
return 'FacebookService_getStatusDetails_result';
}
public function read($input)
{
$xfer = 0;
$fname = null;
$ftype = 0;
$fid = 0;
$xfer += $input->readStructBegin($fname);
while (true)
{
$xfer += $input->readFieldBegin($fname, $ftype, $fid);
if ($ftype == TType::STOP) {
break;
}
switch ($fid)
{
case 0:
if ($ftype == TType::STRING) {
$xfer += $input->readString($this->success);
} else {
$xfer += $input->skip($ftype);
}
break;
default:
$xfer += $input->skip($ftype);
break;
}
$xfer += $input->readFieldEnd();
}
$xfer += $input->readStructEnd();
return $xfer;
}
public function write($output) {
$xfer = 0;
$xfer += $output->writeStructBegin('FacebookService_getStatusDetails_result');
if ($this->success !== null) {
$xfer += $output->writeFieldBegin('success', TType::STRING, 0);
$xfer += $output->writeString($this->success);
$xfer += $output->writeFieldEnd();
}
$xfer += $output->writeFieldStop();
$xfer += $output->writeStructEnd();
return $xfer;
}
}
class FacebookService_getCounters_args {
static $_TSPEC;
public function __construct() {
if (!isset(self::$_TSPEC)) {
self::$_TSPEC = array(
);
}
}
public function getName() {
return 'FacebookService_getCounters_args';
}
public function read($input)
{
$xfer = 0;
$fname = null;
$ftype = 0;
$fid = 0;
$xfer += $input->readStructBegin($fname);
while (true)
{
$xfer += $input->readFieldBegin($fname, $ftype, $fid);
if ($ftype == TType::STOP) {
break;
}
switch ($fid)
{
default:
$xfer += $input->skip($ftype);
break;
}
$xfer += $input->readFieldEnd();
}
$xfer += $input->readStructEnd();
return $xfer;
}
public function write($output) {
$xfer = 0;
$xfer += $output->writeStructBegin('FacebookService_getCounters_args');
$xfer += $output->writeFieldStop();
$xfer += $output->writeStructEnd();
return $xfer;
}
}
class FacebookService_getCounters_result {
static $_TSPEC;
public $success = null;
public function __construct($vals=null) {
if (!isset(self::$_TSPEC)) {
self::$_TSPEC = array(
0 => array(
'var' => 'success',
'type' => TType::MAP,
'ktype' => TType::STRING,
'vtype' => TType::I64,
'key' => array(
'type' => TType::STRING,
),
'val' => array(
'type' => TType::I64,
),
),
);
}
if (is_array($vals)) {
if (isset($vals['success'])) {
$this->success = $vals['success'];
}
}
}
public function getName() {
return 'FacebookService_getCounters_result';
}
public function read($input)
{
$xfer = 0;
$fname = null;
$ftype = 0;
$fid = 0;
$xfer += $input->readStructBegin($fname);
while (true)
{
$xfer += $input->readFieldBegin($fname, $ftype, $fid);
if ($ftype == TType::STOP) {
break;
}
switch ($fid)
{
case 0:
if ($ftype == TType::MAP) {
$this->success = array();
$_size0 = 0;
$_ktype1 = 0;
$_vtype2 = 0;
$xfer += $input->readMapBegin($_ktype1, $_vtype2, $_size0);
for ($_i4 = 0; $_i4 < $_size0; ++$_i4)
{
$key5 = '';
$val6 = 0;
$xfer += $input->readString($key5);
$xfer += $input->readI64($val6);
$this->success[$key5] = $val6;
}
$xfer += $input->readMapEnd();
} else {
$xfer += $input->skip($ftype);
}
break;
default:
$xfer += $input->skip($ftype);
break;
}
$xfer += $input->readFieldEnd();
}
$xfer += $input->readStructEnd();
return $xfer;
}
public function write($output) {
$xfer = 0;
$xfer += $output->writeStructBegin('FacebookService_getCounters_result');
if ($this->success !== null) {
if (!is_array($this->success)) {
throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
}
$xfer += $output->writeFieldBegin('success', TType::MAP, 0);
{
$output->writeMapBegin(TType::STRING, TType::I64, count($this->success));
{
foreach ($this->success as $kiter7 => $viter8)
{
$xfer += $output->writeString($kiter7);
$xfer += $output->writeI64($viter8);
}
}
$output->writeMapEnd();
}
$xfer += $output->writeFieldEnd();
}
$xfer += $output->writeFieldStop();
$xfer += $output->writeStructEnd();
return $xfer;
}
}
class FacebookService_getCounter_args {
static $_TSPEC;
public $key = null;
public function __construct($vals=null) {
if (!isset(self::$_TSPEC)) {
self::$_TSPEC = array(
1 => array(
'var' => 'key',
'type' => TType::STRING,
),
);
}
if (is_array($vals)) {
if (isset($vals['key'])) {
$this->key = $vals['key'];
}
}
}
public function getName() {
return 'FacebookService_getCounter_args';
}
public function read($input)
{
$xfer = 0;
$fname = null;
$ftype = 0;
$fid = 0;
$xfer += $input->readStructBegin($fname);
while (true)
{
$xfer += $input->readFieldBegin($fname, $ftype, $fid);
if ($ftype == TType::STOP) {
break;
}
switch ($fid)
{
case 1:
if ($ftype == TType::STRING) {
$xfer += $input->readString($this->key);
} else {
$xfer += $input->skip($ftype);
}
break;
default:
$xfer += $input->skip($ftype);
break;
}
$xfer += $input->readFieldEnd();
}
$xfer += $input->readStructEnd();
return $xfer;
}
public function write($output) {
$xfer = 0;
$xfer += $output->writeStructBegin('FacebookService_getCounter_args');
if ($this->key !== null) {
$xfer += $output->writeFieldBegin('key', TType::STRING, 1);
$xfer += $output->writeString($this->key);
$xfer += $output->writeFieldEnd();
}
$xfer += $output->writeFieldStop();
$xfer += $output->writeStructEnd();
return $xfer;
}
}
class FacebookService_getCounter_result {
static $_TSPEC;
public $success = null;
public function __construct($vals=null) {
if (!isset(self::$_TSPEC)) {
self::$_TSPEC = array(
0 => array(
'var' => 'success',
'type' => TType::I64,
),
);
}
if (is_array($vals)) {
if (isset($vals['success'])) {
$this->success = $vals['success'];
}
}
}
public function getName() {
return 'FacebookService_getCounter_result';
}
public function read($input)
{
$xfer = 0;
$fname = null;
$ftype = 0;
$fid = 0;
$xfer += $input->readStructBegin($fname);
while (true)
{
$xfer += $input->readFieldBegin($fname, $ftype, $fid);
if ($ftype == TType::STOP) {
break;
}
switch ($fid)
{
case 0:
if ($ftype == TType::I64) {
$xfer += $input->readI64($this->success);
} else {
$xfer += $input->skip($ftype);
}
break;
default:
$xfer += $input->skip($ftype);
break;
}
$xfer += $input->readFieldEnd();
}
$xfer += $input->readStructEnd();
return $xfer;
}
public function write($output) {
$xfer = 0;
$xfer += $output->writeStructBegin('FacebookService_getCounter_result');
if ($this->success !== null) {
$xfer += $output->writeFieldBegin('success', TType::I64, 0);
$xfer += $output->writeI64($this->success);
$xfer += $output->writeFieldEnd();
}
$xfer += $output->writeFieldStop();
$xfer += $output->writeStructEnd();
return $xfer;
}
}
class FacebookService_setOption_args {
static $_TSPEC;
public $key = null;
public $value = null;
public function __construct($vals=null) {
if (!isset(self::$_TSPEC)) {
self::$_TSPEC = array(
1 => array(
'var' => 'key',
'type' => TType::STRING,
),
2 => array(
'var' => 'value',
'type' => TType::STRING,
),
);
}
if (is_array($vals)) {
if (isset($vals['key'])) {
$this->key = $vals['key'];
}
if (isset($vals['value'])) {
$this->value = $vals['value'];
}
}
}
public function getName() {
return 'FacebookService_setOption_args';
}
public function read($input)
{
$xfer = 0;
$fname = null;
$ftype = 0;
$fid = 0;
$xfer += $input->readStructBegin($fname);
while (true)
{
$xfer += $input->readFieldBegin($fname, $ftype, $fid);
if ($ftype == TType::STOP) {
break;
}
switch ($fid)
{
case 1:
if ($ftype == TType::STRING) {
$xfer += $input->readString($this->key);
} else {
$xfer += $input->skip($ftype);
}
break;
case 2:
if ($ftype == TType::STRING) {
$xfer += $input->readString($this->value);
} else {
$xfer += $input->skip($ftype);
}
break;
default:
$xfer += $input->skip($ftype);
break;
}
$xfer += $input->readFieldEnd();
}
$xfer += $input->readStructEnd();
return $xfer;
}
public function write($output) {
$xfer = 0;
$xfer += $output->writeStructBegin('FacebookService_setOption_args');
if ($this->key !== null) {
$xfer += $output->writeFieldBegin('key', TType::STRING, 1);
$xfer += $output->writeString($this->key);
$xfer += $output->writeFieldEnd();
}
if ($this->value !== null) {
$xfer += $output->writeFieldBegin('value', TType::STRING, 2);
$xfer += $output->writeString($this->value);
$xfer += $output->writeFieldEnd();
}
$xfer += $output->writeFieldStop();
$xfer += $output->writeStructEnd();
return $xfer;
}
}
class FacebookService_setOption_result {
static $_TSPEC;
public function __construct() {
if (!isset(self::$_TSPEC)) {
self::$_TSPEC = array(
);
}
}
public function getName() {
return 'FacebookService_setOption_result';
}
public function read($input)
{
$xfer = 0;
$fname = null;
$ftype = 0;
$fid = 0;
$xfer += $input->readStructBegin($fname);
while (true)
{
$xfer += $input->readFieldBegin($fname, $ftype, $fid);
if ($ftype == TType::STOP) {
break;
}
switch ($fid)
{
default:
$xfer += $input->skip($ftype);
break;
}
$xfer += $input->readFieldEnd();
}
$xfer += $input->readStructEnd();
return $xfer;
}
public function write($output) {
$xfer = 0;
$xfer += $output->writeStructBegin('FacebookService_setOption_result');
$xfer += $output->writeFieldStop();
$xfer += $output->writeStructEnd();
return $xfer;
}
}
class FacebookService_getOption_args {
static $_TSPEC;
public $key = null;
public function __construct($vals=null) {
if (!isset(self::$_TSPEC)) {
self::$_TSPEC = array(
1 => array(
'var' => 'key',
'type' => TType::STRING,
),
);
}
if (is_array($vals)) {
if (isset($vals['key'])) {
$this->key = $vals['key'];
}
}
}
public function getName() {
return 'FacebookService_getOption_args';
}
public function read($input)
{
$xfer = 0;
$fname = null;
$ftype = 0;
$fid = 0;
$xfer += $input->readStructBegin($fname);
while (true)
{
$xfer += $input->readFieldBegin($fname, $ftype, $fid);
if ($ftype == TType::STOP) {
break;
}
switch ($fid)
{
case 1:
if ($ftype == TType::STRING) {
$xfer += $input->readString($this->key);
} else {
$xfer += $input->skip($ftype);
}
break;
default:
$xfer += $input->skip($ftype);
break;
}
$xfer += $input->readFieldEnd();
}
$xfer += $input->readStructEnd();
return $xfer;
}
public function write($output) {
$xfer = 0;
$xfer += $output->writeStructBegin('FacebookService_getOption_args');
if ($this->key !== null) {
$xfer += $output->writeFieldBegin('key', TType::STRING, 1);
$xfer += $output->writeString($this->key);
$xfer += $output->writeFieldEnd();
}
$xfer += $output->writeFieldStop();
$xfer += $output->writeStructEnd();
return $xfer;
}
}
class FacebookService_getOption_result {
static $_TSPEC;
public $success = null;
public function __construct($vals=null) {
if (!isset(self::$_TSPEC)) {
self::$_TSPEC = array(
0 => array(
'var' => 'success',
'type' => TType::STRING,
),
);
}
if (is_array($vals)) {
if (isset($vals['success'])) {
$this->success = $vals['success'];
}
}
}
public function getName() {
return 'FacebookService_getOption_result';
}
public function read($input)
{
$xfer = 0;
$fname = null;
$ftype = 0;
$fid = 0;
$xfer += $input->readStructBegin($fname);
while (true)
{
$xfer += $input->readFieldBegin($fname, $ftype, $fid);
if ($ftype == TType::STOP) {
break;
}
switch ($fid)
{
case 0:
if ($ftype == TType::STRING) {
$xfer += $input->readString($this->success);
} else {
$xfer += $input->skip($ftype);
}
break;
default:
$xfer += $input->skip($ftype);
break;
}
$xfer += $input->readFieldEnd();
}
$xfer += $input->readStructEnd();
return $xfer;
}
public function write($output) {
$xfer = 0;
$xfer += $output->writeStructBegin('FacebookService_getOption_result');
if ($this->success !== null) {
$xfer += $output->writeFieldBegin('success', TType::STRING, 0);
$xfer += $output->writeString($this->success);
$xfer += $output->writeFieldEnd();
}
$xfer += $output->writeFieldStop();
$xfer += $output->writeStructEnd();
return $xfer;
}
}
class FacebookService_getOptions_args {
static $_TSPEC;
public function __construct() {
if (!isset(self::$_TSPEC)) {
self::$_TSPEC = array(
);
}
}
public function getName() {
return 'FacebookService_getOptions_args';
}
public function read($input)
{
$xfer = 0;
$fname = null;
$ftype = 0;
$fid = 0;
$xfer += $input->readStructBegin($fname);
while (true)
{
$xfer += $input->readFieldBegin($fname, $ftype, $fid);
if ($ftype == TType::STOP) {
break;
}
switch ($fid)
{
default:
$xfer += $input->skip($ftype);
break;
}
$xfer += $input->readFieldEnd();
}
$xfer += $input->readStructEnd();
return $xfer;
}
public function write($output) {
$xfer = 0;
$xfer += $output->writeStructBegin('FacebookService_getOptions_args');
$xfer += $output->writeFieldStop();
$xfer += $output->writeStructEnd();
return $xfer;
}
}
class FacebookService_getOptions_result {
static $_TSPEC;
public $success = null;
public function __construct($vals=null) {
if (!isset(self::$_TSPEC)) {
self::$_TSPEC = array(
0 => array(
'var' => 'success',
'type' => TType::MAP,
'ktype' => TType::STRING,
'vtype' => TType::STRING,
'key' => array(
'type' => TType::STRING,
),
'val' => array(
'type' => TType::STRING,
),
),
);
}
if (is_array($vals)) {
if (isset($vals['success'])) {
$this->success = $vals['success'];
}
}
}
public function getName() {
return 'FacebookService_getOptions_result';
}
public function read($input)
{
$xfer = 0;
$fname = null;
$ftype = 0;
$fid = 0;
$xfer += $input->readStructBegin($fname);
while (true)
{
$xfer += $input->readFieldBegin($fname, $ftype, $fid);
if ($ftype == TType::STOP) {
break;
}
switch ($fid)
{
case 0:
if ($ftype == TType::MAP) {
$this->success = array();
$_size9 = 0;
$_ktype10 = 0;
$_vtype11 = 0;
$xfer += $input->readMapBegin($_ktype10, $_vtype11, $_size9);
for ($_i13 = 0; $_i13 < $_size9; ++$_i13)
{
$key14 = '';
$val15 = '';
$xfer += $input->readString($key14);
$xfer += $input->readString($val15);
$this->success[$key14] = $val15;
}
$xfer += $input->readMapEnd();
} else {
$xfer += $input->skip($ftype);
}
break;
default:
$xfer += $input->skip($ftype);
break;
}
$xfer += $input->readFieldEnd();
}
$xfer += $input->readStructEnd();
return $xfer;
}
public function write($output) {
$xfer = 0;
$xfer += $output->writeStructBegin('FacebookService_getOptions_result');
if ($this->success !== null) {
if (!is_array($this->success)) {
throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
}
$xfer += $output->writeFieldBegin('success', TType::MAP, 0);
{
$output->writeMapBegin(TType::STRING, TType::STRING, count($this->success));
{
foreach ($this->success as $kiter16 => $viter17)
{
$xfer += $output->writeString($kiter16);
$xfer += $output->writeString($viter17);
}
}
$output->writeMapEnd();
}
$xfer += $output->writeFieldEnd();
}
$xfer += $output->writeFieldStop();
$xfer += $output->writeStructEnd();
return $xfer;
}
}
class FacebookService_getCpuProfile_args {
static $_TSPEC;
public $profileDurationInSec = null;
public function __construct($vals=null) {
if (!isset(self::$_TSPEC)) {
self::$_TSPEC = array(
1 => array(
'var' => 'profileDurationInSec',
'type' => TType::I32,
),
);
}
if (is_array($vals)) {
if (isset($vals['profileDurationInSec'])) {
$this->profileDurationInSec = $vals['profileDurationInSec'];
}
}
}
public function getName() {
return 'FacebookService_getCpuProfile_args';
}
public function read($input)
{
$xfer = 0;
$fname = null;
$ftype = 0;
$fid = 0;
$xfer += $input->readStructBegin($fname);
while (true)
{
$xfer += $input->readFieldBegin($fname, $ftype, $fid);
if ($ftype == TType::STOP) {
break;
}
switch ($fid)
{
case 1:
if ($ftype == TType::I32) {
$xfer += $input->readI32($this->profileDurationInSec);
} else {
$xfer += $input->skip($ftype);
}
break;
default:
$xfer += $input->skip($ftype);
break;
}
$xfer += $input->readFieldEnd();
}
$xfer += $input->readStructEnd();
return $xfer;
}
public function write($output) {
$xfer = 0;
$xfer += $output->writeStructBegin('FacebookService_getCpuProfile_args');
if ($this->profileDurationInSec !== null) {
$xfer += $output->writeFieldBegin('profileDurationInSec', TType::I32, 1);
$xfer += $output->writeI32($this->profileDurationInSec);
$xfer += $output->writeFieldEnd();
}
$xfer += $output->writeFieldStop();
$xfer += $output->writeStructEnd();
return $xfer;
}
}
class FacebookService_getCpuProfile_result {
static $_TSPEC;
public $success = null;
public function __construct($vals=null) {
if (!isset(self::$_TSPEC)) {
self::$_TSPEC = array(
0 => array(
'var' => 'success',
'type' => TType::STRING,
),
);
}
if (is_array($vals)) {
if (isset($vals['success'])) {
$this->success = $vals['success'];
}
}
}
public function getName() {
return 'FacebookService_getCpuProfile_result';
}
public function read($input)
{
$xfer = 0;
$fname = null;
$ftype = 0;
$fid = 0;
$xfer += $input->readStructBegin($fname);
while (true)
{
$xfer += $input->readFieldBegin($fname, $ftype, $fid);
if ($ftype == TType::STOP) {
break;
}
switch ($fid)
{
case 0:
if ($ftype == TType::STRING) {
$xfer += $input->readString($this->success);
} else {
$xfer += $input->skip($ftype);
}
break;
default:
$xfer += $input->skip($ftype);
break;
}
$xfer += $input->readFieldEnd();
}
$xfer += $input->readStructEnd();
return $xfer;
}
public function write($output) {
$xfer = 0;
$xfer += $output->writeStructBegin('FacebookService_getCpuProfile_result');
if ($this->success !== null) {
$xfer += $output->writeFieldBegin('success', TType::STRING, 0);
$xfer += $output->writeString($this->success);
$xfer += $output->writeFieldEnd();
}
$xfer += $output->writeFieldStop();
$xfer += $output->writeStructEnd();
return $xfer;
}
}
class FacebookService_aliveSince_args {
static $_TSPEC;
public function __construct() {
if (!isset(self::$_TSPEC)) {
self::$_TSPEC = array(
);
}
}
public function getName() {
return 'FacebookService_aliveSince_args';
}
public function read($input)
{
$xfer = 0;
$fname = null;
$ftype = 0;
$fid = 0;
$xfer += $input->readStructBegin($fname);
while (true)
{
$xfer += $input->readFieldBegin($fname, $ftype, $fid);
if ($ftype == TType::STOP) {
break;
}
switch ($fid)
{
default:
$xfer += $input->skip($ftype);
break;
}
$xfer += $input->readFieldEnd();
}
$xfer += $input->readStructEnd();
return $xfer;
}
public function write($output) {
$xfer = 0;
$xfer += $output->writeStructBegin('FacebookService_aliveSince_args');
$xfer += $output->writeFieldStop();
$xfer += $output->writeStructEnd();
return $xfer;
}
}
class FacebookService_aliveSince_result {
static $_TSPEC;
public $success = null;
public function __construct($vals=null) {
if (!isset(self::$_TSPEC)) {
self::$_TSPEC = array(
0 => array(
'var' => 'success',
'type' => TType::I64,
),
);
}
if (is_array($vals)) {
if (isset($vals['success'])) {
$this->success = $vals['success'];
}
}
}
public function getName() {
return 'FacebookService_aliveSince_result';
}
public function read($input)
{
$xfer = 0;
$fname = null;
$ftype = 0;
$fid = 0;
$xfer += $input->readStructBegin($fname);
while (true)
{
$xfer += $input->readFieldBegin($fname, $ftype, $fid);
if ($ftype == TType::STOP) {
break;
}
switch ($fid)
{
case 0:
if ($ftype == TType::I64) {
$xfer += $input->readI64($this->success);
} else {
$xfer += $input->skip($ftype);
}
break;
default:
$xfer += $input->skip($ftype);
break;
}
$xfer += $input->readFieldEnd();
}
$xfer += $input->readStructEnd();
return $xfer;
}
public function write($output) {
$xfer = 0;
$xfer += $output->writeStructBegin('FacebookService_aliveSince_result');
if ($this->success !== null) {
$xfer += $output->writeFieldBegin('success', TType::I64, 0);
$xfer += $output->writeI64($this->success);
$xfer += $output->writeFieldEnd();
}
$xfer += $output->writeFieldStop();
$xfer += $output->writeStructEnd();
return $xfer;
}
}
class FacebookService_getLimitedReflection_args {
static $_TSPEC;
public function __construct() {
if (!isset(self::$_TSPEC)) {
self::$_TSPEC = array(
);
}
}
public function getName() {
return 'FacebookService_getLimitedReflection_args';
}
public function read($input)
{
$xfer = 0;
$fname = null;
$ftype = 0;
$fid = 0;
$xfer += $input->readStructBegin($fname);
while (true)
{
$xfer += $input->readFieldBegin($fname, $ftype, $fid);
if ($ftype == TType::STOP) {
break;
}
switch ($fid)
{
default:
$xfer += $input->skip($ftype);
break;
}
$xfer += $input->readFieldEnd();
}
$xfer += $input->readStructEnd();
return $xfer;
}
public function write($output) {
$xfer = 0;
$xfer += $output->writeStructBegin('FacebookService_getLimitedReflection_args');
$xfer += $output->writeFieldStop();
$xfer += $output->writeStructEnd();
return $xfer;
}
}
class FacebookService_getLimitedReflection_result {
static $_TSPEC;
public $success = null;
public function __construct($vals=null) {
if (!isset(self::$_TSPEC)) {
self::$_TSPEC = array(
0 => array(
'var' => 'success',
'type' => TType::STRUCT,
'class' => 'Service',
),
);
}
if (is_array($vals)) {
if (isset($vals['success'])) {
$this->success = $vals['success'];
}
}
}
public function getName() {
return 'FacebookService_getLimitedReflection_result';
}
public function read($input)
{
$xfer = 0;
$fname = null;
$ftype = 0;
$fid = 0;
$xfer += $input->readStructBegin($fname);
while (true)
{
$xfer += $input->readFieldBegin($fname, $ftype, $fid);
if ($ftype == TType::STOP) {
break;
}
switch ($fid)
{
case 0:
if ($ftype == TType::STRUCT) {
$this->success = new Service();
$xfer += $this->success->read($input);
} else {
$xfer += $input->skip($ftype);
}
break;
default:
$xfer += $input->skip($ftype);
break;
}
$xfer += $input->readFieldEnd();
}
$xfer += $input->readStructEnd();
return $xfer;
}
public function write($output) {
$xfer = 0;
$xfer += $output->writeStructBegin('FacebookService_getLimitedReflection_result');
if ($this->success !== null) {
if (!is_object($this->success)) {
throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
}
$xfer += $output->writeFieldBegin('success', TType::STRUCT, 0);
$xfer += $this->success->write($output);
$xfer += $output->writeFieldEnd();
}
$xfer += $output->writeFieldStop();
$xfer += $output->writeStructEnd();
return $xfer;
}
}
class FacebookService_reinitialize_args {
static $_TSPEC;
public function __construct() {
if (!isset(self::$_TSPEC)) {
self::$_TSPEC = array(
);
}
}
public function getName() {
return 'FacebookService_reinitialize_args';
}
public function read($input)
{
$xfer = 0;
$fname = null;
$ftype = 0;
$fid = 0;
$xfer += $input->readStructBegin($fname);
while (true)
{
$xfer += $input->readFieldBegin($fname, $ftype, $fid);
if ($ftype == TType::STOP) {
break;
}
switch ($fid)
{
default:
$xfer += $input->skip($ftype);
break;
}
$xfer += $input->readFieldEnd();
}
$xfer += $input->readStructEnd();
return $xfer;
}
public function write($output) {
$xfer = 0;
$xfer += $output->writeStructBegin('FacebookService_reinitialize_args');
$xfer += $output->writeFieldStop();
$xfer += $output->writeStructEnd();
return $xfer;
}
}
class FacebookService_shutdown_args {
static $_TSPEC;
public function __construct() {
if (!isset(self::$_TSPEC)) {
self::$_TSPEC = array(
);
}
}
public function getName() {
return 'FacebookService_shutdown_args';
}
public function read($input)
{
$xfer = 0;
$fname = null;
$ftype = 0;
$fid = 0;
$xfer += $input->readStructBegin($fname);
while (true)
{
$xfer += $input->readFieldBegin($fname, $ftype, $fid);
if ($ftype == TType::STOP) {
break;
}
switch ($fid)
{
default:
$xfer += $input->skip($ftype);
break;
}
$xfer += $input->readFieldEnd();
}
$xfer += $input->readStructEnd();
return $xfer;
}
public function write($output) {
$xfer = 0;
$xfer += $output->writeStructBegin('FacebookService_shutdown_args');
$xfer += $output->writeFieldStop();
$xfer += $output->writeStructEnd();
return $xfer;
}
}
class FacebookServiceProcessor {
protected $handler_ = null;
public function __construct($handler) {
$this->handler_ = $handler;
}
public function process($input, $output) {
$rseqid = 0;
$fname = null;
$mtype = 0;
$input->readMessageBegin($fname, $mtype, $rseqid);
$methodname = 'process_'.$fname;
if (!method_exists($this, $methodname)) {
$input->skip(TType::STRUCT);
$input->readMessageEnd();
$x = new TApplicationException('Function '.$fname.' not implemented.', TApplicationException::UNKNOWN_METHOD);
$output->writeMessageBegin($fname, TMessageType::EXCEPTION, $rseqid);
$x->write($output);
$output->writeMessageEnd();
$output->getTransport()->flush();
return;
}
$this->$methodname($rseqid, $input, $output);
return true;
}
protected function process_getName($seqid, $input, $output) {
$args = new FacebookService_getName_args();
$args->read($input);
$input->readMessageEnd();
$result = new FacebookService_getName_result();
$result->success = $this->handler_->getName();
$output->writeMessageBegin('getName', TMessageType::REPLY, $seqid);
$result->write($output);
$output->getTransport()->flush();
}
protected function process_getVersion($seqid, $input, $output) {
$args = new FacebookService_getVersion_args();
$args->read($input);
$input->readMessageEnd();
$result = new FacebookService_getVersion_result();
$result->success = $this->handler_->getVersion();
$output->writeMessageBegin('getVersion', TMessageType::REPLY, $seqid);
$result->write($output);
$output->getTransport()->flush();
}
protected function process_getStatus($seqid, $input, $output) {
$args = new FacebookService_getStatus_args();
$args->read($input);
$input->readMessageEnd();
$result = new FacebookService_getStatus_result();
$result->success = $this->handler_->getStatus();
$output->writeMessageBegin('getStatus', TMessageType::REPLY, $seqid);
$result->write($output);
$output->getTransport()->flush();
}
protected function process_getStatusDetails($seqid, $input, $output) {
$args = new FacebookService_getStatusDetails_args();
$args->read($input);
$input->readMessageEnd();
$result = new FacebookService_getStatusDetails_result();
$result->success = $this->handler_->getStatusDetails();
$output->writeMessageBegin('getStatusDetails', TMessageType::REPLY, $seqid);
$result->write($output);
$output->getTransport()->flush();
}
protected function process_getCounters($seqid, $input, $output) {
$args = new FacebookService_getCounters_args();
$args->read($input);
$input->readMessageEnd();
$result = new FacebookService_getCounters_result();
$result->success = $this->handler_->getCounters();
$output->writeMessageBegin('getCounters', TMessageType::REPLY, $seqid);
$result->write($output);
$output->getTransport()->flush();
}
protected function process_getCounter($seqid, $input, $output) {
$args = new FacebookService_getCounter_args();
$args->read($input);
$input->readMessageEnd();
$result = new FacebookService_getCounter_result();
$result->success = $this->handler_->getCounter($args->key);
$output->writeMessageBegin('getCounter', TMessageType::REPLY, $seqid);
$result->write($output);
$output->getTransport()->flush();
}
protected function process_setOption($seqid, $input, $output) {
$args = new FacebookService_setOption_args();
$args->read($input);
$input->readMessageEnd();
$result = new FacebookService_setOption_result();
$this->handler_->setOption($args->key, $args->value);
$output->writeMessageBegin('setOption', TMessageType::REPLY, $seqid);
$result->write($output);
$output->getTransport()->flush();
}
protected function process_getOption($seqid, $input, $output) {
$args = new FacebookService_getOption_args();
$args->read($input);
$input->readMessageEnd();
$result = new FacebookService_getOption_result();
$result->success = $this->handler_->getOption($args->key);
$output->writeMessageBegin('getOption', TMessageType::REPLY, $seqid);
$result->write($output);
$output->getTransport()->flush();
}
protected function process_getOptions($seqid, $input, $output) {
$args = new FacebookService_getOptions_args();
$args->read($input);
$input->readMessageEnd();
$result = new FacebookService_getOptions_result();
$result->success = $this->handler_->getOptions();
$output->writeMessageBegin('getOptions', TMessageType::REPLY, $seqid);
$result->write($output);
$output->getTransport()->flush();
}
protected function process_getCpuProfile($seqid, $input, $output) {
$args = new FacebookService_getCpuProfile_args();
$args->read($input);
$input->readMessageEnd();
$result = new FacebookService_getCpuProfile_result();
$result->success = $this->handler_->getCpuProfile($args->profileDurationInSec);
$output->writeMessageBegin('getCpuProfile', TMessageType::REPLY, $seqid);
$result->write($output);
$output->getTransport()->flush();
}
protected function process_aliveSince($seqid, $input, $output) {
$args = new FacebookService_aliveSince_args();
$args->read($input);
$input->readMessageEnd();
$result = new FacebookService_aliveSince_result();
$result->success = $this->handler_->aliveSince();
$output->writeMessageBegin('aliveSince', TMessageType::REPLY, $seqid);
$result->write($output);
$output->getTransport()->flush();
}
protected function process_getLimitedReflection($seqid, $input, $output) {
$args = new FacebookService_getLimitedReflection_args();
$args->read($input);
$input->readMessageEnd();
$result = new FacebookService_getLimitedReflection_result();
$result->success = $this->handler_->getLimitedReflection();
$output->writeMessageBegin('getLimitedReflection', TMessageType::REPLY, $seqid);
$result->write($output);
$output->getTransport()->flush();
}
protected function process_reinitialize($seqid, $input, $output) {
$args = new FacebookService_reinitialize_args();
$args->read($input);
$input->readMessageEnd();
$this->handler_->reinitialize();
return;
}
protected function process_shutdown($seqid, $input, $output) {
$args = new FacebookService_shutdown_args();
$args->read($input);
$input->readMessageEnd();
$this->handler_->shutdown();
return;
}
}
?>
Horde_Thrift-2.0.2/lib/Horde/Thrift/thrift_root/packages/fb303/fb303_types.php 0000664 0001750 0001750 00000001313 12453742644 024770 0 ustar jan jan 0,
'STARTING' => 1,
'ALIVE' => 2,
'STOPPING' => 3,
'STOPPED' => 4,
'WARNING' => 5,
);
final class fb_status {
const DEAD = 0;
const STARTING = 1;
const ALIVE = 2;
const STOPPING = 3;
const STOPPED = 4;
const WARNING = 5;
public static $__names = array(
0 => 'DEAD',
1 => 'STARTING',
2 => 'ALIVE',
3 => 'STOPPING',
4 => 'STOPPED',
5 => 'WARNING',
);
}
?>
././@LongLink 0 0 0 150 0 003732 L Horde_Thrift-2.0.2/lib/Horde/Thrift/thrift_root/packages/reflection_limited/reflection_limited_types.php Horde_Thrift-2.0.2/lib/Horde/Thrift/thrift_root/packages/reflection_limited/reflection_limited_types0000664 0001750 0001750 00000050157 12453742644 032264 0 ustar jan jan 1,
'T_BOOL' => 2,
'T_BYTE' => 3,
'T_I16' => 6,
'T_I32' => 8,
'T_I64' => 10,
'T_DOUBLE' => 4,
'T_STRING' => 11,
'T_STRUCT' => 12,
'T_MAP' => 13,
'T_SET' => 14,
'T_LIST' => 15,
'T_ENUM' => 101,
'T_NOT_REFLECTED' => 102,
);
final class TTypeTag {
const T_VOID = 1;
const T_BOOL = 2;
const T_BYTE = 3;
const T_I16 = 6;
const T_I32 = 8;
const T_I64 = 10;
const T_DOUBLE = 4;
const T_STRING = 11;
const T_STRUCT = 12;
const T_MAP = 13;
const T_SET = 14;
const T_LIST = 15;
const T_ENUM = 101;
const T_NOT_REFLECTED = 102;
public static $__names = array(
1 => 'T_VOID',
2 => 'T_BOOL',
3 => 'T_BYTE',
6 => 'T_I16',
8 => 'T_I32',
10 => 'T_I64',
4 => 'T_DOUBLE',
11 => 'T_STRING',
12 => 'T_STRUCT',
13 => 'T_MAP',
14 => 'T_SET',
15 => 'T_LIST',
101 => 'T_ENUM',
102 => 'T_NOT_REFLECTED',
);
}
class SimpleType {
static $_TSPEC;
public $ttype = null;
public $name = null;
public function __construct($vals=null) {
if (!isset(self::$_TSPEC)) {
self::$_TSPEC = array(
1 => array(
'var' => 'ttype',
'type' => TType::I32,
),
2 => array(
'var' => 'name',
'type' => TType::STRING,
),
);
}
if (is_array($vals)) {
if (isset($vals['ttype'])) {
$this->ttype = $vals['ttype'];
}
if (isset($vals['name'])) {
$this->name = $vals['name'];
}
}
}
public function getName() {
return 'SimpleType';
}
public function read($input)
{
$xfer = 0;
$fname = null;
$ftype = 0;
$fid = 0;
$xfer += $input->readStructBegin($fname);
while (true)
{
$xfer += $input->readFieldBegin($fname, $ftype, $fid);
if ($ftype == TType::STOP) {
break;
}
switch ($fid)
{
case 1:
if ($ftype == TType::I32) {
$xfer += $input->readI32($this->ttype);
} else {
$xfer += $input->skip($ftype);
}
break;
case 2:
if ($ftype == TType::STRING) {
$xfer += $input->readString($this->name);
} else {
$xfer += $input->skip($ftype);
}
break;
default:
$xfer += $input->skip($ftype);
break;
}
$xfer += $input->readFieldEnd();
}
$xfer += $input->readStructEnd();
return $xfer;
}
public function write($output) {
$xfer = 0;
$xfer += $output->writeStructBegin('SimpleType');
if ($this->ttype !== null) {
$xfer += $output->writeFieldBegin('ttype', TType::I32, 1);
$xfer += $output->writeI32($this->ttype);
$xfer += $output->writeFieldEnd();
}
if ($this->name !== null) {
$xfer += $output->writeFieldBegin('name', TType::STRING, 2);
$xfer += $output->writeString($this->name);
$xfer += $output->writeFieldEnd();
}
$xfer += $output->writeFieldStop();
$xfer += $output->writeStructEnd();
return $xfer;
}
}
class ContainerType {
static $_TSPEC;
public $ttype = null;
public $subtype1 = null;
public $subtype2 = null;
public function __construct($vals=null) {
if (!isset(self::$_TSPEC)) {
self::$_TSPEC = array(
1 => array(
'var' => 'ttype',
'type' => TType::I32,
),
2 => array(
'var' => 'subtype1',
'type' => TType::STRUCT,
'class' => 'SimpleType',
),
3 => array(
'var' => 'subtype2',
'type' => TType::STRUCT,
'class' => 'SimpleType',
),
);
}
if (is_array($vals)) {
if (isset($vals['ttype'])) {
$this->ttype = $vals['ttype'];
}
if (isset($vals['subtype1'])) {
$this->subtype1 = $vals['subtype1'];
}
if (isset($vals['subtype2'])) {
$this->subtype2 = $vals['subtype2'];
}
}
}
public function getName() {
return 'ContainerType';
}
public function read($input)
{
$xfer = 0;
$fname = null;
$ftype = 0;
$fid = 0;
$xfer += $input->readStructBegin($fname);
while (true)
{
$xfer += $input->readFieldBegin($fname, $ftype, $fid);
if ($ftype == TType::STOP) {
break;
}
switch ($fid)
{
case 1:
if ($ftype == TType::I32) {
$xfer += $input->readI32($this->ttype);
} else {
$xfer += $input->skip($ftype);
}
break;
case 2:
if ($ftype == TType::STRUCT) {
$this->subtype1 = new SimpleType();
$xfer += $this->subtype1->read($input);
} else {
$xfer += $input->skip($ftype);
}
break;
case 3:
if ($ftype == TType::STRUCT) {
$this->subtype2 = new SimpleType();
$xfer += $this->subtype2->read($input);
} else {
$xfer += $input->skip($ftype);
}
break;
default:
$xfer += $input->skip($ftype);
break;
}
$xfer += $input->readFieldEnd();
}
$xfer += $input->readStructEnd();
return $xfer;
}
public function write($output) {
$xfer = 0;
$xfer += $output->writeStructBegin('ContainerType');
if ($this->ttype !== null) {
$xfer += $output->writeFieldBegin('ttype', TType::I32, 1);
$xfer += $output->writeI32($this->ttype);
$xfer += $output->writeFieldEnd();
}
if ($this->subtype1 !== null) {
if (!is_object($this->subtype1)) {
throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
}
$xfer += $output->writeFieldBegin('subtype1', TType::STRUCT, 2);
$xfer += $this->subtype1->write($output);
$xfer += $output->writeFieldEnd();
}
if ($this->subtype2 !== null) {
if (!is_object($this->subtype2)) {
throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
}
$xfer += $output->writeFieldBegin('subtype2', TType::STRUCT, 3);
$xfer += $this->subtype2->write($output);
$xfer += $output->writeFieldEnd();
}
$xfer += $output->writeFieldStop();
$xfer += $output->writeStructEnd();
return $xfer;
}
}
class ThriftType {
static $_TSPEC;
public $is_container = null;
public $simple_type = null;
public $container_type = null;
public function __construct($vals=null) {
if (!isset(self::$_TSPEC)) {
self::$_TSPEC = array(
1 => array(
'var' => 'is_container',
'type' => TType::BOOL,
),
2 => array(
'var' => 'simple_type',
'type' => TType::STRUCT,
'class' => 'SimpleType',
),
3 => array(
'var' => 'container_type',
'type' => TType::STRUCT,
'class' => 'ContainerType',
),
);
}
if (is_array($vals)) {
if (isset($vals['is_container'])) {
$this->is_container = $vals['is_container'];
}
if (isset($vals['simple_type'])) {
$this->simple_type = $vals['simple_type'];
}
if (isset($vals['container_type'])) {
$this->container_type = $vals['container_type'];
}
}
}
public function getName() {
return 'ThriftType';
}
public function read($input)
{
$xfer = 0;
$fname = null;
$ftype = 0;
$fid = 0;
$xfer += $input->readStructBegin($fname);
while (true)
{
$xfer += $input->readFieldBegin($fname, $ftype, $fid);
if ($ftype == TType::STOP) {
break;
}
switch ($fid)
{
case 1:
if ($ftype == TType::BOOL) {
$xfer += $input->readBool($this->is_container);
} else {
$xfer += $input->skip($ftype);
}
break;
case 2:
if ($ftype == TType::STRUCT) {
$this->simple_type = new SimpleType();
$xfer += $this->simple_type->read($input);
} else {
$xfer += $input->skip($ftype);
}
break;
case 3:
if ($ftype == TType::STRUCT) {
$this->container_type = new ContainerType();
$xfer += $this->container_type->read($input);
} else {
$xfer += $input->skip($ftype);
}
break;
default:
$xfer += $input->skip($ftype);
break;
}
$xfer += $input->readFieldEnd();
}
$xfer += $input->readStructEnd();
return $xfer;
}
public function write($output) {
$xfer = 0;
$xfer += $output->writeStructBegin('ThriftType');
if ($this->is_container !== null) {
$xfer += $output->writeFieldBegin('is_container', TType::BOOL, 1);
$xfer += $output->writeBool($this->is_container);
$xfer += $output->writeFieldEnd();
}
if ($this->simple_type !== null) {
if (!is_object($this->simple_type)) {
throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
}
$xfer += $output->writeFieldBegin('simple_type', TType::STRUCT, 2);
$xfer += $this->simple_type->write($output);
$xfer += $output->writeFieldEnd();
}
if ($this->container_type !== null) {
if (!is_object($this->container_type)) {
throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
}
$xfer += $output->writeFieldBegin('container_type', TType::STRUCT, 3);
$xfer += $this->container_type->write($output);
$xfer += $output->writeFieldEnd();
}
$xfer += $output->writeFieldStop();
$xfer += $output->writeStructEnd();
return $xfer;
}
}
class Argument {
static $_TSPEC;
public $key = null;
public $name = null;
public $type = null;
public function __construct($vals=null) {
if (!isset(self::$_TSPEC)) {
self::$_TSPEC = array(
1 => array(
'var' => 'key',
'type' => TType::I16,
),
2 => array(
'var' => 'name',
'type' => TType::STRING,
),
3 => array(
'var' => 'type',
'type' => TType::STRUCT,
'class' => 'ThriftType',
),
);
}
if (is_array($vals)) {
if (isset($vals['key'])) {
$this->key = $vals['key'];
}
if (isset($vals['name'])) {
$this->name = $vals['name'];
}
if (isset($vals['type'])) {
$this->type = $vals['type'];
}
}
}
public function getName() {
return 'Argument';
}
public function read($input)
{
$xfer = 0;
$fname = null;
$ftype = 0;
$fid = 0;
$xfer += $input->readStructBegin($fname);
while (true)
{
$xfer += $input->readFieldBegin($fname, $ftype, $fid);
if ($ftype == TType::STOP) {
break;
}
switch ($fid)
{
case 1:
if ($ftype == TType::I16) {
$xfer += $input->readI16($this->key);
} else {
$xfer += $input->skip($ftype);
}
break;
case 2:
if ($ftype == TType::STRING) {
$xfer += $input->readString($this->name);
} else {
$xfer += $input->skip($ftype);
}
break;
case 3:
if ($ftype == TType::STRUCT) {
$this->type = new ThriftType();
$xfer += $this->type->read($input);
} else {
$xfer += $input->skip($ftype);
}
break;
default:
$xfer += $input->skip($ftype);
break;
}
$xfer += $input->readFieldEnd();
}
$xfer += $input->readStructEnd();
return $xfer;
}
public function write($output) {
$xfer = 0;
$xfer += $output->writeStructBegin('Argument');
if ($this->key !== null) {
$xfer += $output->writeFieldBegin('key', TType::I16, 1);
$xfer += $output->writeI16($this->key);
$xfer += $output->writeFieldEnd();
}
if ($this->name !== null) {
$xfer += $output->writeFieldBegin('name', TType::STRING, 2);
$xfer += $output->writeString($this->name);
$xfer += $output->writeFieldEnd();
}
if ($this->type !== null) {
if (!is_object($this->type)) {
throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
}
$xfer += $output->writeFieldBegin('type', TType::STRUCT, 3);
$xfer += $this->type->write($output);
$xfer += $output->writeFieldEnd();
}
$xfer += $output->writeFieldStop();
$xfer += $output->writeStructEnd();
return $xfer;
}
}
class Method {
static $_TSPEC;
public $name = null;
public $return_type = null;
public $arguments = null;
public function __construct($vals=null) {
if (!isset(self::$_TSPEC)) {
self::$_TSPEC = array(
1 => array(
'var' => 'name',
'type' => TType::STRING,
),
2 => array(
'var' => 'return_type',
'type' => TType::STRUCT,
'class' => 'ThriftType',
),
3 => array(
'var' => 'arguments',
'type' => TType::LST,
'etype' => TType::STRUCT,
'elem' => array(
'type' => TType::STRUCT,
'class' => 'Argument',
),
),
);
}
if (is_array($vals)) {
if (isset($vals['name'])) {
$this->name = $vals['name'];
}
if (isset($vals['return_type'])) {
$this->return_type = $vals['return_type'];
}
if (isset($vals['arguments'])) {
$this->arguments = $vals['arguments'];
}
}
}
public function getName() {
return 'Method';
}
public function read($input)
{
$xfer = 0;
$fname = null;
$ftype = 0;
$fid = 0;
$xfer += $input->readStructBegin($fname);
while (true)
{
$xfer += $input->readFieldBegin($fname, $ftype, $fid);
if ($ftype == TType::STOP) {
break;
}
switch ($fid)
{
case 1:
if ($ftype == TType::STRING) {
$xfer += $input->readString($this->name);
} else {
$xfer += $input->skip($ftype);
}
break;
case 2:
if ($ftype == TType::STRUCT) {
$this->return_type = new ThriftType();
$xfer += $this->return_type->read($input);
} else {
$xfer += $input->skip($ftype);
}
break;
case 3:
if ($ftype == TType::LST) {
$this->arguments = array();
$_size0 = 0;
$_etype3 = 0;
$xfer += $input->readListBegin($_etype3, $_size0);
for ($_i4 = 0; $_i4 < $_size0; ++$_i4)
{
$elem5 = null;
$elem5 = new Argument();
$xfer += $elem5->read($input);
$this->arguments []= $elem5;
}
$xfer += $input->readListEnd();
} else {
$xfer += $input->skip($ftype);
}
break;
default:
$xfer += $input->skip($ftype);
break;
}
$xfer += $input->readFieldEnd();
}
$xfer += $input->readStructEnd();
return $xfer;
}
public function write($output) {
$xfer = 0;
$xfer += $output->writeStructBegin('Method');
if ($this->name !== null) {
$xfer += $output->writeFieldBegin('name', TType::STRING, 1);
$xfer += $output->writeString($this->name);
$xfer += $output->writeFieldEnd();
}
if ($this->return_type !== null) {
if (!is_object($this->return_type)) {
throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
}
$xfer += $output->writeFieldBegin('return_type', TType::STRUCT, 2);
$xfer += $this->return_type->write($output);
$xfer += $output->writeFieldEnd();
}
if ($this->arguments !== null) {
if (!is_array($this->arguments)) {
throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
}
$xfer += $output->writeFieldBegin('arguments', TType::LST, 3);
{
$output->writeListBegin(TType::STRUCT, count($this->arguments));
{
foreach ($this->arguments as $iter6)
{
$xfer += $iter6->write($output);
}
}
$output->writeListEnd();
}
$xfer += $output->writeFieldEnd();
}
$xfer += $output->writeFieldStop();
$xfer += $output->writeStructEnd();
return $xfer;
}
}
class Service {
static $_TSPEC;
public $name = null;
public $methods = null;
public $fully_reflected = null;
public function __construct($vals=null) {
if (!isset(self::$_TSPEC)) {
self::$_TSPEC = array(
1 => array(
'var' => 'name',
'type' => TType::STRING,
),
2 => array(
'var' => 'methods',
'type' => TType::LST,
'etype' => TType::STRUCT,
'elem' => array(
'type' => TType::STRUCT,
'class' => 'Method',
),
),
3 => array(
'var' => 'fully_reflected',
'type' => TType::BOOL,
),
);
}
if (is_array($vals)) {
if (isset($vals['name'])) {
$this->name = $vals['name'];
}
if (isset($vals['methods'])) {
$this->methods = $vals['methods'];
}
if (isset($vals['fully_reflected'])) {
$this->fully_reflected = $vals['fully_reflected'];
}
}
}
public function getName() {
return 'Service';
}
public function read($input)
{
$xfer = 0;
$fname = null;
$ftype = 0;
$fid = 0;
$xfer += $input->readStructBegin($fname);
while (true)
{
$xfer += $input->readFieldBegin($fname, $ftype, $fid);
if ($ftype == TType::STOP) {
break;
}
switch ($fid)
{
case 1:
if ($ftype == TType::STRING) {
$xfer += $input->readString($this->name);
} else {
$xfer += $input->skip($ftype);
}
break;
case 2:
if ($ftype == TType::LST) {
$this->methods = array();
$_size7 = 0;
$_etype10 = 0;
$xfer += $input->readListBegin($_etype10, $_size7);
for ($_i11 = 0; $_i11 < $_size7; ++$_i11)
{
$elem12 = null;
$elem12 = new Method();
$xfer += $elem12->read($input);
$this->methods []= $elem12;
}
$xfer += $input->readListEnd();
} else {
$xfer += $input->skip($ftype);
}
break;
case 3:
if ($ftype == TType::BOOL) {
$xfer += $input->readBool($this->fully_reflected);
} else {
$xfer += $input->skip($ftype);
}
break;
default:
$xfer += $input->skip($ftype);
break;
}
$xfer += $input->readFieldEnd();
}
$xfer += $input->readStructEnd();
return $xfer;
}
public function write($output) {
$xfer = 0;
$xfer += $output->writeStructBegin('Service');
if ($this->name !== null) {
$xfer += $output->writeFieldBegin('name', TType::STRING, 1);
$xfer += $output->writeString($this->name);
$xfer += $output->writeFieldEnd();
}
if ($this->methods !== null) {
if (!is_array($this->methods)) {
throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
}
$xfer += $output->writeFieldBegin('methods', TType::LST, 2);
{
$output->writeListBegin(TType::STRUCT, count($this->methods));
{
foreach ($this->methods as $iter13)
{
$xfer += $iter13->write($output);
}
}
$output->writeListEnd();
}
$xfer += $output->writeFieldEnd();
}
if ($this->fully_reflected !== null) {
$xfer += $output->writeFieldBegin('fully_reflected', TType::BOOL, 3);
$xfer += $output->writeBool($this->fully_reflected);
$xfer += $output->writeFieldEnd();
}
$xfer += $output->writeFieldStop();
$xfer += $output->writeStructEnd();
return $xfer;
}
}
?>
Horde_Thrift-2.0.2/lib/Horde/Thrift/thrift_root/protocol/TBinaryProtocol.php 0000664 0001750 0001750 00000023016 12453742644 025273 0 ustar jan jan
*/
/**
* Binary implementation of the Thrift protocol.
*
* @author Mark Slee
* @author Marc Kwiatkowski
*/
class TBinaryProtocol extends TProtocol {
const VERSION_MASK = 0xffff0000;
const VERSION_1 = 0x80010000;
protected $strictRead_ = false;
protected $strictWrite_ = true;
public function __construct($trans, $strictRead=false, $strictWrite=true) {
parent::__construct($trans);
$this->strictRead_ = $strictRead;
$this->strictWrite_ = $strictWrite;
}
public function writeMessageBegin($name, $type, $seqid) {
if ($this->strictWrite_) {
$version = self::VERSION_1 | $type;
return
$this->writeI32($version) +
$this->writeString($name) +
$this->writeI32($seqid);
} else {
return
$this->writeString($name) +
$this->writeByte($type) +
$this->writeI32($seqid);
}
}
public function writeMessageEnd() {
return 0;
}
public function writeStructBegin($name) {
return 0;
}
public function writeStructEnd() {
return 0;
}
public function writeFieldBegin($fieldName, $fieldType, $fieldId) {
return
$this->writeByte($fieldType) +
$this->writeI16($fieldId);
}
public function writeFieldEnd() {
return 0;
}
public function writeFieldStop() {
return
$this->writeByte(TType::STOP);
}
public function writeMapBegin($keyType, $valType, $size) {
return
$this->writeByte($keyType) +
$this->writeByte($valType) +
$this->writeI32($size);
}
public function writeMapEnd() {
return 0;
}
public function writeListBegin($elemType, $size) {
return
$this->writeByte($elemType) +
$this->writeI32($size);
}
public function writeListEnd() {
return 0;
}
public function writeSetBegin($elemType, $size) {
return
$this->writeByte($elemType) +
$this->writeI32($size);
}
public function writeSetEnd() {
return 0;
}
public function writeBool($value) {
$data = pack('c', $value ? 1 : 0);
$this->trans_->write($data, 1);
return 1;
}
public function writeByte($value) {
$data = pack('c', $value);
$this->trans_->write($data, 1);
return 1;
}
public function writeI16($value) {
$data = pack('n', $value);
$this->trans_->write($data, 2);
return 2;
}
public function writeI32($value) {
$data = pack('N', $value);
$this->trans_->write($data, 4);
return 4;
}
public function writeI64($value) {
// If we are on a 32bit architecture we have to explicitly deal with
// 64-bit twos-complement arithmetic since PHP wants to treat all ints
// as signed and any int over 2^31 - 1 as a float
if (PHP_INT_SIZE == 4) {
$neg = $value < 0;
if ($neg) {
$value *= -1;
}
$hi = (int)($value / 4294967296);
$lo = (int)$value;
if ($neg) {
$hi = ~$hi;
$lo = ~$lo;
if (($lo & (int)0xffffffff) == (int)0xffffffff) {
$lo = 0;
$hi++;
} else {
$lo++;
}
}
$data = pack('N2', $hi, $lo);
} else {
$hi = $value >> 32;
$lo = $value & 0xFFFFFFFF;
$data = pack('N2', $hi, $lo);
}
$this->trans_->write($data, 8);
return 8;
}
public function writeDouble($value) {
$data = pack('d', $value);
$this->trans_->write(strrev($data), 8);
return 8;
}
public function writeString($value) {
$len = strlen($value);
$result = $this->writeI32($len);
if ($len) {
$this->trans_->write($value, $len);
}
return $result + $len;
}
public function readMessageBegin(&$name, &$type, &$seqid) {
$result = $this->readI32($sz);
if ($sz < 0) {
$version = (int) ($sz & self::VERSION_MASK);
if ($version != (int) self::VERSION_1) {
throw new TProtocolException('Bad version identifier: '.$sz, TProtocolException::BAD_VERSION);
}
$type = $sz & 0x000000ff;
$result +=
$this->readString($name) +
$this->readI32($seqid);
} else {
if ($this->strictRead_) {
throw new TProtocolException('No version identifier, old protocol client?', TProtocolException::BAD_VERSION);
} else {
// Handle pre-versioned input
$name = $this->trans_->readAll($sz);
$result +=
$sz +
$this->readByte($type) +
$this->readI32($seqid);
}
}
return $result;
}
public function readMessageEnd() {
return 0;
}
public function readStructBegin(&$name) {
$name = '';
return 0;
}
public function readStructEnd() {
return 0;
}
public function readFieldBegin(&$name, &$fieldType, &$fieldId) {
$result = $this->readByte($fieldType);
if ($fieldType == TType::STOP) {
$fieldId = 0;
return $result;
}
$result += $this->readI16($fieldId);
return $result;
}
public function readFieldEnd() {
return 0;
}
public function readMapBegin(&$keyType, &$valType, &$size) {
return
$this->readByte($keyType) +
$this->readByte($valType) +
$this->readI32($size);
}
public function readMapEnd() {
return 0;
}
public function readListBegin(&$elemType, &$size) {
return
$this->readByte($elemType) +
$this->readI32($size);
}
public function readListEnd() {
return 0;
}
public function readSetBegin(&$elemType, &$size) {
return
$this->readByte($elemType) +
$this->readI32($size);
}
public function readSetEnd() {
return 0;
}
public function readBool(&$value) {
$data = $this->trans_->readAll(1);
$arr = unpack('c', $data);
$value = $arr[1] == 1;
return 1;
}
public function readByte(&$value) {
$data = $this->trans_->readAll(1);
$arr = unpack('c', $data);
$value = $arr[1];
return 1;
}
public function readI16(&$value) {
$data = $this->trans_->readAll(2);
$arr = unpack('n', $data);
$value = $arr[1];
if ($value > 0x7fff) {
$value = 0 - (($value - 1) ^ 0xffff);
}
return 2;
}
public function readI32(&$value) {
$data = $this->trans_->readAll(4);
$arr = unpack('N', $data);
$value = $arr[1];
if ($value > 0x7fffffff) {
$value = 0 - (($value - 1) ^ 0xffffffff);
}
return 4;
}
public function readI64(&$value) {
$data = $this->trans_->readAll(8);
$arr = unpack('N2', $data);
// If we are on a 32bit architecture we have to explicitly deal with
// 64-bit twos-complement arithmetic since PHP wants to treat all ints
// as signed and any int over 2^31 - 1 as a float
if (PHP_INT_SIZE == 4) {
$hi = $arr[1];
$lo = $arr[2];
$isNeg = $hi < 0;
// Check for a negative
if ($isNeg) {
$hi = ~$hi & (int)0xffffffff;
$lo = ~$lo & (int)0xffffffff;
if ($lo == (int)0xffffffff) {
$hi++;
$lo = 0;
} else {
$lo++;
}
}
// Force 32bit words in excess of 2G to pe positive - we deal wigh sign
// explicitly below
if ($hi & (int)0x80000000) {
$hi &= (int)0x7fffffff;
$hi += 0x80000000;
}
if ($lo & (int)0x80000000) {
$lo &= (int)0x7fffffff;
$lo += 0x80000000;
}
$value = $hi * 4294967296 + $lo;
if ($isNeg) {
$value = 0 - $value;
}
} else {
// Upcast negatives in LSB bit
if ($arr[2] & 0x80000000) {
$arr[2] = $arr[2] & 0xffffffff;
}
// Check for a negative
if ($arr[1] & 0x80000000) {
$arr[1] = $arr[1] & 0xffffffff;
$arr[1] = $arr[1] ^ 0xffffffff;
$arr[2] = $arr[2] ^ 0xffffffff;
$value = 0 - $arr[1]*4294967296 - $arr[2] - 1;
} else {
$value = $arr[1]*4294967296 + $arr[2];
}
}
return 8;
}
public function readDouble(&$value) {
$data = strrev($this->trans_->readAll(8));
$arr = unpack('d', $data);
$value = $arr[1];
return 8;
}
public function readString(&$value) {
$result = $this->readI32($len);
if ($len) {
$value = $this->trans_->readAll($len);
} else {
$value = '';
}
return $result + $len;
}
}
/**
* Binary Protocol Factory
*/
class TBinaryProtocolFactory implements TProtocolFactory {
private $strictRead_ = false;
private $strictWrite_ = false;
public function __construct($strictRead=false, $strictWrite=false) {
$this->strictRead_ = $strictRead;
$this->strictWrite_ = $strictWrite;
}
public function getProtocol($trans) {
return new TBinaryProtocol($trans, $this->strictRead, $this->strictWrite);
}
}
/**
* Accelerated binary protocol: used in conjunction with the thrift_protocol
* extension for faster deserialization
*/
class TBinaryProtocolAccelerated extends TBinaryProtocol {
public function __construct($trans, $strictRead=false, $strictWrite=true) {
// If the transport doesn't implement putBack, wrap it in a
// TBufferedTransport (which does)
if (!method_exists($trans, 'putBack')) {
$trans = new TBufferedTransport($trans);
}
parent::__construct($trans, $strictRead, $strictWrite);
}
public function isStrictRead() {
return $this->strictRead_;
}
public function isStrictWrite() {
return $this->strictWrite_;
}
}
?>
Horde_Thrift-2.0.2/lib/Horde/Thrift/thrift_root/protocol/TProtocol.php 0000664 0001750 0001750 00000022055 12453742644 024130 0 ustar jan jan
*/
/**
* Protocol module. Contains all the types and definitions needed to implement
* a protocol encoder/decoder.
*
* @package thrift.protocol
* @author Mark Slee
* @author Aditya Agarwal
*/
/**
* Protocol exceptions
*/
class TProtocolException extends TException {
const UNKNOWN = 0;
const INVALID_DATA = 1;
const NEGATIVE_SIZE = 2;
const SIZE_LIMIT = 3;
const BAD_VERSION = 4;
function __construct($message=null, $code=0) {
parent::__construct($message, $code);
}
}
/**
* Protocol base class module.
*/
abstract class TProtocol {
// The below may seem silly, but it is to get around the problem that the
// "instanceof" operator can only take in a T_VARIABLE and not a T_STRING
// or T_CONSTANT_ENCAPSED_STRING. Using "is_a()" instead of "instanceof" is
// a workaround but is deprecated in PHP5. This is used in the generated
// deserialization code.
static $TBINARYPROTOCOLACCELERATED = 'TBinaryProtocolAccelerated';
/**
* Underlying transport
*
* @var TTransport
*/
protected $trans_;
/**
* Constructor
*/
protected function __construct($trans) {
$this->trans_ = $trans;
}
/**
* Accessor for transport
*
* @return TTransport
*/
public function getTransport() {
return $this->trans_;
}
/**
* Writes the message header
*
* @param string $name Function name
* @param int $type message type TMessageType::CALL or TMessageType::REPLY
* @param int $seqid The sequence id of this message
*/
public abstract function writeMessageBegin($name, $type, $seqid);
/**
* Close the message
*/
public abstract function writeMessageEnd();
/**
* Writes a struct header.
*
* @param string $name Struct name
* @throws TException on write error
* @return int How many bytes written
*/
public abstract function writeStructBegin($name);
/**
* Close a struct.
*
* @throws TException on write error
* @return int How many bytes written
*/
public abstract function writeStructEnd();
/*
* Starts a field.
*
* @param string $name Field name
* @param int $type Field type
* @param int $fid Field id
* @throws TException on write error
* @return int How many bytes written
*/
public abstract function writeFieldBegin($fieldName, $fieldType, $fieldId);
public abstract function writeFieldEnd();
public abstract function writeFieldStop();
public abstract function writeMapBegin($keyType, $valType, $size);
public abstract function writeMapEnd();
public abstract function writeListBegin($elemType, $size);
public abstract function writeListEnd();
public abstract function writeSetBegin($elemType, $size);
public abstract function writeSetEnd();
public abstract function writeBool($bool);
public abstract function writeByte($byte);
public abstract function writeI16($i16);
public abstract function writeI32($i32);
public abstract function writeI64($i64);
public abstract function writeDouble($dub);
public abstract function writeString($str);
/**
* Reads the message header
*
* @param string $name Function name
* @param int $type message type TMessageType::CALL or TMessageType::REPLY
* @parem int $seqid The sequence id of this message
*/
public abstract function readMessageBegin(&$name, &$type, &$seqid);
/**
* Read the close of message
*/
public abstract function readMessageEnd();
public abstract function readStructBegin(&$name);
public abstract function readStructEnd();
public abstract function readFieldBegin(&$name, &$fieldType, &$fieldId);
public abstract function readFieldEnd();
public abstract function readMapBegin(&$keyType, &$valType, &$size);
public abstract function readMapEnd();
public abstract function readListBegin(&$elemType, &$size);
public abstract function readListEnd();
public abstract function readSetBegin(&$elemType, &$size);
public abstract function readSetEnd();
public abstract function readBool(&$bool);
public abstract function readByte(&$byte);
public abstract function readI16(&$i16);
public abstract function readI32(&$i32);
public abstract function readI64(&$i64);
public abstract function readDouble(&$dub);
public abstract function readString(&$str);
/**
* The skip function is a utility to parse over unrecognized date without
* causing corruption.
*
* @param TType $type What type is it
*/
public function skip($type) {
switch ($type) {
case TType::BOOL:
return $this->readBool($bool);
case TType::BYTE:
return $this->readByte($byte);
case TType::I16:
return $this->readI16($i16);
case TType::I32:
return $this->readI32($i32);
case TType::I64:
return $this->readI64($i64);
case TType::DOUBLE:
return $this->readDouble($dub);
case TType::STRING:
return $this->readString($str);
case TType::STRUCT:
{
$result = $this->readStructBegin($name);
while (true) {
$result += $this->readFieldBegin($name, $ftype, $fid);
if ($ftype == TType::STOP) {
break;
}
$result += $this->skip($ftype);
$result += $this->readFieldEnd();
}
$result += $this->readStructEnd();
return $result;
}
case TType::MAP:
{
$result = $this->readMapBegin($keyType, $valType, $size);
for ($i = 0; $i < $size; $i++) {
$result += $this->skip($keyType);
$result += $this->skip($valType);
}
$result += $this->readMapEnd();
return $result;
}
case TType::SET:
{
$result = $this->readSetBegin($elemType, $size);
for ($i = 0; $i < $size; $i++) {
$result += $this->skip($elemType);
}
$result += $this->readSetEnd();
return $result;
}
case TType::LST:
{
$result = $this->readListBegin($elemType, $size);
for ($i = 0; $i < $size; $i++) {
$result += $this->skip($elemType);
}
$result += $this->readListEnd();
return $result;
}
default:
return 0;
}
}
/**
* Utility for skipping binary data
*
* @param TTransport $itrans TTransport object
* @param int $type Field type
*/
public static function skipBinary($itrans, $type) {
switch ($type) {
case TType::BOOL:
return $itrans->readAll(1);
case TType::BYTE:
return $itrans->readAll(1);
case TType::I16:
return $itrans->readAll(2);
case TType::I32:
return $itrans->readAll(4);
case TType::I64:
return $itrans->readAll(8);
case TType::DOUBLE:
return $itrans->readAll(8);
case TType::STRING:
$len = unpack('N', $itrans->readAll(4));
$len = $len[1];
if ($len > 0x7fffffff) {
$len = 0 - (($len - 1) ^ 0xffffffff);
}
return 4 + $itrans->readAll($len);
case TType::STRUCT:
{
$result = 0;
while (true) {
$ftype = 0;
$fid = 0;
$data = $itrans->readAll(1);
$arr = unpack('c', $data);
$ftype = $arr[1];
if ($ftype == TType::STOP) {
break;
}
// I16 field id
$result += $itrans->readAll(2);
$result += self::skipBinary($itrans, $ftype);
}
return $result;
}
case TType::MAP:
{
// Ktype
$data = $itrans->readAll(1);
$arr = unpack('c', $data);
$ktype = $arr[1];
// Vtype
$data = $itrans->readAll(1);
$arr = unpack('c', $data);
$vtype = $arr[1];
// Size
$data = $itrans->readAll(4);
$arr = unpack('N', $data);
$size = $arr[1];
if ($size > 0x7fffffff) {
$size = 0 - (($size - 1) ^ 0xffffffff);
}
$result = 6;
for ($i = 0; $i < $size; $i++) {
$result += self::skipBinary($itrans, $ktype);
$result += self::skipBinary($itrans, $vtype);
}
return $result;
}
case TType::SET:
case TType::LST:
{
// Vtype
$data = $itrans->readAll(1);
$arr = unpack('c', $data);
$vtype = $arr[1];
// Size
$data = $itrans->readAll(4);
$arr = unpack('N', $data);
$size = $arr[1];
if ($size > 0x7fffffff) {
$size = 0 - (($size - 1) ^ 0xffffffff);
}
$result = 5;
for ($i = 0; $i < $size; $i++) {
$result += self::skipBinary($itrans, $vtype);
}
return $result;
}
default:
return 0;
}
}
}
/**
* Protocol factory creates protocol objects from transports
*/
interface TProtocolFactory {
/**
* Build a protocol from the base transport
*
* @return TProtcol protocol
*/
public function getProtocol($trans);
}
?>
Horde_Thrift-2.0.2/lib/Horde/Thrift/thrift_root/transport/TBufferedTransport.php 0000664 0001750 0001750 00000007020 12453742644 026154 0 ustar jan jan
*/
/**
* Buffered transport. Stores data to an internal buffer that it doesn't
* actually write out until flush is called. For reading, we do a greedy
* read and then serve data out of the internal buffer.
*
* @package thrift.transport
* @author Mark Slee
*/
class TBufferedTransport extends TTransport {
/**
* Constructor. Creates a buffered transport around an underlying transport
*/
public function __construct($transport=null, $rBufSize=512, $wBufSize=512) {
$this->transport_ = $transport;
$this->rBufSize_ = $rBufSize;
$this->wBufSize_ = $wBufSize;
}
/**
* The underlying transport
*
* @var TTransport
*/
protected $transport_ = null;
/**
* The receive buffer size
*
* @var int
*/
protected $rBufSize_ = 512;
/**
* The write buffer size
*
* @var int
*/
protected $wBufSize_ = 512;
/**
* The write buffer.
*
* @var string
*/
protected $wBuf_ = '';
/**
* The read buffer.
*
* @var string
*/
protected $rBuf_ = '';
public function isOpen() {
return $this->transport_->isOpen();
}
public function open() {
$this->transport_->open();
}
public function close() {
$this->transport_->close();
}
public function putBack($data) {
if (strlen($this->rBuf_) === 0) {
$this->rBuf_ = $data;
} else {
$this->rBuf_ = ($data . $this->rBuf_);
}
}
/**
* The reason that we customize readAll here is that the majority of PHP
* streams are already internally buffered by PHP. The socket stream, for
* example, buffers internally and blocks if you call read with $len greater
* than the amount of data available, unlike recv() in C.
*
* Therefore, use the readAll method of the wrapped transport inside
* the buffered readAll.
*/
public function readAll($len) {
$have = strlen($this->rBuf_);
if ($have == 0) {
$data = $this->transport_->readAll($len);
} else if ($have < $len) {
$data = $this->rBuf_;
$this->rBuf_ = '';
$data .= $this->transport_->readAll($len - $have);
} else if ($have == $len) {
$data = $this->rBuf_;
$this->rBuf_ = '';
} else if ($have > $len) {
$data = substr($this->rBuf_, 0, $len);
$this->rBuf_ = substr($this->rBuf_, $len);
}
return $data;
}
public function read($len) {
if (strlen($this->rBuf_) === 0) {
$this->rBuf_ = $this->transport_->read($this->rBufSize_);
}
if (strlen($this->rBuf_) <= $len) {
$ret = $this->rBuf_;
$this->rBuf_ = '';
return $ret;
}
$ret = substr($this->rBuf_, 0, $len);
$this->rBuf_ = substr($this->rBuf_, $len);
return $ret;
}
public function write($buf) {
$this->wBuf_ .= $buf;
if (strlen($this->wBuf_) >= $this->wBufSize_) {
$out = $this->wBuf_;
// Note that we clear the internal wBuf_ prior to the underlying write
// to ensure we're in a sane state (i.e. internal buffer cleaned)
// if the underlying write throws up an exception
$this->wBuf_ = '';
$this->transport_->write($out);
}
}
public function flush() {
if (strlen($this->wBuf_) > 0) {
$this->transport_->write($this->wBuf_);
$this->wBuf_ = '';
}
$this->transport_->flush();
}
}
?>
Horde_Thrift-2.0.2/lib/Horde/Thrift/thrift_root/transport/TFramedTransport.php 0000664 0001750 0001750 00000006724 12453742644 025642 0 ustar jan jan
*/
/**
* Framed transport. Writes and reads data in chunks that are stamped with
* their length.
*
* @package thrift.transport
* @author Mark Slee
*/
class TFramedTransport extends TTransport {
/**
* Underlying transport object.
*
* @var TTransport
*/
private $transport_;
/**
* Buffer for read data.
*
* @var string
*/
private $rBuf_;
/**
* Buffer for queued output data
*
* @var string
*/
private $wBuf_;
/**
* Whether to frame reads
*
* @var bool
*/
private $read_;
/**
* Whether to frame writes
*
* @var bool
*/
private $write_;
/**
* Constructor.
*
* @param TTransport $transport Underlying transport
*/
public function __construct($transport=null, $read=true, $write=true) {
$this->transport_ = $transport;
$this->read_ = $read;
$this->write_ = $write;
}
public function isOpen() {
return $this->transport_->isOpen();
}
public function open() {
$this->transport_->open();
}
public function close() {
$this->transport_->close();
}
/**
* Reads from the buffer. When more data is required reads another entire
* chunk and serves future reads out of that.
*
* @param int $len How much data
*/
public function read($len) {
if (!$this->read_) {
return $this->transport_->read($len);
}
if (strlen($this->rBuf_) === 0) {
$this->readFrame();
}
// Just return full buff
if ($len >= strlen($this->rBuf_)) {
$out = $this->rBuf_;
$this->rBuf_ = null;
return $out;
}
// Return substr
$out = substr($this->rBuf_, 0, $len);
$this->rBuf_ = substr($this->rBuf_, $len);
return $out;
}
/**
* Put previously read data back into the buffer
*
* @param string $data data to return
*/
public function putBack($data) {
if (strlen($this->rBuf_) === 0) {
$this->rBuf_ = $data;
} else {
$this->rBuf_ = ($data . $this->rBuf_);
}
}
/**
* Reads a chunk of data into the internal read buffer.
*/
private function readFrame() {
$buf = $this->transport_->readAll(4);
$val = unpack('N', $buf);
$sz = $val[1];
$this->rBuf_ = $this->transport_->readAll($sz);
}
/**
* Writes some data to the pending output buffer.
*
* @param string $buf The data
* @param int $len Limit of bytes to write
*/
public function write($buf, $len=null) {
if (!$this->write_) {
return $this->transport_->write($buf, $len);
}
if ($len !== null && $len < strlen($buf)) {
$buf = substr($buf, 0, $len);
}
$this->wBuf_ .= $buf;
}
/**
* Writes the output buffer to the stream in the format of a 4-byte length
* followed by the actual data.
*/
public function flush() {
if (!$this->write_) {
return $this->transport_->flush();
}
$out = pack('N', strlen($this->wBuf_));
$out .= $this->wBuf_;
// Note that we clear the internal wBuf_ prior to the underlying write
// to ensure we're in a sane state (i.e. internal buffer cleaned)
// if the underlying write throws up an exception
$this->wBuf_ = '';
$this->transport_->write($out);
$this->transport_->flush();
}
}
Horde_Thrift-2.0.2/lib/Horde/Thrift/thrift_root/transport/THttpClient.php 0000664 0001750 0001750 00000010434 12453742644 024576 0 ustar jan jan
*/
/**
* HTTP client for Thrift
*
* @package thrift.transport
* @author Mark Slee
*/
class THttpClient extends TTransport {
/**
* The host to connect to
*
* @var string
*/
protected $host_;
/**
* The port to connect on
*
* @var int
*/
protected $port_;
/**
* The URI to request
*
* @var string
*/
protected $uri_;
/**
* The scheme to use for the request, i.e. http, https
*
* @var string
*/
protected $scheme_;
/**
* Buffer for the HTTP request data
*
* @var string
*/
protected $buf_;
/**
* Input socket stream.
*
* @var resource
*/
protected $handle_;
/**
* Read timeout
*
* @var float
*/
protected $timeout_;
/**
* Make a new HTTP client.
*
* @param string $host
* @param int $port
* @param string $uri
*/
public function __construct($host, $port=80, $uri='', $scheme = 'http') {
if ((strlen($uri) > 0) && ($uri{0} != '/')) {
$uri = '/'.$uri;
}
$this->scheme_ = $scheme;
$this->host_ = $host;
$this->port_ = $port;
$this->uri_ = $uri;
$this->buf_ = '';
$this->handle_ = null;
$this->timeout_ = null;
}
/**
* Set read timeout
*
* @param float $timeout
*/
public function setTimeoutSecs($timeout) {
$this->timeout_ = $timeout;
}
/**
* Whether this transport is open.
*
* @return boolean true if open
*/
public function isOpen() {
return true;
}
/**
* Open the transport for reading/writing
*
* @throws TTransportException if cannot open
*/
public function open() {}
/**
* Close the transport.
*/
public function close() {
if ($this->handle_) {
@fclose($this->handle_);
$this->handle_ = null;
}
}
/**
* Read some data into the array.
*
* @param int $len How much to read
* @return string The data that has been read
* @throws TTransportException if cannot read any more data
*/
public function read($len) {
$data = @fread($this->handle_, $len);
if ($data === FALSE || $data === '') {
$md = stream_get_meta_data($this->handle_);
if ($md['timed_out']) {
throw new TTransportException('THttpClient: timed out reading '.$len.' bytes from '.$this->host_.':'.$this->port_.'/'.$this->uri_, TTransportException::TIMED_OUT);
} else {
throw new TTransportException('THttpClient: Could not read '.$len.' bytes from '.$this->host_.':'.$this->port_.'/'.$this->uri_, TTransportException::UNKNOWN);
}
}
return $data;
}
/**
* Writes some data into the pending buffer
*
* @param string $buf The data to write
* @throws TTransportException if writing fails
*/
public function write($buf) {
$this->buf_ .= $buf;
}
/**
* Opens and sends the actual request over the HTTP connection
*
* @throws TTransportException if a writing error occurs
*/
public function flush() {
// God, PHP really has some esoteric ways of doing simple things.
$host = $this->host_.($this->port_ != 80 ? ':'.$this->port_ : '');
$headers = array('Host: '.$host,
'Accept: application/x-thrift',
'User-Agent: PHP/THttpClient',
'Content-Type: application/x-thrift',
'Content-Length: '.strlen($this->buf_));
$options = array('method' => 'POST',
'header' => implode("\r\n", $headers),
'max_redirects' => 1,
'content' => $this->buf_);
if ($this->timeout_ > 0) {
$options['timeout'] = $this->timeout_;
}
$this->buf_ = '';
$contextid = stream_context_create(array('http' => $options));
$this->handle_ = @fopen($this->scheme_.'://'.$host.$this->uri_, 'r', false, $contextid);
// Connect failed?
if ($this->handle_ === FALSE) {
$this->handle_ = null;
$error = 'THttpClient: Could not connect to '.$host.$this->uri_;
throw new TTransportException($error, TTransportException::NOT_OPEN);
}
}
}
?>
Horde_Thrift-2.0.2/lib/Horde/Thrift/thrift_root/transport/TMemoryBuffer.php 0000664 0001750 0001750 00000003133 12453742644 025120 0 ustar jan jan
*/
/**
* A memory buffer is a tranpsort that simply reads from and writes to an
* in-memory string buffer. Anytime you call write on it, the data is simply
* placed into a buffer, and anytime you call read, data is read from that
* buffer.
*
* @package thrift.transport
* @author Levy Klots
*/
class TMemoryBuffer extends TTransport {
/**
* Constructor. Optionally pass an initial value
* for the buffer.
*/
public function __construct($buf = '') {
$this->buf_ = $buf;
}
protected $buf_ = '';
public function isOpen() {
return true;
}
public function open() {}
public function close() {}
public function write($buf) {
$this->buf_ .= $buf;
}
public function read($len) {
if (strlen($this->buf_) === 0) {
throw new TTransportException('TMemoryBuffer: Could not read ' .
$len . ' bytes from buffer.',
TTransportException::UNKNOWN);
}
if (strlen($this->buf_) <= $len) {
$ret = $this->buf_;
$this->buf_ = '';
return $ret;
}
$ret = substr($this->buf_, 0, $len);
$this->buf_ = substr($this->buf_, $len);
return $ret;
}
function getBuffer() {
return $this->buf_;
}
public function available() {
return strlen($this->buf_);
}
}
?>
Horde_Thrift-2.0.2/lib/Horde/Thrift/thrift_root/transport/TNullTransport.php 0000664 0001750 0001750 00000001422 12453742644 025344 0 ustar jan jan
*/
/**
* Transport that only accepts writes and ignores them.
* This is useful for measuring the serialized size of structures.
*
* @package thrift.transport
* @author David Reiss
*/
class TNullTransport extends TTransport {
public function isOpen() {
return true;
}
public function open() {}
public function close() {}
public function read($len) {
throw new TTransportException("Can't read from TNullTransport.");
}
public function write($buf) {}
}
?>
Horde_Thrift-2.0.2/lib/Horde/Thrift/thrift_root/transport/TPhpStream.php 0000664 0001750 0001750 00000004237 12453742644 024427 0 ustar jan jan
*/
/**
* Php stream transport. Reads to and writes from the php standard streams
* php://input and php://output
*
* @package thrift.transport
* @author Mark Slee
*/
class TPhpStream extends TTransport {
const MODE_R = 1;
const MODE_W = 2;
private $inStream_ = null;
private $outStream_ = null;
private $read_ = false;
private $write_ = false;
public function __construct($mode) {
$this->read_ = $mode & self::MODE_R;
$this->write_ = $mode & self::MODE_W;
}
public function open() {
if ($this->read_) {
$this->inStream_ = @fopen('php://input', 'r');
if (!is_resource($this->inStream_)) {
throw new TException('TPhpStream: Could not open php://input');
}
}
if ($this->write_) {
$this->outStream_ = @fopen('php://output', 'w');
if (!is_resource($this->outStream_)) {
throw new TException('TPhpStream: Could not open php://output');
}
}
}
public function close() {
if ($this->read_) {
@fclose($this->inStream_);
$this->inStream_ = null;
}
if ($this->write_) {
@fclose($this->outStream_);
$this->outStream_ = null;
}
}
public function isOpen() {
return
(!$this->read_ || is_resource($this->inStream_)) &&
(!$this->write_ || is_resource($this->outStream_));
}
public function read($len) {
$data = @fread($this->inStream_, $len);
if ($data === FALSE || $data === '') {
throw new TException('TPhpStream: Could not read '.$len.' bytes');
}
return $data;
}
public function write($buf) {
while (strlen($buf) > 0) {
$got = @fwrite($this->outStream_, $buf);
if ($got === 0 || $got === FALSE) {
throw new TException('TPhpStream: Could not write '.strlen($buf).' bytes');
}
$buf = substr($buf, $got);
}
}
public function flush() {
@fflush($this->outStream_);
}
}
?>
Horde_Thrift-2.0.2/lib/Horde/Thrift/thrift_root/transport/TSocket.php 0000664 0001750 0001750 00000016146 12453742644 023756 0 ustar jan jan
*/
/**
* Sockets implementation of the TTransport interface.
*
* @package thrift.transport
* @author Mark Slee
*/
class TSocket extends TTransport {
/**
* Handle to PHP socket
*
* @var resource
*/
private $handle_ = null;
/**
* Remote hostname
*
* @var string
*/
protected $host_ = 'localhost';
/**
* Remote port
*
* @var int
*/
protected $port_ = '9090';
/**
* Send timeout in milliseconds
*
* @var int
*/
private $sendTimeout_ = 100;
/**
* Recv timeout in milliseconds
*
* @var int
*/
private $recvTimeout_ = 750;
/**
* Is send timeout set?
*
* @var bool
*/
private $sendTimeoutSet_ = FALSE;
/**
* Persistent socket or plain?
*
* @var bool
*/
private $persist_ = FALSE;
/**
* Debugging on?
*
* @var bool
*/
protected $debug_ = FALSE;
/**
* Debug handler
*
* @var mixed
*/
protected $debugHandler_ = null;
/**
* Socket constructor
*
* @param string $host Remote hostname
* @param int $port Remote port
* @param bool $persist Whether to use a persistent socket
* @param string $debugHandler Function to call for error logging
*/
public function __construct($host='localhost',
$port=9090,
$persist=FALSE,
$debugHandler=null) {
$this->host_ = $host;
$this->port_ = $port;
$this->persist_ = $persist;
$this->debugHandler_ = $debugHandler ? $debugHandler : 'error_log';
}
/**
* Sets the send timeout.
*
* @param int $timeout
*/
public function setSendTimeout($timeout) {
$this->sendTimeout_ = $timeout;
}
/**
* Sets the receive timeout.
*
* @param int $timeout
*/
public function setRecvTimeout($timeout) {
$this->recvTimeout_ = $timeout;
}
/**
* Sets debugging output on or off
*
* @param bool $debug
*/
public function setDebug($debug) {
$this->debug_ = $debug;
}
/**
* Get the host that this socket is connected to
*
* @return string host
*/
public function getHost() {
return $this->host_;
}
/**
* Get the remote port that this socket is connected to
*
* @return int port
*/
public function getPort() {
return $this->port_;
}
/**
* Tests whether this is open
*
* @return bool true if the socket is open
*/
public function isOpen() {
return is_resource($this->handle_);
}
/**
* Connects the socket.
*/
public function open() {
if ($this->persist_) {
$this->handle_ = @pfsockopen($this->host_,
$this->port_,
$errno,
$errstr,
$this->sendTimeout_/1000.0);
} else {
$this->handle_ = @fsockopen($this->host_,
$this->port_,
$errno,
$errstr,
$this->sendTimeout_/1000.0);
}
// Connect failed?
if ($this->handle_ === FALSE) {
$error = 'TSocket: Could not connect to '.$this->host_.':'.$this->port_.' ('.$errstr.' ['.$errno.'])';
if ($this->debug_) {
call_user_func($this->debugHandler_, $error);
}
throw new TException($error);
}
stream_set_timeout($this->handle_, 0, $this->sendTimeout_*1000);
$this->sendTimeoutSet_ = TRUE;
}
/**
* Closes the socket.
*/
public function close() {
if (!$this->persist_) {
@fclose($this->handle_);
$this->handle_ = null;
}
}
/**
* Uses stream get contents to do the reading
*
* @param int $len How many bytes
* @return string Binary data
*/
public function readAll($len) {
if ($this->sendTimeoutSet_) {
stream_set_timeout($this->handle_, 0, $this->recvTimeout_*1000);
$this->sendTimeoutSet_ = FALSE;
}
// This call does not obey stream_set_timeout values!
// $buf = @stream_get_contents($this->handle_, $len);
$pre = null;
while (TRUE) {
$buf = @fread($this->handle_, $len);
if ($buf === FALSE || $buf === '') {
$md = stream_get_meta_data($this->handle_);
if ($md['timed_out']) {
throw new TException('TSocket: timed out reading '.$len.' bytes from '.
$this->host_.':'.$this->port_);
} else {
throw new TException('TSocket: Could not read '.$len.' bytes from '.
$this->host_.':'.$this->port_);
}
} else if (($sz = strlen($buf)) < $len) {
$md = stream_get_meta_data($this->handle_);
if ($md['timed_out']) {
throw new TException('TSocket: timed out reading '.$len.' bytes from '.
$this->host_.':'.$this->port_);
} else {
$pre .= $buf;
$len -= $sz;
}
} else {
return $pre.$buf;
}
}
}
/**
* Read from the socket
*
* @param int $len How many bytes
* @return string Binary data
*/
public function read($len) {
if ($this->sendTimeoutSet_) {
stream_set_timeout($this->handle_, 0, $this->recvTimeout_*1000);
$this->sendTimeoutSet_ = FALSE;
}
$data = @fread($this->handle_, $len);
if ($data === FALSE || $data === '') {
$md = stream_get_meta_data($this->handle_);
if ($md['timed_out']) {
throw new TException('TSocket: timed out reading '.$len.' bytes from '.
$this->host_.':'.$this->port_);
} else {
throw new TException('TSocket: Could not read '.$len.' bytes from '.
$this->host_.':'.$this->port_);
}
}
return $data;
}
/**
* Write to the socket.
*
* @param string $buf The data to write
*/
public function write($buf) {
if (!$this->sendTimeoutSet_) {
stream_set_timeout($this->handle_, 0, $this->sendTimeout_*1000);
$this->sendTimeoutSet_ = TRUE;
}
while (strlen($buf) > 0) {
$got = @fwrite($this->handle_, $buf);
if ($got === 0 || $got === FALSE) {
$md = stream_get_meta_data($this->handle_);
if ($md['timed_out']) {
throw new TException('TSocket: timed out writing '.strlen($buf).' bytes from '.
$this->host_.':'.$this->port_);
} else {
throw new TException('TSocket: Could not write '.strlen($buf).' bytes '.
$this->host_.':'.$this->port_);
}
}
$buf = substr($buf, $got);
}
}
/**
* Flush output to the socket.
*/
public function flush() {
$ret = fflush($this->handle_);
if ($ret === FALSE) {
throw new TException('TSocket: Could not flush: '.
$this->host_.':'.$this->port_);
}
}
}
?>
Horde_Thrift-2.0.2/lib/Horde/Thrift/thrift_root/transport/TSocketPool.php 0000664 0001750 0001750 00000017213 12453742644 024604 0 ustar jan jan
*/
/** Inherits from Socket */
include_once $GLOBALS['THRIFT_ROOT'].'/transport/TSocket.php';
/**
* This library makes use of APC cache to make hosts as down in a web
* environment. If you are running from the CLI or on a system without APC
* installed, then these null functions will step in and act like cache
* misses.
*/
if (!function_exists('apc_fetch')) {
function apc_fetch($key) { return FALSE; }
function apc_store($key, $var, $ttl=0) { return FALSE; }
}
/**
* Sockets implementation of the TTransport interface that allows connection
* to a pool of servers.
*
* @package thrift.transport
* @author Mark Slee
*/
class TSocketPool extends TSocket {
/**
* Remote servers. Array of associative arrays with 'host' and 'port' keys
*/
private $servers_ = array();
/**
* How many times to retry each host in connect
*
* @var int
*/
private $numRetries_ = 1;
/**
* Retry interval in seconds, how long to not try a host if it has been
* marked as down.
*
* @var int
*/
private $retryInterval_ = 60;
/**
* Max consecutive failures before marking a host down.
*
* @var int
*/
private $maxConsecutiveFailures_ = 1;
/**
* Try hosts in order? or Randomized?
*
* @var bool
*/
private $randomize_ = TRUE;
/**
* Always try last host, even if marked down?
*
* @var bool
*/
private $alwaysTryLast_ = TRUE;
/**
* Socket pool constructor
*
* @param array $hosts List of remote hostnames
* @param mixed $ports Array of remote ports, or a single common port
* @param bool $persist Whether to use a persistent socket
* @param mixed $debugHandler Function for error logging
*/
public function __construct($hosts=array('localhost'),
$ports=array(9090),
$persist=FALSE,
$debugHandler=null) {
parent::__construct(null, 0, $persist, $debugHandler);
if (!is_array($ports)) {
$port = $ports;
$ports = array();
foreach ($hosts as $key => $val) {
$ports[$key] = $port;
}
}
foreach ($hosts as $key => $host) {
$this->servers_ []= array('host' => $host,
'port' => $ports[$key]);
}
}
/**
* Add a server to the pool
*
* This function does not prevent you from adding a duplicate server entry.
*
* @param string $host hostname or IP
* @param int $port port
*/
public function addServer($host, $port) {
$this->servers_[] = array('host' => $host, 'port' => $port);
}
/**
* Sets how many time to keep retrying a host in the connect function.
*
* @param int $numRetries
*/
public function setNumRetries($numRetries) {
$this->numRetries_ = $numRetries;
}
/**
* Sets how long to wait until retrying a host if it was marked down
*
* @param int $numRetries
*/
public function setRetryInterval($retryInterval) {
$this->retryInterval_ = $retryInterval;
}
/**
* Sets how many time to keep retrying a host before marking it as down.
*
* @param int $numRetries
*/
public function setMaxConsecutiveFailures($maxConsecutiveFailures) {
$this->maxConsecutiveFailures_ = $maxConsecutiveFailures;
}
/**
* Turns randomization in connect order on or off.
*
* @param bool $randomize
*/
public function setRandomize($randomize) {
$this->randomize_ = $randomize;
}
/**
* Whether to always try the last server.
*
* @param bool $alwaysTryLast
*/
public function setAlwaysTryLast($alwaysTryLast) {
$this->alwaysTryLast_ = $alwaysTryLast;
}
/**
* Connects the socket by iterating through all the servers in the pool
* and trying to find one that works.
*/
public function open() {
// Check if we want order randomization
if ($this->randomize_) {
shuffle($this->servers_);
}
// Count servers to identify the "last" one
$numServers = count($this->servers_);
for ($i = 0; $i < $numServers; ++$i) {
// This extracts the $host and $port variables
extract($this->servers_[$i]);
// Check APC cache for a record of this server being down
$failtimeKey = 'thrift_failtime:'.$host.':'.$port.'~';
// Cache miss? Assume it's OK
$lastFailtime = apc_fetch($failtimeKey);
if ($lastFailtime === FALSE) {
$lastFailtime = 0;
}
$retryIntervalPassed = FALSE;
// Cache hit...make sure enough the retry interval has elapsed
if ($lastFailtime > 0) {
$elapsed = time() - $lastFailtime;
if ($elapsed > $this->retryInterval_) {
$retryIntervalPassed = TRUE;
if ($this->debug_) {
call_user_func($this->debugHandler_,
'TSocketPool: retryInterval '.
'('.$this->retryInterval_.') '.
'has passed for host '.$host.':'.$port);
}
}
}
// Only connect if not in the middle of a fail interval, OR if this
// is the LAST server we are trying, just hammer away on it
$isLastServer = FALSE;
if ($this->alwaysTryLast_) {
$isLastServer = ($i == ($numServers - 1));
}
if (($lastFailtime === 0) ||
($isLastServer) ||
($lastFailtime > 0 && $retryIntervalPassed)) {
// Set underlying TSocket params to this one
$this->host_ = $host;
$this->port_ = $port;
// Try up to numRetries_ connections per server
for ($attempt = 0; $attempt < $this->numRetries_; $attempt++) {
try {
// Use the underlying TSocket open function
parent::open();
// Only clear the failure counts if required to do so
if ($lastFailtime > 0) {
apc_store($failtimeKey, 0);
}
// Successful connection, return now
return;
} catch (TException $tx) {
// Connection failed
}
}
// Mark failure of this host in the cache
$consecfailsKey = 'thrift_consecfails:'.$host.':'.$port.'~';
// Ignore cache misses
$consecfails = apc_fetch($consecfailsKey);
if ($consecfails === FALSE) {
$consecfails = 0;
}
// Increment by one
$consecfails++;
// Log and cache this failure
if ($consecfails >= $this->maxConsecutiveFailures_) {
if ($this->debug_) {
call_user_func($this->debugHandler_,
'TSocketPool: marking '.$host.':'.$port.
' as down for '.$this->retryInterval_.' secs '.
'after '.$consecfails.' failed attempts.');
}
// Store the failure time
apc_store($failtimeKey, time());
// Clear the count of consecutive failures
apc_store($consecfailsKey, 0);
} else {
apc_store($consecfailsKey, $consecfails);
}
}
}
// Holy shit we failed them all. The system is totally ill!
$error = 'TSocketPool: All hosts in pool are down. ';
$hosts = array();
foreach ($this->servers_ as $server) {
$hosts []= $server['host'].':'.$server['port'];
}
$hostlist = implode(',', $hosts);
$error .= '('.$hostlist.')';
if ($this->debug_) {
call_user_func($this->debugHandler_, $error);
}
throw new TException($error);
}
}
?>
Horde_Thrift-2.0.2/lib/Horde/Thrift/thrift_root/transport/TTransport.php 0000664 0001750 0001750 00000003770 12453742644 024521 0 ustar jan jan
*/
/**
* Transport exceptions
*/
class TTransportException extends TException {
const UNKNOWN = 0;
const NOT_OPEN = 1;
const ALREADY_OPEN = 2;
const TIMED_OUT = 3;
const END_OF_FILE = 4;
function __construct($message=null, $code=0) {
parent::__construct($message, $code);
}
}
/**
* Base interface for a transport agent.
*
* @package thrift.transport
* @author Mark Slee
*/
abstract class TTransport {
/**
* Whether this transport is open.
*
* @return boolean true if open
*/
public abstract function isOpen();
/**
* Open the transport for reading/writing
*
* @throws TTransportException if cannot open
*/
public abstract function open();
/**
* Close the transport.
*/
public abstract function close();
/**
* Read some data into the array.
*
* @param int $len How much to read
* @return string The data that has been read
* @throws TTransportException if cannot read any more data
*/
public abstract function read($len);
/**
* Guarantees that the full amount of data is read.
*
* @return string The data, of exact length
* @throws TTransportException if cannot read data
*/
public function readAll($len) {
// return $this->read($len);
$data = '';
$got = 0;
while (($got = strlen($data)) < $len) {
$data .= $this->read($len - $got);
}
return $data;
}
/**
* Writes the given data out.
*
* @param string $buf The data to write
* @throws TTransportException if writing fails
*/
public abstract function write($buf);
/**
* Flushes any pending data out of a buffer
*
* @throws TTransportException if a writing error occurs
*/
public function flush() {}
}
?>
Horde_Thrift-2.0.2/lib/Horde/Thrift/thrift_root/Thrift.php 0000664 0001750 0001750 00000053407 12453742644 021607 0 ustar jan jan
*/
/**
* Data types that can be sent via Thrift
*/
class TType {
const STOP = 0;
const VOID = 1;
const BOOL = 2;
const BYTE = 3;
const I08 = 3;
const DOUBLE = 4;
const I16 = 6;
const I32 = 8;
const I64 = 10;
const STRING = 11;
const UTF7 = 11;
const STRUCT = 12;
const MAP = 13;
const SET = 14;
const LST = 15; // N.B. cannot use LIST keyword in PHP!
const UTF8 = 16;
const UTF16 = 17;
}
/**
* Message types for RPC
*/
class TMessageType {
const CALL = 1;
const REPLY = 2;
const EXCEPTION = 3;
}
/**
* NOTE(mcslee): This currently contains a ton of duplicated code from TBase
* because we need to save CPU cycles and this is not yet in an extension.
* Ideally we'd multiply-inherit TException from both Exception and Base, but
* that's not possible in PHP and there are no modules either, so for now we
* apologetically take a trip to HackTown.
*
* Can be called with standard Exception constructor (message, code) or with
* Thrift Base object constructor (spec, vals).
*
* @param mixed $p1 Message (string) or type-spec (array)
* @param mixed $p2 Code (integer) or values (array)
*/
class TException extends Exception {
function __construct($p1=null, $p2=0) {
if (is_array($p1) && is_array($p2)) {
$spec = $p1;
$vals = $p2;
foreach ($spec as $fid => $fspec) {
$var = $fspec['var'];
if (isset($vals[$var])) {
$this->$var = $vals[$var];
}
}
} else {
parent::__construct($p1, $p2);
}
}
static $tmethod = array(TType::BOOL => 'Bool',
TType::BYTE => 'Byte',
TType::I16 => 'I16',
TType::I32 => 'I32',
TType::I64 => 'I64',
TType::DOUBLE => 'Double',
TType::STRING => 'String');
private function _readMap(&$var, $spec, $input) {
$xfer = 0;
$ktype = $spec['ktype'];
$vtype = $spec['vtype'];
$kread = $vread = null;
if (isset(TBase::$tmethod[$ktype])) {
$kread = 'read'.TBase::$tmethod[$ktype];
} else {
$kspec = $spec['key'];
}
if (isset(TBase::$tmethod[$vtype])) {
$vread = 'read'.TBase::$tmethod[$vtype];
} else {
$vspec = $spec['val'];
}
$var = array();
$_ktype = $_vtype = $size = 0;
$xfer += $input->readMapBegin($_ktype, $_vtype, $size);
for ($i = 0; $i < $size; ++$i) {
$key = $val = null;
if ($kread !== null) {
$xfer += $input->$kread($key);
} else {
switch ($ktype) {
case TType::STRUCT:
$class = $kspec['class'];
$key = new $class();
$xfer += $key->read($input);
break;
case TType::MAP:
$xfer += $this->_readMap($key, $kspec, $input);
break;
case TType::LST:
$xfer += $this->_readList($key, $kspec, $input, false);
break;
case TType::SET:
$xfer += $this->_readList($key, $kspec, $input, true);
break;
}
}
if ($vread !== null) {
$xfer += $input->$vread($val);
} else {
switch ($vtype) {
case TType::STRUCT:
$class = $vspec['class'];
$val = new $class();
$xfer += $val->read($input);
break;
case TType::MAP:
$xfer += $this->_readMap($val, $vspec, $input);
break;
case TType::LST:
$xfer += $this->_readList($val, $vspec, $input, false);
break;
case TType::SET:
$xfer += $this->_readList($val, $vspec, $input, true);
break;
}
}
$var[$key] = $val;
}
$xfer += $input->readMapEnd();
return $xfer;
}
private function _readList(&$var, $spec, $input, $set=false) {
$xfer = 0;
$etype = $spec['etype'];
$eread = $vread = null;
if (isset(TBase::$tmethod[$etype])) {
$eread = 'read'.TBase::$tmethod[$etype];
} else {
$espec = $spec['elem'];
}
$var = array();
$_etype = $size = 0;
if ($set) {
$xfer += $input->readSetBegin($_etype, $size);
} else {
$xfer += $input->readListBegin($_etype, $size);
}
for ($i = 0; $i < $size; ++$i) {
$elem = null;
if ($eread !== null) {
$xfer += $input->$eread($elem);
} else {
$espec = $spec['elem'];
switch ($etype) {
case TType::STRUCT:
$class = $espec['class'];
$elem = new $class();
$xfer += $elem->read($input);
break;
case TType::MAP:
$xfer += $this->_readMap($elem, $espec, $input);
break;
case TType::LST:
$xfer += $this->_readList($elem, $espec, $input, false);
break;
case TType::SET:
$xfer += $this->_readList($elem, $espec, $input, true);
break;
}
}
if ($set) {
$var[$elem] = true;
} else {
$var []= $elem;
}
}
if ($set) {
$xfer += $input->readSetEnd();
} else {
$xfer += $input->readListEnd();
}
return $xfer;
}
protected function _read($class, $spec, $input) {
$xfer = 0;
$fname = null;
$ftype = 0;
$fid = 0;
$xfer += $input->readStructBegin($fname);
while (true) {
$xfer += $input->readFieldBegin($fname, $ftype, $fid);
if ($ftype == TType::STOP) {
break;
}
if (isset($spec[$fid])) {
$fspec = $spec[$fid];
$var = $fspec['var'];
if ($ftype == $fspec['type']) {
$xfer = 0;
if (isset(TBase::$tmethod[$ftype])) {
$func = 'read'.TBase::$tmethod[$ftype];
$xfer += $input->$func($this->$var);
} else {
switch ($ftype) {
case TType::STRUCT:
$class = $fspec['class'];
$this->$var = new $class();
$xfer += $this->$var->read($input);
break;
case TType::MAP:
$xfer += $this->_readMap($this->$var, $fspec, $input);
break;
case TType::LST:
$xfer += $this->_readList($this->$var, $fspec, $input, false);
break;
case TType::SET:
$xfer += $this->_readList($this->$var, $fspec, $input, true);
break;
}
}
} else {
$xfer += $input->skip($ftype);
}
} else {
$xfer += $input->skip($ftype);
}
$xfer += $input->readFieldEnd();
}
$xfer += $input->readStructEnd();
return $xfer;
}
private function _writeMap($var, $spec, $output) {
$xfer = 0;
$ktype = $spec['ktype'];
$vtype = $spec['vtype'];
$kwrite = $vwrite = null;
if (isset(TBase::$tmethod[$ktype])) {
$kwrite = 'write'.TBase::$tmethod[$ktype];
} else {
$kspec = $spec['key'];
}
if (isset(TBase::$tmethod[$vtype])) {
$vwrite = 'write'.TBase::$tmethod[$vtype];
} else {
$vspec = $spec['val'];
}
$xfer += $output->writeMapBegin($ktype, $vtype, count($var));
foreach ($var as $key => $val) {
if (isset($kwrite)) {
$xfer += $output->$kwrite($key);
} else {
switch ($ktype) {
case TType::STRUCT:
$xfer += $key->write($output);
break;
case TType::MAP:
$xfer += $this->_writeMap($key, $kspec, $output);
break;
case TType::LST:
$xfer += $this->_writeList($key, $kspec, $output, false);
break;
case TType::SET:
$xfer += $this->_writeList($key, $kspec, $output, true);
break;
}
}
if (isset($vwrite)) {
$xfer += $output->$vwrite($val);
} else {
switch ($vtype) {
case TType::STRUCT:
$xfer += $val->write($output);
break;
case TType::MAP:
$xfer += $this->_writeMap($val, $vspec, $output);
break;
case TType::LST:
$xfer += $this->_writeList($val, $vspec, $output, false);
break;
case TType::SET:
$xfer += $this->_writeList($val, $vspec, $output, true);
break;
}
}
}
$xfer += $output->writeMapEnd();
return $xfer;
}
private function _writeList($var, $spec, $output, $set=false) {
$xfer = 0;
$etype = $spec['etype'];
$ewrite = null;
if (isset(TBase::$tmethod[$etype])) {
$ewrite = 'write'.TBase::$tmethod[$etype];
} else {
$espec = $spec['elem'];
}
if ($set) {
$xfer += $output->writeSetBegin($etype, count($var));
} else {
$xfer += $output->writeListBegin($etype, count($var));
}
foreach ($var as $key => $val) {
$elem = $set ? $key : $val;
if (isset($ewrite)) {
$xfer += $output->$ewrite($elem);
} else {
switch ($etype) {
case TType::STRUCT:
$xfer += $elem->write($output);
break;
case TType::MAP:
$xfer += $this->_writeMap($elem, $espec, $output);
break;
case TType::LST:
$xfer += $this->_writeList($elem, $espec, $output, false);
break;
case TType::SET:
$xfer += $this->_writeList($elem, $espec, $output, true);
break;
}
}
}
if ($set) {
$xfer += $output->writeSetEnd();
} else {
$xfer += $output->writeListEnd();
}
return $xfer;
}
protected function _write($class, $spec, $output) {
$xfer = 0;
$xfer += $output->writeStructBegin($class);
foreach ($spec as $fid => $fspec) {
$var = $fspec['var'];
if ($this->$var !== null) {
$ftype = $fspec['type'];
$xfer += $output->writeFieldBegin($var, $ftype, $fid);
if (isset(TBase::$tmethod[$ftype])) {
$func = 'write'.TBase::$tmethod[$ftype];
$xfer += $output->$func($this->$var);
} else {
switch ($ftype) {
case TType::STRUCT:
$xfer += $this->$var->write($output);
break;
case TType::MAP:
$xfer += $this->_writeMap($this->$var, $fspec, $output);
break;
case TType::LST:
$xfer += $this->_writeList($this->$var, $fspec, $output, false);
break;
case TType::SET:
$xfer += $this->_writeList($this->$var, $fspec, $output, true);
break;
}
}
$xfer += $output->writeFieldEnd();
}
}
$xfer += $output->writeFieldStop();
$xfer += $output->writeStructEnd();
return $xfer;
}
}
/**
* Base class from which other Thrift structs extend. This is so that we can
* cut back on the size of the generated code which is turning out to have a
* nontrivial cost just to load thanks to the wondrously abysmal implementation
* of PHP. Note that code is intentionally duplicated in here to avoid making
* function calls for every field or member of a container..
*/
abstract class TBase {
static $tmethod = array(TType::BOOL => 'Bool',
TType::BYTE => 'Byte',
TType::I16 => 'I16',
TType::I32 => 'I32',
TType::I64 => 'I64',
TType::DOUBLE => 'Double',
TType::STRING => 'String');
abstract function read($input);
abstract function write($output);
public function __construct($spec=null, $vals=null) {
if (is_array($spec) && is_array($vals)) {
foreach ($spec as $fid => $fspec) {
$var = $fspec['var'];
if (isset($vals[$var])) {
$this->$var = $vals[$var];
}
}
}
}
private function _readMap(&$var, $spec, $input) {
$xfer = 0;
$ktype = $spec['ktype'];
$vtype = $spec['vtype'];
$kread = $vread = null;
if (isset(TBase::$tmethod[$ktype])) {
$kread = 'read'.TBase::$tmethod[$ktype];
} else {
$kspec = $spec['key'];
}
if (isset(TBase::$tmethod[$vtype])) {
$vread = 'read'.TBase::$tmethod[$vtype];
} else {
$vspec = $spec['val'];
}
$var = array();
$_ktype = $_vtype = $size = 0;
$xfer += $input->readMapBegin($_ktype, $_vtype, $size);
for ($i = 0; $i < $size; ++$i) {
$key = $val = null;
if ($kread !== null) {
$xfer += $input->$kread($key);
} else {
switch ($ktype) {
case TType::STRUCT:
$class = $kspec['class'];
$key = new $class();
$xfer += $key->read($input);
break;
case TType::MAP:
$xfer += $this->_readMap($key, $kspec, $input);
break;
case TType::LST:
$xfer += $this->_readList($key, $kspec, $input, false);
break;
case TType::SET:
$xfer += $this->_readList($key, $kspec, $input, true);
break;
}
}
if ($vread !== null) {
$xfer += $input->$vread($val);
} else {
switch ($vtype) {
case TType::STRUCT:
$class = $vspec['class'];
$val = new $class();
$xfer += $val->read($input);
break;
case TType::MAP:
$xfer += $this->_readMap($val, $vspec, $input);
break;
case TType::LST:
$xfer += $this->_readList($val, $vspec, $input, false);
break;
case TType::SET:
$xfer += $this->_readList($val, $vspec, $input, true);
break;
}
}
$var[$key] = $val;
}
$xfer += $input->readMapEnd();
return $xfer;
}
private function _readList(&$var, $spec, $input, $set=false) {
$xfer = 0;
$etype = $spec['etype'];
$eread = $vread = null;
if (isset(TBase::$tmethod[$etype])) {
$eread = 'read'.TBase::$tmethod[$etype];
} else {
$espec = $spec['elem'];
}
$var = array();
$_etype = $size = 0;
if ($set) {
$xfer += $input->readSetBegin($_etype, $size);
} else {
$xfer += $input->readListBegin($_etype, $size);
}
for ($i = 0; $i < $size; ++$i) {
$elem = null;
if ($eread !== null) {
$xfer += $input->$eread($elem);
} else {
$espec = $spec['elem'];
switch ($etype) {
case TType::STRUCT:
$class = $espec['class'];
$elem = new $class();
$xfer += $elem->read($input);
break;
case TType::MAP:
$xfer += $this->_readMap($elem, $espec, $input);
break;
case TType::LST:
$xfer += $this->_readList($elem, $espec, $input, false);
break;
case TType::SET:
$xfer += $this->_readList($elem, $espec, $input, true);
break;
}
}
if ($set) {
$var[$elem] = true;
} else {
$var []= $elem;
}
}
if ($set) {
$xfer += $input->readSetEnd();
} else {
$xfer += $input->readListEnd();
}
return $xfer;
}
protected function _read($class, $spec, $input) {
$xfer = 0;
$fname = null;
$ftype = 0;
$fid = 0;
$xfer += $input->readStructBegin($fname);
while (true) {
$xfer += $input->readFieldBegin($fname, $ftype, $fid);
if ($ftype == TType::STOP) {
break;
}
if (isset($spec[$fid])) {
$fspec = $spec[$fid];
$var = $fspec['var'];
if ($ftype == $fspec['type']) {
$xfer = 0;
if (isset(TBase::$tmethod[$ftype])) {
$func = 'read'.TBase::$tmethod[$ftype];
$xfer += $input->$func($this->$var);
} else {
switch ($ftype) {
case TType::STRUCT:
$class = $fspec['class'];
$this->$var = new $class();
$xfer += $this->$var->read($input);
break;
case TType::MAP:
$xfer += $this->_readMap($this->$var, $fspec, $input);
break;
case TType::LST:
$xfer += $this->_readList($this->$var, $fspec, $input, false);
break;
case TType::SET:
$xfer += $this->_readList($this->$var, $fspec, $input, true);
break;
}
}
} else {
$xfer += $input->skip($ftype);
}
} else {
$xfer += $input->skip($ftype);
}
$xfer += $input->readFieldEnd();
}
$xfer += $input->readStructEnd();
return $xfer;
}
private function _writeMap($var, $spec, $output) {
$xfer = 0;
$ktype = $spec['ktype'];
$vtype = $spec['vtype'];
$kwrite = $vwrite = null;
if (isset(TBase::$tmethod[$ktype])) {
$kwrite = 'write'.TBase::$tmethod[$ktype];
} else {
$kspec = $spec['key'];
}
if (isset(TBase::$tmethod[$vtype])) {
$vwrite = 'write'.TBase::$tmethod[$vtype];
} else {
$vspec = $spec['val'];
}
$xfer += $output->writeMapBegin($ktype, $vtype, count($var));
foreach ($var as $key => $val) {
if (isset($kwrite)) {
$xfer += $output->$kwrite($key);
} else {
switch ($ktype) {
case TType::STRUCT:
$xfer += $key->write($output);
break;
case TType::MAP:
$xfer += $this->_writeMap($key, $kspec, $output);
break;
case TType::LST:
$xfer += $this->_writeList($key, $kspec, $output, false);
break;
case TType::SET:
$xfer += $this->_writeList($key, $kspec, $output, true);
break;
}
}
if (isset($vwrite)) {
$xfer += $output->$vwrite($val);
} else {
switch ($vtype) {
case TType::STRUCT:
$xfer += $val->write($output);
break;
case TType::MAP:
$xfer += $this->_writeMap($val, $vspec, $output);
break;
case TType::LST:
$xfer += $this->_writeList($val, $vspec, $output, false);
break;
case TType::SET:
$xfer += $this->_writeList($val, $vspec, $output, true);
break;
}
}
}
$xfer += $output->writeMapEnd();
return $xfer;
}
private function _writeList($var, $spec, $output, $set=false) {
$xfer = 0;
$etype = $spec['etype'];
$ewrite = null;
if (isset(TBase::$tmethod[$etype])) {
$ewrite = 'write'.TBase::$tmethod[$etype];
} else {
$espec = $spec['elem'];
}
if ($set) {
$xfer += $output->writeSetBegin($etype, count($var));
} else {
$xfer += $output->writeListBegin($etype, count($var));
}
foreach ($var as $key => $val) {
$elem = $set ? $key : $val;
if (isset($ewrite)) {
$xfer += $output->$ewrite($elem);
} else {
switch ($etype) {
case TType::STRUCT:
$xfer += $elem->write($output);
break;
case TType::MAP:
$xfer += $this->_writeMap($elem, $espec, $output);
break;
case TType::LST:
$xfer += $this->_writeList($elem, $espec, $output, false);
break;
case TType::SET:
$xfer += $this->_writeList($elem, $espec, $output, true);
break;
}
}
}
if ($set) {
$xfer += $output->writeSetEnd();
} else {
$xfer += $output->writeListEnd();
}
return $xfer;
}
protected function _write($class, $spec, $output) {
$xfer = 0;
$xfer += $output->writeStructBegin($class);
foreach ($spec as $fid => $fspec) {
$var = $fspec['var'];
if ($this->$var !== null) {
$ftype = $fspec['type'];
$xfer += $output->writeFieldBegin($var, $ftype, $fid);
if (isset(TBase::$tmethod[$ftype])) {
$func = 'write'.TBase::$tmethod[$ftype];
$xfer += $output->$func($this->$var);
} else {
switch ($ftype) {
case TType::STRUCT:
$xfer += $this->$var->write($output);
break;
case TType::MAP:
$xfer += $this->_writeMap($this->$var, $fspec, $output);
break;
case TType::LST:
$xfer += $this->_writeList($this->$var, $fspec, $output, false);
break;
case TType::SET:
$xfer += $this->_writeList($this->$var, $fspec, $output, true);
break;
}
}
$xfer += $output->writeFieldEnd();
}
}
$xfer += $output->writeFieldStop();
$xfer += $output->writeStructEnd();
return $xfer;
}
}
class TApplicationException extends TException {
static $_TSPEC =
array(1 => array('var' => 'message',
'type' => TType::STRING),
2 => array('var' => 'code',
'type' => TType::I32));
const UNKNOWN = 0;
const UNKNOWN_METHOD = 1;
const INVALID_MESSAGE_TYPE = 2;
const WRONG_METHOD_NAME = 3;
const BAD_SEQUENCE_ID = 4;
const MISSING_RESULT = 5;
function __construct($message=null, $code=0) {
parent::__construct($message, $code);
}
public function read($output) {
return $this->_read('TApplicationException', self::$_TSPEC, $output);
}
public function write($output) {
$xfer = 0;
$xfer += $output->writeStructBegin('TApplicationException');
if ($message = $this->getMessage()) {
$xfer += $output->writeFieldBegin('message', TType::STRING, 1);
$xfer += $output->writeString($message);
$xfer += $output->writeFieldEnd();
}
if ($code = $this->getCode()) {
$xfer += $output->writeFieldBegin('type', TType::I32, 2);
$xfer += $output->writeI32($code);
$xfer += $output->writeFieldEnd();
}
$xfer += $output->writeFieldStop();
$xfer += $output->writeStructEnd();
return $xfer;
}
}
/**
* Set global THRIFT ROOT automatically via inclusion here
*/
if (!isset($GLOBALS['THRIFT_ROOT'])) {
$GLOBALS['THRIFT_ROOT'] = __DIR__;
}
include_once $GLOBALS['THRIFT_ROOT'].'/protocol/TProtocol.php';
include_once $GLOBALS['THRIFT_ROOT'].'/transport/TTransport.php';
?>
Horde_Thrift-2.0.2/lib/Horde/Thrift.php 0000664 0001750 0001750 00000000631 12453742644 015773 0 ustar jan jan