1: <?php
   2: /**
   3:  *  @generated
   4:  */
   5: 
   6: namespace cassandra;
   7: 
   8: class CassandraClient implements \cassandra\CassandraIf {
   9:   protected $input_ = null;
  10:   protected $output_ = null;
  11: 
  12:   protected $seqid_ = 0;
  13: 
  14:   public function __construct($input, $output=null) {
  15:     $this->input_ = $input;
  16:     $this->output_ = $output ? $output : $input;
  17:   }
  18: 
  19:   public function login($auth_request)
  20:   {
  21:     $this->send_login($auth_request);
  22:     $this->recv_login();
  23:   }
  24: 
  25:   public function send_login($auth_request)
  26:   {
  27:     $args = new \cassandra\Cassandra_login_args();
  28:     $args->auth_request = $auth_request;
  29:     $bin_accel = ($this->output_ instanceof \TProtocol::$TBINARYPROTOCOLACCELERATED) && function_exists('thrift_protocol_write_binary');
  30:     if ($bin_accel)
  31:     {
  32:       thrift_protocol_write_binary($this->output_, 'login', \TMessageType::CALL, $args, $this->seqid_, $this->output_->isStrictWrite());
  33:     }
  34:     else
  35:     {
  36:       $this->output_->writeMessageBegin('login', \TMessageType::CALL, $this->seqid_);
  37:       $args->write($this->output_);
  38:       $this->output_->writeMessageEnd();
  39:       $this->output_->getTransport()->flush();
  40:     }
  41:   }
  42: 
  43:   public function recv_login()
  44:   {
  45:     $bin_accel = ($this->input_ instanceof \TProtocol::$TBINARYPROTOCOLACCELERATED) && function_exists('thrift_protocol_read_binary');
  46:     if ($bin_accel) $result = thrift_protocol_read_binary($this->input_, '\cassandra\Cassandra_login_result', $this->input_->isStrictRead());
  47:     else
  48:     {
  49:       $rseqid = 0;
  50:       $fname = null;
  51:       $mtype = 0;
  52: 
  53:       $this->input_->readMessageBegin($fname, $mtype, $rseqid);
  54:       if ($mtype == \TMessageType::EXCEPTION) {
  55:         $x = new \TApplicationException();
  56:         $x->read($this->input_);
  57:         $this->input_->readMessageEnd();
  58:         throw $x;
  59:       }
  60:       $result = new \cassandra\Cassandra_login_result();
  61:       $result->read($this->input_);
  62:       $this->input_->readMessageEnd();
  63:     }
  64:     if ($result->authnx !== null) {
  65:       throw $result->authnx;
  66:     }
  67:     if ($result->authzx !== null) {
  68:       throw $result->authzx;
  69:     }
  70:     return;
  71:   }
  72: 
  73:   public function set_keyspace($keyspace)
  74:   {
  75:     $this->send_set_keyspace($keyspace);
  76:     $this->recv_set_keyspace();
  77:   }
  78: 
  79:   public function send_set_keyspace($keyspace)
  80:   {
  81:     $args = new \cassandra\Cassandra_set_keyspace_args();
  82:     $args->keyspace = $keyspace;
  83:     $bin_accel = ($this->output_ instanceof \TProtocol::$TBINARYPROTOCOLACCELERATED) && function_exists('thrift_protocol_write_binary');
  84:     if ($bin_accel)
  85:     {
  86:       thrift_protocol_write_binary($this->output_, 'set_keyspace', \TMessageType::CALL, $args, $this->seqid_, $this->output_->isStrictWrite());
  87:     }
  88:     else
  89:     {
  90:       $this->output_->writeMessageBegin('set_keyspace', \TMessageType::CALL, $this->seqid_);
  91:       $args->write($this->output_);
  92:       $this->output_->writeMessageEnd();
  93:       $this->output_->getTransport()->flush();
  94:     }
  95:   }
  96: 
  97:   public function recv_set_keyspace()
  98:   {
  99:     $bin_accel = ($this->input_ instanceof \TProtocol::$TBINARYPROTOCOLACCELERATED) && function_exists('thrift_protocol_read_binary');
 100:     if ($bin_accel) $result = thrift_protocol_read_binary($this->input_, '\cassandra\Cassandra_set_keyspace_result', $this->input_->isStrictRead());
 101:     else
 102:     {
 103:       $rseqid = 0;
 104:       $fname = null;
 105:       $mtype = 0;
 106: 
 107:       $this->input_->readMessageBegin($fname, $mtype, $rseqid);
 108:       if ($mtype == \TMessageType::EXCEPTION) {
 109:         $x = new \TApplicationException();
 110:         $x->read($this->input_);
 111:         $this->input_->readMessageEnd();
 112:         throw $x;
 113:       }
 114:       $result = new \cassandra\Cassandra_set_keyspace_result();
 115:       $result->read($this->input_);
 116:       $this->input_->readMessageEnd();
 117:     }
 118:     if ($result->ire !== null) {
 119:       throw $result->ire;
 120:     }
 121:     return;
 122:   }
 123: 
 124:   public function get($key, $column_path, $consistency_level)
 125:   {
 126:     $this->send_get($key, $column_path, $consistency_level);
 127:     return $this->recv_get();
 128:   }
 129: 
 130:   public function send_get($key, $column_path, $consistency_level)
 131:   {
 132:     $args = new \cassandra\Cassandra_get_args();
 133:     $args->key = $key;
 134:     $args->column_path = $column_path;
 135:     $args->consistency_level = $consistency_level;
 136:     $bin_accel = ($this->output_ instanceof \TProtocol::$TBINARYPROTOCOLACCELERATED) && function_exists('thrift_protocol_write_binary');
 137:     if ($bin_accel)
 138:     {
 139:       thrift_protocol_write_binary($this->output_, 'get', \TMessageType::CALL, $args, $this->seqid_, $this->output_->isStrictWrite());
 140:     }
 141:     else
 142:     {
 143:       $this->output_->writeMessageBegin('get', \TMessageType::CALL, $this->seqid_);
 144:       $args->write($this->output_);
 145:       $this->output_->writeMessageEnd();
 146:       $this->output_->getTransport()->flush();
 147:     }
 148:   }
 149: 
 150:   public function recv_get()
 151:   {
 152:     $bin_accel = ($this->input_ instanceof \TProtocol::$TBINARYPROTOCOLACCELERATED) && function_exists('thrift_protocol_read_binary');
 153:     if ($bin_accel) $result = thrift_protocol_read_binary($this->input_, '\cassandra\Cassandra_get_result', $this->input_->isStrictRead());
 154:     else
 155:     {
 156:       $rseqid = 0;
 157:       $fname = null;
 158:       $mtype = 0;
 159: 
 160:       $this->input_->readMessageBegin($fname, $mtype, $rseqid);
 161:       if ($mtype == \TMessageType::EXCEPTION) {
 162:         $x = new \TApplicationException();
 163:         $x->read($this->input_);
 164:         $this->input_->readMessageEnd();
 165:         throw $x;
 166:       }
 167:       $result = new \cassandra\Cassandra_get_result();
 168:       $result->read($this->input_);
 169:       $this->input_->readMessageEnd();
 170:     }
 171:     if ($result->success !== null) {
 172:       return $result->success;
 173:     }
 174:     if ($result->ire !== null) {
 175:       throw $result->ire;
 176:     }
 177:     if ($result->nfe !== null) {
 178:       throw $result->nfe;
 179:     }
 180:     if ($result->ue !== null) {
 181:       throw $result->ue;
 182:     }
 183:     if ($result->te !== null) {
 184:       throw $result->te;
 185:     }
 186:     throw new \Exception("get failed: unknown result");
 187:   }
 188: 
 189:   public function get_slice($key, $column_parent, $predicate, $consistency_level)
 190:   {
 191:     $this->send_get_slice($key, $column_parent, $predicate, $consistency_level);
 192:     return $this->recv_get_slice();
 193:   }
 194: 
 195:   public function send_get_slice($key, $column_parent, $predicate, $consistency_level)
 196:   {
 197:     $args = new \cassandra\Cassandra_get_slice_args();
 198:     $args->key = $key;
 199:     $args->column_parent = $column_parent;
 200:     $args->predicate = $predicate;
 201:     $args->consistency_level = $consistency_level;
 202:     $bin_accel = ($this->output_ instanceof \TProtocol::$TBINARYPROTOCOLACCELERATED) && function_exists('thrift_protocol_write_binary');
 203:     if ($bin_accel)
 204:     {
 205:       thrift_protocol_write_binary($this->output_, 'get_slice', \TMessageType::CALL, $args, $this->seqid_, $this->output_->isStrictWrite());
 206:     }
 207:     else
 208:     {
 209:       $this->output_->writeMessageBegin('get_slice', \TMessageType::CALL, $this->seqid_);
 210:       $args->write($this->output_);
 211:       $this->output_->writeMessageEnd();
 212:       $this->output_->getTransport()->flush();
 213:     }
 214:   }
 215: 
 216:   public function recv_get_slice()
 217:   {
 218:     $bin_accel = ($this->input_ instanceof \TProtocol::$TBINARYPROTOCOLACCELERATED) && function_exists('thrift_protocol_read_binary');
 219:     if ($bin_accel) $result = thrift_protocol_read_binary($this->input_, '\cassandra\Cassandra_get_slice_result', $this->input_->isStrictRead());
 220:     else
 221:     {
 222:       $rseqid = 0;
 223:       $fname = null;
 224:       $mtype = 0;
 225: 
 226:       $this->input_->readMessageBegin($fname, $mtype, $rseqid);
 227:       if ($mtype == \TMessageType::EXCEPTION) {
 228:         $x = new \TApplicationException();
 229:         $x->read($this->input_);
 230:         $this->input_->readMessageEnd();
 231:         throw $x;
 232:       }
 233:       $result = new \cassandra\Cassandra_get_slice_result();
 234:       $result->read($this->input_);
 235:       $this->input_->readMessageEnd();
 236:     }
 237:     if ($result->success !== null) {
 238:       return $result->success;
 239:     }
 240:     if ($result->ire !== null) {
 241:       throw $result->ire;
 242:     }
 243:     if ($result->ue !== null) {
 244:       throw $result->ue;
 245:     }
 246:     if ($result->te !== null) {
 247:       throw $result->te;
 248:     }
 249:     throw new \Exception("get_slice failed: unknown result");
 250:   }
 251: 
 252:   public function get_count($key, $column_parent, $predicate, $consistency_level)
 253:   {
 254:     $this->send_get_count($key, $column_parent, $predicate, $consistency_level);
 255:     return $this->recv_get_count();
 256:   }
 257: 
 258:   public function send_get_count($key, $column_parent, $predicate, $consistency_level)
 259:   {
 260:     $args = new \cassandra\Cassandra_get_count_args();
 261:     $args->key = $key;
 262:     $args->column_parent = $column_parent;
 263:     $args->predicate = $predicate;
 264:     $args->consistency_level = $consistency_level;
 265:     $bin_accel = ($this->output_ instanceof \TProtocol::$TBINARYPROTOCOLACCELERATED) && function_exists('thrift_protocol_write_binary');
 266:     if ($bin_accel)
 267:     {
 268:       thrift_protocol_write_binary($this->output_, 'get_count', \TMessageType::CALL, $args, $this->seqid_, $this->output_->isStrictWrite());
 269:     }
 270:     else
 271:     {
 272:       $this->output_->writeMessageBegin('get_count', \TMessageType::CALL, $this->seqid_);
 273:       $args->write($this->output_);
 274:       $this->output_->writeMessageEnd();
 275:       $this->output_->getTransport()->flush();
 276:     }
 277:   }
 278: 
 279:   public function recv_get_count()
 280:   {
 281:     $bin_accel = ($this->input_ instanceof \TProtocol::$TBINARYPROTOCOLACCELERATED) && function_exists('thrift_protocol_read_binary');
 282:     if ($bin_accel) $result = thrift_protocol_read_binary($this->input_, '\cassandra\Cassandra_get_count_result', $this->input_->isStrictRead());
 283:     else
 284:     {
 285:       $rseqid = 0;
 286:       $fname = null;
 287:       $mtype = 0;
 288: 
 289:       $this->input_->readMessageBegin($fname, $mtype, $rseqid);
 290:       if ($mtype == \TMessageType::EXCEPTION) {
 291:         $x = new \TApplicationException();
 292:         $x->read($this->input_);
 293:         $this->input_->readMessageEnd();
 294:         throw $x;
 295:       }
 296:       $result = new \cassandra\Cassandra_get_count_result();
 297:       $result->read($this->input_);
 298:       $this->input_->readMessageEnd();
 299:     }
 300:     if ($result->success !== null) {
 301:       return $result->success;
 302:     }
 303:     if ($result->ire !== null) {
 304:       throw $result->ire;
 305:     }
 306:     if ($result->ue !== null) {
 307:       throw $result->ue;
 308:     }
 309:     if ($result->te !== null) {
 310:       throw $result->te;
 311:     }
 312:     throw new \Exception("get_count failed: unknown result");
 313:   }
 314: 
 315:   public function multiget_slice($keys, $column_parent, $predicate, $consistency_level)
 316:   {
 317:     $this->send_multiget_slice($keys, $column_parent, $predicate, $consistency_level);
 318:     return $this->recv_multiget_slice();
 319:   }
 320: 
 321:   public function send_multiget_slice($keys, $column_parent, $predicate, $consistency_level)
 322:   {
 323:     $args = new \cassandra\Cassandra_multiget_slice_args();
 324:     $args->keys = $keys;
 325:     $args->column_parent = $column_parent;
 326:     $args->predicate = $predicate;
 327:     $args->consistency_level = $consistency_level;
 328:     $bin_accel = ($this->output_ instanceof \TProtocol::$TBINARYPROTOCOLACCELERATED) && function_exists('thrift_protocol_write_binary');
 329:     if ($bin_accel)
 330:     {
 331:       thrift_protocol_write_binary($this->output_, 'multiget_slice', \TMessageType::CALL, $args, $this->seqid_, $this->output_->isStrictWrite());
 332:     }
 333:     else
 334:     {
 335:       $this->output_->writeMessageBegin('multiget_slice', \TMessageType::CALL, $this->seqid_);
 336:       $args->write($this->output_);
 337:       $this->output_->writeMessageEnd();
 338:       $this->output_->getTransport()->flush();
 339:     }
 340:   }
 341: 
 342:   public function recv_multiget_slice()
 343:   {
 344:     $bin_accel = ($this->input_ instanceof \TProtocol::$TBINARYPROTOCOLACCELERATED) && function_exists('thrift_protocol_read_binary');
 345:     if ($bin_accel) $result = thrift_protocol_read_binary($this->input_, '\cassandra\Cassandra_multiget_slice_result', $this->input_->isStrictRead());
 346:     else
 347:     {
 348:       $rseqid = 0;
 349:       $fname = null;
 350:       $mtype = 0;
 351: 
 352:       $this->input_->readMessageBegin($fname, $mtype, $rseqid);
 353:       if ($mtype == \TMessageType::EXCEPTION) {
 354:         $x = new \TApplicationException();
 355:         $x->read($this->input_);
 356:         $this->input_->readMessageEnd();
 357:         throw $x;
 358:       }
 359:       $result = new \cassandra\Cassandra_multiget_slice_result();
 360:       $result->read($this->input_);
 361:       $this->input_->readMessageEnd();
 362:     }
 363:     if ($result->success !== null) {
 364:       return $result->success;
 365:     }
 366:     if ($result->ire !== null) {
 367:       throw $result->ire;
 368:     }
 369:     if ($result->ue !== null) {
 370:       throw $result->ue;
 371:     }
 372:     if ($result->te !== null) {
 373:       throw $result->te;
 374:     }
 375:     throw new \Exception("multiget_slice failed: unknown result");
 376:   }
 377: 
 378:   public function multiget_count($keys, $column_parent, $predicate, $consistency_level)
 379:   {
 380:     $this->send_multiget_count($keys, $column_parent, $predicate, $consistency_level);
 381:     return $this->recv_multiget_count();
 382:   }
 383: 
 384:   public function send_multiget_count($keys, $column_parent, $predicate, $consistency_level)
 385:   {
 386:     $args = new \cassandra\Cassandra_multiget_count_args();
 387:     $args->keys = $keys;
 388:     $args->column_parent = $column_parent;
 389:     $args->predicate = $predicate;
 390:     $args->consistency_level = $consistency_level;
 391:     $bin_accel = ($this->output_ instanceof \TProtocol::$TBINARYPROTOCOLACCELERATED) && function_exists('thrift_protocol_write_binary');
 392:     if ($bin_accel)
 393:     {
 394:       thrift_protocol_write_binary($this->output_, 'multiget_count', \TMessageType::CALL, $args, $this->seqid_, $this->output_->isStrictWrite());
 395:     }
 396:     else
 397:     {
 398:       $this->output_->writeMessageBegin('multiget_count', \TMessageType::CALL, $this->seqid_);
 399:       $args->write($this->output_);
 400:       $this->output_->writeMessageEnd();
 401:       $this->output_->getTransport()->flush();
 402:     }
 403:   }
 404: 
 405:   public function recv_multiget_count()
 406:   {
 407:     $bin_accel = ($this->input_ instanceof \TProtocol::$TBINARYPROTOCOLACCELERATED) && function_exists('thrift_protocol_read_binary');
 408:     if ($bin_accel) $result = thrift_protocol_read_binary($this->input_, '\cassandra\Cassandra_multiget_count_result', $this->input_->isStrictRead());
 409:     else
 410:     {
 411:       $rseqid = 0;
 412:       $fname = null;
 413:       $mtype = 0;
 414: 
 415:       $this->input_->readMessageBegin($fname, $mtype, $rseqid);
 416:       if ($mtype == \TMessageType::EXCEPTION) {
 417:         $x = new \TApplicationException();
 418:         $x->read($this->input_);
 419:         $this->input_->readMessageEnd();
 420:         throw $x;
 421:       }
 422:       $result = new \cassandra\Cassandra_multiget_count_result();
 423:       $result->read($this->input_);
 424:       $this->input_->readMessageEnd();
 425:     }
 426:     if ($result->success !== null) {
 427:       return $result->success;
 428:     }
 429:     if ($result->ire !== null) {
 430:       throw $result->ire;
 431:     }
 432:     if ($result->ue !== null) {
 433:       throw $result->ue;
 434:     }
 435:     if ($result->te !== null) {
 436:       throw $result->te;
 437:     }
 438:     throw new \Exception("multiget_count failed: unknown result");
 439:   }
 440: 
 441:   public function get_range_slices($column_parent, $predicate, $range, $consistency_level)
 442:   {
 443:     $this->send_get_range_slices($column_parent, $predicate, $range, $consistency_level);
 444:     return $this->recv_get_range_slices();
 445:   }
 446: 
 447:   public function send_get_range_slices($column_parent, $predicate, $range, $consistency_level)
 448:   {
 449:     $args = new \cassandra\Cassandra_get_range_slices_args();
 450:     $args->column_parent = $column_parent;
 451:     $args->predicate = $predicate;
 452:     $args->range = $range;
 453:     $args->consistency_level = $consistency_level;
 454:     $bin_accel = ($this->output_ instanceof \TProtocol::$TBINARYPROTOCOLACCELERATED) && function_exists('thrift_protocol_write_binary');
 455:     if ($bin_accel)
 456:     {
 457:       thrift_protocol_write_binary($this->output_, 'get_range_slices', \TMessageType::CALL, $args, $this->seqid_, $this->output_->isStrictWrite());
 458:     }
 459:     else
 460:     {
 461:       $this->output_->writeMessageBegin('get_range_slices', \TMessageType::CALL, $this->seqid_);
 462:       $args->write($this->output_);
 463:       $this->output_->writeMessageEnd();
 464:       $this->output_->getTransport()->flush();
 465:     }
 466:   }
 467: 
 468:   public function recv_get_range_slices()
 469:   {
 470:     $bin_accel = ($this->input_ instanceof \TProtocol::$TBINARYPROTOCOLACCELERATED) && function_exists('thrift_protocol_read_binary');
 471:     if ($bin_accel) $result = thrift_protocol_read_binary($this->input_, '\cassandra\Cassandra_get_range_slices_result', $this->input_->isStrictRead());
 472:     else
 473:     {
 474:       $rseqid = 0;
 475:       $fname = null;
 476:       $mtype = 0;
 477: 
 478:       $this->input_->readMessageBegin($fname, $mtype, $rseqid);
 479:       if ($mtype == \TMessageType::EXCEPTION) {
 480:         $x = new \TApplicationException();
 481:         $x->read($this->input_);
 482:         $this->input_->readMessageEnd();
 483:         throw $x;
 484:       }
 485:       $result = new \cassandra\Cassandra_get_range_slices_result();
 486:       $result->read($this->input_);
 487:       $this->input_->readMessageEnd();
 488:     }
 489:     if ($result->success !== null) {
 490:       return $result->success;
 491:     }
 492:     if ($result->ire !== null) {
 493:       throw $result->ire;
 494:     }
 495:     if ($result->ue !== null) {
 496:       throw $result->ue;
 497:     }
 498:     if ($result->te !== null) {
 499:       throw $result->te;
 500:     }
 501:     throw new \Exception("get_range_slices failed: unknown result");
 502:   }
 503: 
 504:   public function get_paged_slice($column_family, $range, $start_column, $consistency_level)
 505:   {
 506:     $this->send_get_paged_slice($column_family, $range, $start_column, $consistency_level);
 507:     return $this->recv_get_paged_slice();
 508:   }
 509: 
 510:   public function send_get_paged_slice($column_family, $range, $start_column, $consistency_level)
 511:   {
 512:     $args = new \cassandra\Cassandra_get_paged_slice_args();
 513:     $args->column_family = $column_family;
 514:     $args->range = $range;
 515:     $args->start_column = $start_column;
 516:     $args->consistency_level = $consistency_level;
 517:     $bin_accel = ($this->output_ instanceof \TProtocol::$TBINARYPROTOCOLACCELERATED) && function_exists('thrift_protocol_write_binary');
 518:     if ($bin_accel)
 519:     {
 520:       thrift_protocol_write_binary($this->output_, 'get_paged_slice', \TMessageType::CALL, $args, $this->seqid_, $this->output_->isStrictWrite());
 521:     }
 522:     else
 523:     {
 524:       $this->output_->writeMessageBegin('get_paged_slice', \TMessageType::CALL, $this->seqid_);
 525:       $args->write($this->output_);
 526:       $this->output_->writeMessageEnd();
 527:       $this->output_->getTransport()->flush();
 528:     }
 529:   }
 530: 
 531:   public function recv_get_paged_slice()
 532:   {
 533:     $bin_accel = ($this->input_ instanceof \TProtocol::$TBINARYPROTOCOLACCELERATED) && function_exists('thrift_protocol_read_binary');
 534:     if ($bin_accel) $result = thrift_protocol_read_binary($this->input_, '\cassandra\Cassandra_get_paged_slice_result', $this->input_->isStrictRead());
 535:     else
 536:     {
 537:       $rseqid = 0;
 538:       $fname = null;
 539:       $mtype = 0;
 540: 
 541:       $this->input_->readMessageBegin($fname, $mtype, $rseqid);
 542:       if ($mtype == \TMessageType::EXCEPTION) {
 543:         $x = new \TApplicationException();
 544:         $x->read($this->input_);
 545:         $this->input_->readMessageEnd();
 546:         throw $x;
 547:       }
 548:       $result = new \cassandra\Cassandra_get_paged_slice_result();
 549:       $result->read($this->input_);
 550:       $this->input_->readMessageEnd();
 551:     }
 552:     if ($result->success !== null) {
 553:       return $result->success;
 554:     }
 555:     if ($result->ire !== null) {
 556:       throw $result->ire;
 557:     }
 558:     if ($result->ue !== null) {
 559:       throw $result->ue;
 560:     }
 561:     if ($result->te !== null) {
 562:       throw $result->te;
 563:     }
 564:     throw new \Exception("get_paged_slice failed: unknown result");
 565:   }
 566: 
 567:   public function get_indexed_slices($column_parent, $index_clause, $column_predicate, $consistency_level)
 568:   {
 569:     $this->send_get_indexed_slices($column_parent, $index_clause, $column_predicate, $consistency_level);
 570:     return $this->recv_get_indexed_slices();
 571:   }
 572: 
 573:   public function send_get_indexed_slices($column_parent, $index_clause, $column_predicate, $consistency_level)
 574:   {
 575:     $args = new \cassandra\Cassandra_get_indexed_slices_args();
 576:     $args->column_parent = $column_parent;
 577:     $args->index_clause = $index_clause;
 578:     $args->column_predicate = $column_predicate;
 579:     $args->consistency_level = $consistency_level;
 580:     $bin_accel = ($this->output_ instanceof \TProtocol::$TBINARYPROTOCOLACCELERATED) && function_exists('thrift_protocol_write_binary');
 581:     if ($bin_accel)
 582:     {
 583:       thrift_protocol_write_binary($this->output_, 'get_indexed_slices', \TMessageType::CALL, $args, $this->seqid_, $this->output_->isStrictWrite());
 584:     }
 585:     else
 586:     {
 587:       $this->output_->writeMessageBegin('get_indexed_slices', \TMessageType::CALL, $this->seqid_);
 588:       $args->write($this->output_);
 589:       $this->output_->writeMessageEnd();
 590:       $this->output_->getTransport()->flush();
 591:     }
 592:   }
 593: 
 594:   public function recv_get_indexed_slices()
 595:   {
 596:     $bin_accel = ($this->input_ instanceof \TProtocol::$TBINARYPROTOCOLACCELERATED) && function_exists('thrift_protocol_read_binary');
 597:     if ($bin_accel) $result = thrift_protocol_read_binary($this->input_, '\cassandra\Cassandra_get_indexed_slices_result', $this->input_->isStrictRead());
 598:     else
 599:     {
 600:       $rseqid = 0;
 601:       $fname = null;
 602:       $mtype = 0;
 603: 
 604:       $this->input_->readMessageBegin($fname, $mtype, $rseqid);
 605:       if ($mtype == \TMessageType::EXCEPTION) {
 606:         $x = new \TApplicationException();
 607:         $x->read($this->input_);
 608:         $this->input_->readMessageEnd();
 609:         throw $x;
 610:       }
 611:       $result = new \cassandra\Cassandra_get_indexed_slices_result();
 612:       $result->read($this->input_);
 613:       $this->input_->readMessageEnd();
 614:     }
 615:     if ($result->success !== null) {
 616:       return $result->success;
 617:     }
 618:     if ($result->ire !== null) {
 619:       throw $result->ire;
 620:     }
 621:     if ($result->ue !== null) {
 622:       throw $result->ue;
 623:     }
 624:     if ($result->te !== null) {
 625:       throw $result->te;
 626:     }
 627:     throw new \Exception("get_indexed_slices failed: unknown result");
 628:   }
 629: 
 630:   public function insert($key, $column_parent, $column, $consistency_level)
 631:   {
 632:     $this->send_insert($key, $column_parent, $column, $consistency_level);
 633:     $this->recv_insert();
 634:   }
 635: 
 636:   public function send_insert($key, $column_parent, $column, $consistency_level)
 637:   {
 638:     $args = new \cassandra\Cassandra_insert_args();
 639:     $args->key = $key;
 640:     $args->column_parent = $column_parent;
 641:     $args->column = $column;
 642:     $args->consistency_level = $consistency_level;
 643:     $bin_accel = ($this->output_ instanceof \TProtocol::$TBINARYPROTOCOLACCELERATED) && function_exists('thrift_protocol_write_binary');
 644:     if ($bin_accel)
 645:     {
 646:       thrift_protocol_write_binary($this->output_, 'insert', \TMessageType::CALL, $args, $this->seqid_, $this->output_->isStrictWrite());
 647:     }
 648:     else
 649:     {
 650:       $this->output_->writeMessageBegin('insert', \TMessageType::CALL, $this->seqid_);
 651:       $args->write($this->output_);
 652:       $this->output_->writeMessageEnd();
 653:       $this->output_->getTransport()->flush();
 654:     }
 655:   }
 656: 
 657:   public function recv_insert()
 658:   {
 659:     $bin_accel = ($this->input_ instanceof \TProtocol::$TBINARYPROTOCOLACCELERATED) && function_exists('thrift_protocol_read_binary');
 660:     if ($bin_accel) $result = thrift_protocol_read_binary($this->input_, '\cassandra\Cassandra_insert_result', $this->input_->isStrictRead());
 661:     else
 662:     {
 663:       $rseqid = 0;
 664:       $fname = null;
 665:       $mtype = 0;
 666: 
 667:       $this->input_->readMessageBegin($fname, $mtype, $rseqid);
 668:       if ($mtype == \TMessageType::EXCEPTION) {
 669:         $x = new \TApplicationException();
 670:         $x->read($this->input_);
 671:         $this->input_->readMessageEnd();
 672:         throw $x;
 673:       }
 674:       $result = new \cassandra\Cassandra_insert_result();
 675:       $result->read($this->input_);
 676:       $this->input_->readMessageEnd();
 677:     }
 678:     if ($result->ire !== null) {
 679:       throw $result->ire;
 680:     }
 681:     if ($result->ue !== null) {
 682:       throw $result->ue;
 683:     }
 684:     if ($result->te !== null) {
 685:       throw $result->te;
 686:     }
 687:     return;
 688:   }
 689: 
 690:   public function add($key, $column_parent, $column, $consistency_level)
 691:   {
 692:     $this->send_add($key, $column_parent, $column, $consistency_level);
 693:     $this->recv_add();
 694:   }
 695: 
 696:   public function send_add($key, $column_parent, $column, $consistency_level)
 697:   {
 698:     $args = new \cassandra\Cassandra_add_args();
 699:     $args->key = $key;
 700:     $args->column_parent = $column_parent;
 701:     $args->column = $column;
 702:     $args->consistency_level = $consistency_level;
 703:     $bin_accel = ($this->output_ instanceof \TProtocol::$TBINARYPROTOCOLACCELERATED) && function_exists('thrift_protocol_write_binary');
 704:     if ($bin_accel)
 705:     {
 706:       thrift_protocol_write_binary($this->output_, 'add', \TMessageType::CALL, $args, $this->seqid_, $this->output_->isStrictWrite());
 707:     }
 708:     else
 709:     {
 710:       $this->output_->writeMessageBegin('add', \TMessageType::CALL, $this->seqid_);
 711:       $args->write($this->output_);
 712:       $this->output_->writeMessageEnd();
 713:       $this->output_->getTransport()->flush();
 714:     }
 715:   }
 716: 
 717:   public function recv_add()
 718:   {
 719:     $bin_accel = ($this->input_ instanceof \TProtocol::$TBINARYPROTOCOLACCELERATED) && function_exists('thrift_protocol_read_binary');
 720:     if ($bin_accel) $result = thrift_protocol_read_binary($this->input_, '\cassandra\Cassandra_add_result', $this->input_->isStrictRead());
 721:     else
 722:     {
 723:       $rseqid = 0;
 724:       $fname = null;
 725:       $mtype = 0;
 726: 
 727:       $this->input_->readMessageBegin($fname, $mtype, $rseqid);
 728:       if ($mtype == \TMessageType::EXCEPTION) {
 729:         $x = new \TApplicationException();
 730:         $x->read($this->input_);
 731:         $this->input_->readMessageEnd();
 732:         throw $x;
 733:       }
 734:       $result = new \cassandra\Cassandra_add_result();
 735:       $result->read($this->input_);
 736:       $this->input_->readMessageEnd();
 737:     }
 738:     if ($result->ire !== null) {
 739:       throw $result->ire;
 740:     }
 741:     if ($result->ue !== null) {
 742:       throw $result->ue;
 743:     }
 744:     if ($result->te !== null) {
 745:       throw $result->te;
 746:     }
 747:     return;
 748:   }
 749: 
 750:   public function remove($key, $column_path, $timestamp, $consistency_level)
 751:   {
 752:     $this->send_remove($key, $column_path, $timestamp, $consistency_level);
 753:     $this->recv_remove();
 754:   }
 755: 
 756:   public function send_remove($key, $column_path, $timestamp, $consistency_level)
 757:   {
 758:     $args = new \cassandra\Cassandra_remove_args();
 759:     $args->key = $key;
 760:     $args->column_path = $column_path;
 761:     $args->timestamp = $timestamp;
 762:     $args->consistency_level = $consistency_level;
 763:     $bin_accel = ($this->output_ instanceof \TProtocol::$TBINARYPROTOCOLACCELERATED) && function_exists('thrift_protocol_write_binary');
 764:     if ($bin_accel)
 765:     {
 766:       thrift_protocol_write_binary($this->output_, 'remove', \TMessageType::CALL, $args, $this->seqid_, $this->output_->isStrictWrite());
 767:     }
 768:     else
 769:     {
 770:       $this->output_->writeMessageBegin('remove', \TMessageType::CALL, $this->seqid_);
 771:       $args->write($this->output_);
 772:       $this->output_->writeMessageEnd();
 773:       $this->output_->getTransport()->flush();
 774:     }
 775:   }
 776: 
 777:   public function recv_remove()
 778:   {
 779:     $bin_accel = ($this->input_ instanceof \TProtocol::$TBINARYPROTOCOLACCELERATED) && function_exists('thrift_protocol_read_binary');
 780:     if ($bin_accel) $result = thrift_protocol_read_binary($this->input_, '\cassandra\Cassandra_remove_result', $this->input_->isStrictRead());
 781:     else
 782:     {
 783:       $rseqid = 0;
 784:       $fname = null;
 785:       $mtype = 0;
 786: 
 787:       $this->input_->readMessageBegin($fname, $mtype, $rseqid);
 788:       if ($mtype == \TMessageType::EXCEPTION) {
 789:         $x = new \TApplicationException();
 790:         $x->read($this->input_);
 791:         $this->input_->readMessageEnd();
 792:         throw $x;
 793:       }
 794:       $result = new \cassandra\Cassandra_remove_result();
 795:       $result->read($this->input_);
 796:       $this->input_->readMessageEnd();
 797:     }
 798:     if ($result->ire !== null) {
 799:       throw $result->ire;
 800:     }
 801:     if ($result->ue !== null) {
 802:       throw $result->ue;
 803:     }
 804:     if ($result->te !== null) {
 805:       throw $result->te;
 806:     }
 807:     return;
 808:   }
 809: 
 810:   public function remove_counter($key, $path, $consistency_level)
 811:   {
 812:     $this->send_remove_counter($key, $path, $consistency_level);
 813:     $this->recv_remove_counter();
 814:   }
 815: 
 816:   public function send_remove_counter($key, $path, $consistency_level)
 817:   {
 818:     $args = new \cassandra\Cassandra_remove_counter_args();
 819:     $args->key = $key;
 820:     $args->path = $path;
 821:     $args->consistency_level = $consistency_level;
 822:     $bin_accel = ($this->output_ instanceof \TProtocol::$TBINARYPROTOCOLACCELERATED) && function_exists('thrift_protocol_write_binary');
 823:     if ($bin_accel)
 824:     {
 825:       thrift_protocol_write_binary($this->output_, 'remove_counter', \TMessageType::CALL, $args, $this->seqid_, $this->output_->isStrictWrite());
 826:     }
 827:     else
 828:     {
 829:       $this->output_->writeMessageBegin('remove_counter', \TMessageType::CALL, $this->seqid_);
 830:       $args->write($this->output_);
 831:       $this->output_->writeMessageEnd();
 832:       $this->output_->getTransport()->flush();
 833:     }
 834:   }
 835: 
 836:   public function recv_remove_counter()
 837:   {
 838:     $bin_accel = ($this->input_ instanceof \TProtocol::$TBINARYPROTOCOLACCELERATED) && function_exists('thrift_protocol_read_binary');
 839:     if ($bin_accel) $result = thrift_protocol_read_binary($this->input_, '\cassandra\Cassandra_remove_counter_result', $this->input_->isStrictRead());
 840:     else
 841:     {
 842:       $rseqid = 0;
 843:       $fname = null;
 844:       $mtype = 0;
 845: 
 846:       $this->input_->readMessageBegin($fname, $mtype, $rseqid);
 847:       if ($mtype == \TMessageType::EXCEPTION) {
 848:         $x = new \TApplicationException();
 849:         $x->read($this->input_);
 850:         $this->input_->readMessageEnd();
 851:         throw $x;
 852:       }
 853:       $result = new \cassandra\Cassandra_remove_counter_result();
 854:       $result->read($this->input_);
 855:       $this->input_->readMessageEnd();
 856:     }
 857:     if ($result->ire !== null) {
 858:       throw $result->ire;
 859:     }
 860:     if ($result->ue !== null) {
 861:       throw $result->ue;
 862:     }
 863:     if ($result->te !== null) {
 864:       throw $result->te;
 865:     }
 866:     return;
 867:   }
 868: 
 869:   public function batch_mutate($mutation_map, $consistency_level)
 870:   {
 871:     $this->send_batch_mutate($mutation_map, $consistency_level);
 872:     $this->recv_batch_mutate();
 873:   }
 874: 
 875:   public function send_batch_mutate($mutation_map, $consistency_level)
 876:   {
 877:     $args = new \cassandra\Cassandra_batch_mutate_args();
 878:     $args->mutation_map = $mutation_map;
 879:     $args->consistency_level = $consistency_level;
 880:     $bin_accel = ($this->output_ instanceof \TProtocol::$TBINARYPROTOCOLACCELERATED) && function_exists('thrift_protocol_write_binary');
 881:     if ($bin_accel)
 882:     {
 883:       thrift_protocol_write_binary($this->output_, 'batch_mutate', \TMessageType::CALL, $args, $this->seqid_, $this->output_->isStrictWrite());
 884:     }
 885:     else
 886:     {
 887:       $this->output_->writeMessageBegin('batch_mutate', \TMessageType::CALL, $this->seqid_);
 888:       $args->write($this->output_);
 889:       $this->output_->writeMessageEnd();
 890:       $this->output_->getTransport()->flush();
 891:     }
 892:   }
 893: 
 894:   public function recv_batch_mutate()
 895:   {
 896:     $bin_accel = ($this->input_ instanceof \TProtocol::$TBINARYPROTOCOLACCELERATED) && function_exists('thrift_protocol_read_binary');
 897:     if ($bin_accel) $result = thrift_protocol_read_binary($this->input_, '\cassandra\Cassandra_batch_mutate_result', $this->input_->isStrictRead());
 898:     else
 899:     {
 900:       $rseqid = 0;
 901:       $fname = null;
 902:       $mtype = 0;
 903: 
 904:       $this->input_->readMessageBegin($fname, $mtype, $rseqid);
 905:       if ($mtype == \TMessageType::EXCEPTION) {
 906:         $x = new \TApplicationException();
 907:         $x->read($this->input_);
 908:         $this->input_->readMessageEnd();
 909:         throw $x;
 910:       }
 911:       $result = new \cassandra\Cassandra_batch_mutate_result();
 912:       $result->read($this->input_);
 913:       $this->input_->readMessageEnd();
 914:     }
 915:     if ($result->ire !== null) {
 916:       throw $result->ire;
 917:     }
 918:     if ($result->ue !== null) {
 919:       throw $result->ue;
 920:     }
 921:     if ($result->te !== null) {
 922:       throw $result->te;
 923:     }
 924:     return;
 925:   }
 926: 
 927:   public function truncate($cfname)
 928:   {
 929:     $this->send_truncate($cfname);
 930:     $this->recv_truncate();
 931:   }
 932: 
 933:   public function send_truncate($cfname)
 934:   {
 935:     $args = new \cassandra\Cassandra_truncate_args();
 936:     $args->cfname = $cfname;
 937:     $bin_accel = ($this->output_ instanceof \TProtocol::$TBINARYPROTOCOLACCELERATED) && function_exists('thrift_protocol_write_binary');
 938:     if ($bin_accel)
 939:     {
 940:       thrift_protocol_write_binary($this->output_, 'truncate', \TMessageType::CALL, $args, $this->seqid_, $this->output_->isStrictWrite());
 941:     }
 942:     else
 943:     {
 944:       $this->output_->writeMessageBegin('truncate', \TMessageType::CALL, $this->seqid_);
 945:       $args->write($this->output_);
 946:       $this->output_->writeMessageEnd();
 947:       $this->output_->getTransport()->flush();
 948:     }
 949:   }
 950: 
 951:   public function recv_truncate()
 952:   {
 953:     $bin_accel = ($this->input_ instanceof \TProtocol::$TBINARYPROTOCOLACCELERATED) && function_exists('thrift_protocol_read_binary');
 954:     if ($bin_accel) $result = thrift_protocol_read_binary($this->input_, '\cassandra\Cassandra_truncate_result', $this->input_->isStrictRead());
 955:     else
 956:     {
 957:       $rseqid = 0;
 958:       $fname = null;
 959:       $mtype = 0;
 960: 
 961:       $this->input_->readMessageBegin($fname, $mtype, $rseqid);
 962:       if ($mtype == \TMessageType::EXCEPTION) {
 963:         $x = new \TApplicationException();
 964:         $x->read($this->input_);
 965:         $this->input_->readMessageEnd();
 966:         throw $x;
 967:       }
 968:       $result = new \cassandra\Cassandra_truncate_result();
 969:       $result->read($this->input_);
 970:       $this->input_->readMessageEnd();
 971:     }
 972:     if ($result->ire !== null) {
 973:       throw $result->ire;
 974:     }
 975:     if ($result->ue !== null) {
 976:       throw $result->ue;
 977:     }
 978:     if ($result->te !== null) {
 979:       throw $result->te;
 980:     }
 981:     return;
 982:   }
 983: 
 984:   public function describe_schema_versions()
 985:   {
 986:     $this->send_describe_schema_versions();
 987:     return $this->recv_describe_schema_versions();
 988:   }
 989: 
 990:   public function send_describe_schema_versions()
 991:   {
 992:     $args = new \cassandra\Cassandra_describe_schema_versions_args();
 993:     $bin_accel = ($this->output_ instanceof \TProtocol::$TBINARYPROTOCOLACCELERATED) && function_exists('thrift_protocol_write_binary');
 994:     if ($bin_accel)
 995:     {
 996:       thrift_protocol_write_binary($this->output_, 'describe_schema_versions', \TMessageType::CALL, $args, $this->seqid_, $this->output_->isStrictWrite());
 997:     }
 998:     else
 999:     {
1000:       $this->output_->writeMessageBegin('describe_schema_versions', \TMessageType::CALL, $this->seqid_);
1001:       $args->write($this->output_);
1002:       $this->output_->writeMessageEnd();
1003:       $this->output_->getTransport()->flush();
1004:     }
1005:   }
1006: 
1007:   public function recv_describe_schema_versions()
1008:   {
1009:     $bin_accel = ($this->input_ instanceof \TProtocol::$TBINARYPROTOCOLACCELERATED) && function_exists('thrift_protocol_read_binary');
1010:     if ($bin_accel) $result = thrift_protocol_read_binary($this->input_, '\cassandra\Cassandra_describe_schema_versions_result', $this->input_->isStrictRead());
1011:     else
1012:     {
1013:       $rseqid = 0;
1014:       $fname = null;
1015:       $mtype = 0;
1016: 
1017:       $this->input_->readMessageBegin($fname, $mtype, $rseqid);
1018:       if ($mtype == \TMessageType::EXCEPTION) {
1019:         $x = new \TApplicationException();
1020:         $x->read($this->input_);
1021:         $this->input_->readMessageEnd();
1022:         throw $x;
1023:       }
1024:       $result = new \cassandra\Cassandra_describe_schema_versions_result();
1025:       $result->read($this->input_);
1026:       $this->input_->readMessageEnd();
1027:     }
1028:     if ($result->success !== null) {
1029:       return $result->success;
1030:     }
1031:     if ($result->ire !== null) {
1032:       throw $result->ire;
1033:     }
1034:     throw new \Exception("describe_schema_versions failed: unknown result");
1035:   }
1036: 
1037:   public function describe_keyspaces()
1038:   {
1039:     $this->send_describe_keyspaces();
1040:     return $this->recv_describe_keyspaces();
1041:   }
1042: 
1043:   public function send_describe_keyspaces()
1044:   {
1045:     $args = new \cassandra\Cassandra_describe_keyspaces_args();
1046:     $bin_accel = ($this->output_ instanceof \TProtocol::$TBINARYPROTOCOLACCELERATED) && function_exists('thrift_protocol_write_binary');
1047:     if ($bin_accel)
1048:     {
1049:       thrift_protocol_write_binary($this->output_, 'describe_keyspaces', \TMessageType::CALL, $args, $this->seqid_, $this->output_->isStrictWrite());
1050:     }
1051:     else
1052:     {
1053:       $this->output_->writeMessageBegin('describe_keyspaces', \TMessageType::CALL, $this->seqid_);
1054:       $args->write($this->output_);
1055:       $this->output_->writeMessageEnd();
1056:       $this->output_->getTransport()->flush();
1057:     }
1058:   }
1059: 
1060:   public function recv_describe_keyspaces()
1061:   {
1062:     $bin_accel = ($this->input_ instanceof \TProtocol::$TBINARYPROTOCOLACCELERATED) && function_exists('thrift_protocol_read_binary');
1063:     if ($bin_accel) $result = thrift_protocol_read_binary($this->input_, '\cassandra\Cassandra_describe_keyspaces_result', $this->input_->isStrictRead());
1064:     else
1065:     {
1066:       $rseqid = 0;
1067:       $fname = null;
1068:       $mtype = 0;
1069: 
1070:       $this->input_->readMessageBegin($fname, $mtype, $rseqid);
1071:       if ($mtype == \TMessageType::EXCEPTION) {
1072:         $x = new \TApplicationException();
1073:         $x->read($this->input_);
1074:         $this->input_->readMessageEnd();
1075:         throw $x;
1076:       }
1077:       $result = new \cassandra\Cassandra_describe_keyspaces_result();
1078:       $result->read($this->input_);
1079:       $this->input_->readMessageEnd();
1080:     }
1081:     if ($result->success !== null) {
1082:       return $result->success;
1083:     }
1084:     if ($result->ire !== null) {
1085:       throw $result->ire;
1086:     }
1087:     throw new \Exception("describe_keyspaces failed: unknown result");
1088:   }
1089: 
1090:   public function describe_cluster_name()
1091:   {
1092:     $this->send_describe_cluster_name();
1093:     return $this->recv_describe_cluster_name();
1094:   }
1095: 
1096:   public function send_describe_cluster_name()
1097:   {
1098:     $args = new \cassandra\Cassandra_describe_cluster_name_args();
1099:     $bin_accel = ($this->output_ instanceof \TProtocol::$TBINARYPROTOCOLACCELERATED) && function_exists('thrift_protocol_write_binary');
1100:     if ($bin_accel)
1101:     {
1102:       thrift_protocol_write_binary($this->output_, 'describe_cluster_name', \TMessageType::CALL, $args, $this->seqid_, $this->output_->isStrictWrite());
1103:     }
1104:     else
1105:     {
1106:       $this->output_->writeMessageBegin('describe_cluster_name', \TMessageType::CALL, $this->seqid_);
1107:       $args->write($this->output_);
1108:       $this->output_->writeMessageEnd();
1109:       $this->output_->getTransport()->flush();
1110:     }
1111:   }
1112: 
1113:   public function recv_describe_cluster_name()
1114:   {
1115:     $bin_accel = ($this->input_ instanceof \TProtocol::$TBINARYPROTOCOLACCELERATED) && function_exists('thrift_protocol_read_binary');
1116:     if ($bin_accel) $result = thrift_protocol_read_binary($this->input_, '\cassandra\Cassandra_describe_cluster_name_result', $this->input_->isStrictRead());
1117:     else
1118:     {
1119:       $rseqid = 0;
1120:       $fname = null;
1121:       $mtype = 0;
1122: 
1123:       $this->input_->readMessageBegin($fname, $mtype, $rseqid);
1124:       if ($mtype == \TMessageType::EXCEPTION) {
1125:         $x = new \TApplicationException();
1126:         $x->read($this->input_);
1127:         $this->input_->readMessageEnd();
1128:         throw $x;
1129:       }
1130:       $result = new \cassandra\Cassandra_describe_cluster_name_result();
1131:       $result->read($this->input_);
1132:       $this->input_->readMessageEnd();
1133:     }
1134:     if ($result->success !== null) {
1135:       return $result->success;
1136:     }
1137:     throw new \Exception("describe_cluster_name failed: unknown result");
1138:   }
1139: 
1140:   public function describe_version()
1141:   {
1142:     $this->send_describe_version();
1143:     return $this->recv_describe_version();
1144:   }
1145: 
1146:   public function send_describe_version()
1147:   {
1148:     $args = new \cassandra\Cassandra_describe_version_args();
1149:     $bin_accel = ($this->output_ instanceof \TProtocol::$TBINARYPROTOCOLACCELERATED) && function_exists('thrift_protocol_write_binary');
1150:     if ($bin_accel)
1151:     {
1152:       thrift_protocol_write_binary($this->output_, 'describe_version', \TMessageType::CALL, $args, $this->seqid_, $this->output_->isStrictWrite());
1153:     }
1154:     else
1155:     {
1156:       $this->output_->writeMessageBegin('describe_version', \TMessageType::CALL, $this->seqid_);
1157:       $args->write($this->output_);
1158:       $this->output_->writeMessageEnd();
1159:       $this->output_->getTransport()->flush();
1160:     }
1161:   }
1162: 
1163:   public function recv_describe_version()
1164:   {
1165:     $bin_accel = ($this->input_ instanceof \TProtocol::$TBINARYPROTOCOLACCELERATED) && function_exists('thrift_protocol_read_binary');
1166:     if ($bin_accel) $result = thrift_protocol_read_binary($this->input_, '\cassandra\Cassandra_describe_version_result', $this->input_->isStrictRead());
1167:     else
1168:     {
1169:       $rseqid = 0;
1170:       $fname = null;
1171:       $mtype = 0;
1172: 
1173:       $this->input_->readMessageBegin($fname, $mtype, $rseqid);
1174:       if ($mtype == \TMessageType::EXCEPTION) {
1175:         $x = new \TApplicationException();
1176:         $x->read($this->input_);
1177:         $this->input_->readMessageEnd();
1178:         throw $x;
1179:       }
1180:       $result = new \cassandra\Cassandra_describe_version_result();
1181:       $result->read($this->input_);
1182:       $this->input_->readMessageEnd();
1183:     }
1184:     if ($result->success !== null) {
1185:       return $result->success;
1186:     }
1187:     throw new \Exception("describe_version failed: unknown result");
1188:   }
1189: 
1190:   public function describe_ring($keyspace)
1191:   {
1192:     $this->send_describe_ring($keyspace);
1193:     return $this->recv_describe_ring();
1194:   }
1195: 
1196:   public function send_describe_ring($keyspace)
1197:   {
1198:     $args = new \cassandra\Cassandra_describe_ring_args();
1199:     $args->keyspace = $keyspace;
1200:     $bin_accel = ($this->output_ instanceof \TProtocol::$TBINARYPROTOCOLACCELERATED) && function_exists('thrift_protocol_write_binary');
1201:     if ($bin_accel)
1202:     {
1203:       thrift_protocol_write_binary($this->output_, 'describe_ring', \TMessageType::CALL, $args, $this->seqid_, $this->output_->isStrictWrite());
1204:     }
1205:     else
1206:     {
1207:       $this->output_->writeMessageBegin('describe_ring', \TMessageType::CALL, $this->seqid_);
1208:       $args->write($this->output_);
1209:       $this->output_->writeMessageEnd();
1210:       $this->output_->getTransport()->flush();
1211:     }
1212:   }
1213: 
1214:   public function recv_describe_ring()
1215:   {
1216:     $bin_accel = ($this->input_ instanceof \TProtocol::$TBINARYPROTOCOLACCELERATED) && function_exists('thrift_protocol_read_binary');
1217:     if ($bin_accel) $result = thrift_protocol_read_binary($this->input_, '\cassandra\Cassandra_describe_ring_result', $this->input_->isStrictRead());
1218:     else
1219:     {
1220:       $rseqid = 0;
1221:       $fname = null;
1222:       $mtype = 0;
1223: 
1224:       $this->input_->readMessageBegin($fname, $mtype, $rseqid);
1225:       if ($mtype == \TMessageType::EXCEPTION) {
1226:         $x = new \TApplicationException();
1227:         $x->read($this->input_);
1228:         $this->input_->readMessageEnd();
1229:         throw $x;
1230:       }
1231:       $result = new \cassandra\Cassandra_describe_ring_result();
1232:       $result->read($this->input_);
1233:       $this->input_->readMessageEnd();
1234:     }
1235:     if ($result->success !== null) {
1236:       return $result->success;
1237:     }
1238:     if ($result->ire !== null) {
1239:       throw $result->ire;
1240:     }
1241:     throw new \Exception("describe_ring failed: unknown result");
1242:   }
1243: 
1244:   public function describe_partitioner()
1245:   {
1246:     $this->send_describe_partitioner();
1247:     return $this->recv_describe_partitioner();
1248:   }
1249: 
1250:   public function send_describe_partitioner()
1251:   {
1252:     $args = new \cassandra\Cassandra_describe_partitioner_args();
1253:     $bin_accel = ($this->output_ instanceof \TProtocol::$TBINARYPROTOCOLACCELERATED) && function_exists('thrift_protocol_write_binary');
1254:     if ($bin_accel)
1255:     {
1256:       thrift_protocol_write_binary($this->output_, 'describe_partitioner', \TMessageType::CALL, $args, $this->seqid_, $this->output_->isStrictWrite());
1257:     }
1258:     else
1259:     {
1260:       $this->output_->writeMessageBegin('describe_partitioner', \TMessageType::CALL, $this->seqid_);
1261:       $args->write($this->output_);
1262:       $this->output_->writeMessageEnd();
1263:       $this->output_->getTransport()->flush();
1264:     }
1265:   }
1266: 
1267:   public function recv_describe_partitioner()
1268:   {
1269:     $bin_accel = ($this->input_ instanceof \TProtocol::$TBINARYPROTOCOLACCELERATED) && function_exists('thrift_protocol_read_binary');
1270:     if ($bin_accel) $result = thrift_protocol_read_binary($this->input_, '\cassandra\Cassandra_describe_partitioner_result', $this->input_->isStrictRead());
1271:     else
1272:     {
1273:       $rseqid = 0;
1274:       $fname = null;
1275:       $mtype = 0;
1276: 
1277:       $this->input_->readMessageBegin($fname, $mtype, $rseqid);
1278:       if ($mtype == \TMessageType::EXCEPTION) {
1279:         $x = new \TApplicationException();
1280:         $x->read($this->input_);
1281:         $this->input_->readMessageEnd();
1282:         throw $x;
1283:       }
1284:       $result = new \cassandra\Cassandra_describe_partitioner_result();
1285:       $result->read($this->input_);
1286:       $this->input_->readMessageEnd();
1287:     }
1288:     if ($result->success !== null) {
1289:       return $result->success;
1290:     }
1291:     throw new \Exception("describe_partitioner failed: unknown result");
1292:   }
1293: 
1294:   public function describe_snitch()
1295:   {
1296:     $this->send_describe_snitch();
1297:     return $this->recv_describe_snitch();
1298:   }
1299: 
1300:   public function send_describe_snitch()
1301:   {
1302:     $args = new \cassandra\Cassandra_describe_snitch_args();
1303:     $bin_accel = ($this->output_ instanceof \TProtocol::$TBINARYPROTOCOLACCELERATED) && function_exists('thrift_protocol_write_binary');
1304:     if ($bin_accel)
1305:     {
1306:       thrift_protocol_write_binary($this->output_, 'describe_snitch', \TMessageType::CALL, $args, $this->seqid_, $this->output_->isStrictWrite());
1307:     }
1308:     else
1309:     {
1310:       $this->output_->writeMessageBegin('describe_snitch', \TMessageType::CALL, $this->seqid_);
1311:       $args->write($this->output_);
1312:       $this->output_->writeMessageEnd();
1313:       $this->output_->getTransport()->flush();
1314:     }
1315:   }
1316: 
1317:   public function recv_describe_snitch()
1318:   {
1319:     $bin_accel = ($this->input_ instanceof \TProtocol::$TBINARYPROTOCOLACCELERATED) && function_exists('thrift_protocol_read_binary');
1320:     if ($bin_accel) $result = thrift_protocol_read_binary($this->input_, '\cassandra\Cassandra_describe_snitch_result', $this->input_->isStrictRead());
1321:     else
1322:     {
1323:       $rseqid = 0;
1324:       $fname = null;
1325:       $mtype = 0;
1326: 
1327:       $this->input_->readMessageBegin($fname, $mtype, $rseqid);
1328:       if ($mtype == \TMessageType::EXCEPTION) {
1329:         $x = new \TApplicationException();
1330:         $x->read($this->input_);
1331:         $this->input_->readMessageEnd();
1332:         throw $x;
1333:       }
1334:       $result = new \cassandra\Cassandra_describe_snitch_result();
1335:       $result->read($this->input_);
1336:       $this->input_->readMessageEnd();
1337:     }
1338:     if ($result->success !== null) {
1339:       return $result->success;
1340:     }
1341:     throw new \Exception("describe_snitch failed: unknown result");
1342:   }
1343: 
1344:   public function describe_keyspace($keyspace)
1345:   {
1346:     $this->send_describe_keyspace($keyspace);
1347:     return $this->recv_describe_keyspace();
1348:   }
1349: 
1350:   public function send_describe_keyspace($keyspace)
1351:   {
1352:     $args = new \cassandra\Cassandra_describe_keyspace_args();
1353:     $args->keyspace = $keyspace;
1354:     $bin_accel = ($this->output_ instanceof \TProtocol::$TBINARYPROTOCOLACCELERATED) && function_exists('thrift_protocol_write_binary');
1355:     if ($bin_accel)
1356:     {
1357:       thrift_protocol_write_binary($this->output_, 'describe_keyspace', \TMessageType::CALL, $args, $this->seqid_, $this->output_->isStrictWrite());
1358:     }
1359:     else
1360:     {
1361:       $this->output_->writeMessageBegin('describe_keyspace', \TMessageType::CALL, $this->seqid_);
1362:       $args->write($this->output_);
1363:       $this->output_->writeMessageEnd();
1364:       $this->output_->getTransport()->flush();
1365:     }
1366:   }
1367: 
1368:   public function recv_describe_keyspace()
1369:   {
1370:     $bin_accel = ($this->input_ instanceof \TProtocol::$TBINARYPROTOCOLACCELERATED) && function_exists('thrift_protocol_read_binary');
1371:     if ($bin_accel) $result = thrift_protocol_read_binary($this->input_, '\cassandra\Cassandra_describe_keyspace_result', $this->input_->isStrictRead());
1372:     else
1373:     {
1374:       $rseqid = 0;
1375:       $fname = null;
1376:       $mtype = 0;
1377: 
1378:       $this->input_->readMessageBegin($fname, $mtype, $rseqid);
1379:       if ($mtype == \TMessageType::EXCEPTION) {
1380:         $x = new \TApplicationException();
1381:         $x->read($this->input_);
1382:         $this->input_->readMessageEnd();
1383:         throw $x;
1384:       }
1385:       $result = new \cassandra\Cassandra_describe_keyspace_result();
1386:       $result->read($this->input_);
1387:       $this->input_->readMessageEnd();
1388:     }
1389:     if ($result->success !== null) {
1390:       return $result->success;
1391:     }
1392:     if ($result->nfe !== null) {
1393:       throw $result->nfe;
1394:     }
1395:     if ($result->ire !== null) {
1396:       throw $result->ire;
1397:     }
1398:     throw new \Exception("describe_keyspace failed: unknown result");
1399:   }
1400: 
1401:   public function describe_splits($cfName, $start_token, $end_token, $keys_per_split)
1402:   {
1403:     $this->send_describe_splits($cfName, $start_token, $end_token, $keys_per_split);
1404:     return $this->recv_describe_splits();
1405:   }
1406: 
1407:   public function send_describe_splits($cfName, $start_token, $end_token, $keys_per_split)
1408:   {
1409:     $args = new \cassandra\Cassandra_describe_splits_args();
1410:     $args->cfName = $cfName;
1411:     $args->start_token = $start_token;
1412:     $args->end_token = $end_token;
1413:     $args->keys_per_split = $keys_per_split;
1414:     $bin_accel = ($this->output_ instanceof \TProtocol::$TBINARYPROTOCOLACCELERATED) && function_exists('thrift_protocol_write_binary');
1415:     if ($bin_accel)
1416:     {
1417:       thrift_protocol_write_binary($this->output_, 'describe_splits', \TMessageType::CALL, $args, $this->seqid_, $this->output_->isStrictWrite());
1418:     }
1419:     else
1420:     {
1421:       $this->output_->writeMessageBegin('describe_splits', \TMessageType::CALL, $this->seqid_);
1422:       $args->write($this->output_);
1423:       $this->output_->writeMessageEnd();
1424:       $this->output_->getTransport()->flush();
1425:     }
1426:   }
1427: 
1428:   public function recv_describe_splits()
1429:   {
1430:     $bin_accel = ($this->input_ instanceof \TProtocol::$TBINARYPROTOCOLACCELERATED) && function_exists('thrift_protocol_read_binary');
1431:     if ($bin_accel) $result = thrift_protocol_read_binary($this->input_, '\cassandra\Cassandra_describe_splits_result', $this->input_->isStrictRead());
1432:     else
1433:     {
1434:       $rseqid = 0;
1435:       $fname = null;
1436:       $mtype = 0;
1437: 
1438:       $this->input_->readMessageBegin($fname, $mtype, $rseqid);
1439:       if ($mtype == \TMessageType::EXCEPTION) {
1440:         $x = new \TApplicationException();
1441:         $x->read($this->input_);
1442:         $this->input_->readMessageEnd();
1443:         throw $x;
1444:       }
1445:       $result = new \cassandra\Cassandra_describe_splits_result();
1446:       $result->read($this->input_);
1447:       $this->input_->readMessageEnd();
1448:     }
1449:     if ($result->success !== null) {
1450:       return $result->success;
1451:     }
1452:     if ($result->ire !== null) {
1453:       throw $result->ire;
1454:     }
1455:     throw new \Exception("describe_splits failed: unknown result");
1456:   }
1457: 
1458:   public function system_add_column_family($cf_def)
1459:   {
1460:     $this->send_system_add_column_family($cf_def);
1461:     return $this->recv_system_add_column_family();
1462:   }
1463: 
1464:   public function send_system_add_column_family($cf_def)
1465:   {
1466:     $args = new \cassandra\Cassandra_system_add_column_family_args();
1467:     $args->cf_def = $cf_def;
1468:     $bin_accel = ($this->output_ instanceof \TProtocol::$TBINARYPROTOCOLACCELERATED) && function_exists('thrift_protocol_write_binary');
1469:     if ($bin_accel)
1470:     {
1471:       thrift_protocol_write_binary($this->output_, 'system_add_column_family', \TMessageType::CALL, $args, $this->seqid_, $this->output_->isStrictWrite());
1472:     }
1473:     else
1474:     {
1475:       $this->output_->writeMessageBegin('system_add_column_family', \TMessageType::CALL, $this->seqid_);
1476:       $args->write($this->output_);
1477:       $this->output_->writeMessageEnd();
1478:       $this->output_->getTransport()->flush();
1479:     }
1480:   }
1481: 
1482:   public function recv_system_add_column_family()
1483:   {
1484:     $bin_accel = ($this->input_ instanceof \TProtocol::$TBINARYPROTOCOLACCELERATED) && function_exists('thrift_protocol_read_binary');
1485:     if ($bin_accel) $result = thrift_protocol_read_binary($this->input_, '\cassandra\Cassandra_system_add_column_family_result', $this->input_->isStrictRead());
1486:     else
1487:     {
1488:       $rseqid = 0;
1489:       $fname = null;
1490:       $mtype = 0;
1491: 
1492:       $this->input_->readMessageBegin($fname, $mtype, $rseqid);
1493:       if ($mtype == \TMessageType::EXCEPTION) {
1494:         $x = new \TApplicationException();
1495:         $x->read($this->input_);
1496:         $this->input_->readMessageEnd();
1497:         throw $x;
1498:       }
1499:       $result = new \cassandra\Cassandra_system_add_column_family_result();
1500:       $result->read($this->input_);
1501:       $this->input_->readMessageEnd();
1502:     }
1503:     if ($result->success !== null) {
1504:       return $result->success;
1505:     }
1506:     if ($result->ire !== null) {
1507:       throw $result->ire;
1508:     }
1509:     if ($result->sde !== null) {
1510:       throw $result->sde;
1511:     }
1512:     throw new \Exception("system_add_column_family failed: unknown result");
1513:   }
1514: 
1515:   public function system_drop_column_family($column_family)
1516:   {
1517:     $this->send_system_drop_column_family($column_family);
1518:     return $this->recv_system_drop_column_family();
1519:   }
1520: 
1521:   public function send_system_drop_column_family($column_family)
1522:   {
1523:     $args = new \cassandra\Cassandra_system_drop_column_family_args();
1524:     $args->column_family = $column_family;
1525:     $bin_accel = ($this->output_ instanceof \TProtocol::$TBINARYPROTOCOLACCELERATED) && function_exists('thrift_protocol_write_binary');
1526:     if ($bin_accel)
1527:     {
1528:       thrift_protocol_write_binary($this->output_, 'system_drop_column_family', \TMessageType::CALL, $args, $this->seqid_, $this->output_->isStrictWrite());
1529:     }
1530:     else
1531:     {
1532:       $this->output_->writeMessageBegin('system_drop_column_family', \TMessageType::CALL, $this->seqid_);
1533:       $args->write($this->output_);
1534:       $this->output_->writeMessageEnd();
1535:       $this->output_->getTransport()->flush();
1536:     }
1537:   }
1538: 
1539:   public function recv_system_drop_column_family()
1540:   {
1541:     $bin_accel = ($this->input_ instanceof \TProtocol::$TBINARYPROTOCOLACCELERATED) && function_exists('thrift_protocol_read_binary');
1542:     if ($bin_accel) $result = thrift_protocol_read_binary($this->input_, '\cassandra\Cassandra_system_drop_column_family_result', $this->input_->isStrictRead());
1543:     else
1544:     {
1545:       $rseqid = 0;
1546:       $fname = null;
1547:       $mtype = 0;
1548: 
1549:       $this->input_->readMessageBegin($fname, $mtype, $rseqid);
1550:       if ($mtype == \TMessageType::EXCEPTION) {
1551:         $x = new \TApplicationException();
1552:         $x->read($this->input_);
1553:         $this->input_->readMessageEnd();
1554:         throw $x;
1555:       }
1556:       $result = new \cassandra\Cassandra_system_drop_column_family_result();
1557:       $result->read($this->input_);
1558:       $this->input_->readMessageEnd();
1559:     }
1560:     if ($result->success !== null) {
1561:       return $result->success;
1562:     }
1563:     if ($result->ire !== null) {
1564:       throw $result->ire;
1565:     }
1566:     if ($result->sde !== null) {
1567:       throw $result->sde;
1568:     }
1569:     throw new \Exception("system_drop_column_family failed: unknown result");
1570:   }
1571: 
1572:   public function system_add_keyspace($ks_def)
1573:   {
1574:     $this->send_system_add_keyspace($ks_def);
1575:     return $this->recv_system_add_keyspace();
1576:   }
1577: 
1578:   public function send_system_add_keyspace($ks_def)
1579:   {
1580:     $args = new \cassandra\Cassandra_system_add_keyspace_args();
1581:     $args->ks_def = $ks_def;
1582:     $bin_accel = ($this->output_ instanceof \TProtocol::$TBINARYPROTOCOLACCELERATED) && function_exists('thrift_protocol_write_binary');
1583:     if ($bin_accel)
1584:     {
1585:       thrift_protocol_write_binary($this->output_, 'system_add_keyspace', \TMessageType::CALL, $args, $this->seqid_, $this->output_->isStrictWrite());
1586:     }
1587:     else
1588:     {
1589:       $this->output_->writeMessageBegin('system_add_keyspace', \TMessageType::CALL, $this->seqid_);
1590:       $args->write($this->output_);
1591:       $this->output_->writeMessageEnd();
1592:       $this->output_->getTransport()->flush();
1593:     }
1594:   }
1595: 
1596:   public function recv_system_add_keyspace()
1597:   {
1598:     $bin_accel = ($this->input_ instanceof \TProtocol::$TBINARYPROTOCOLACCELERATED) && function_exists('thrift_protocol_read_binary');
1599:     if ($bin_accel) $result = thrift_protocol_read_binary($this->input_, '\cassandra\Cassandra_system_add_keyspace_result', $this->input_->isStrictRead());
1600:     else
1601:     {
1602:       $rseqid = 0;
1603:       $fname = null;
1604:       $mtype = 0;
1605: 
1606:       $this->input_->readMessageBegin($fname, $mtype, $rseqid);
1607:       if ($mtype == \TMessageType::EXCEPTION) {
1608:         $x = new \TApplicationException();
1609:         $x->read($this->input_);
1610:         $this->input_->readMessageEnd();
1611:         throw $x;
1612:       }
1613:       $result = new \cassandra\Cassandra_system_add_keyspace_result();
1614:       $result->read($this->input_);
1615:       $this->input_->readMessageEnd();
1616:     }
1617:     if ($result->success !== null) {
1618:       return $result->success;
1619:     }
1620:     if ($result->ire !== null) {
1621:       throw $result->ire;
1622:     }
1623:     if ($result->sde !== null) {
1624:       throw $result->sde;
1625:     }
1626:     throw new \Exception("system_add_keyspace failed: unknown result");
1627:   }
1628: 
1629:   public function system_drop_keyspace($keyspace)
1630:   {
1631:     $this->send_system_drop_keyspace($keyspace);
1632:     return $this->recv_system_drop_keyspace();
1633:   }
1634: 
1635:   public function send_system_drop_keyspace($keyspace)
1636:   {
1637:     $args = new \cassandra\Cassandra_system_drop_keyspace_args();
1638:     $args->keyspace = $keyspace;
1639:     $bin_accel = ($this->output_ instanceof \TProtocol::$TBINARYPROTOCOLACCELERATED) && function_exists('thrift_protocol_write_binary');
1640:     if ($bin_accel)
1641:     {
1642:       thrift_protocol_write_binary($this->output_, 'system_drop_keyspace', \TMessageType::CALL, $args, $this->seqid_, $this->output_->isStrictWrite());
1643:     }
1644:     else
1645:     {
1646:       $this->output_->writeMessageBegin('system_drop_keyspace', \TMessageType::CALL, $this->seqid_);
1647:       $args->write($this->output_);
1648:       $this->output_->writeMessageEnd();
1649:       $this->output_->getTransport()->flush();
1650:     }
1651:   }
1652: 
1653:   public function recv_system_drop_keyspace()
1654:   {
1655:     $bin_accel = ($this->input_ instanceof \TProtocol::$TBINARYPROTOCOLACCELERATED) && function_exists('thrift_protocol_read_binary');
1656:     if ($bin_accel) $result = thrift_protocol_read_binary($this->input_, '\cassandra\Cassandra_system_drop_keyspace_result', $this->input_->isStrictRead());
1657:     else
1658:     {
1659:       $rseqid = 0;
1660:       $fname = null;
1661:       $mtype = 0;
1662: 
1663:       $this->input_->readMessageBegin($fname, $mtype, $rseqid);
1664:       if ($mtype == \TMessageType::EXCEPTION) {
1665:         $x = new \TApplicationException();
1666:         $x->read($this->input_);
1667:         $this->input_->readMessageEnd();
1668:         throw $x;
1669:       }
1670:       $result = new \cassandra\Cassandra_system_drop_keyspace_result();
1671:       $result->read($this->input_);
1672:       $this->input_->readMessageEnd();
1673:     }
1674:     if ($result->success !== null) {
1675:       return $result->success;
1676:     }
1677:     if ($result->ire !== null) {
1678:       throw $result->ire;
1679:     }
1680:     if ($result->sde !== null) {
1681:       throw $result->sde;
1682:     }
1683:     throw new \Exception("system_drop_keyspace failed: unknown result");
1684:   }
1685: 
1686:   public function system_update_keyspace($ks_def)
1687:   {
1688:     $this->send_system_update_keyspace($ks_def);
1689:     return $this->recv_system_update_keyspace();
1690:   }
1691: 
1692:   public function send_system_update_keyspace($ks_def)
1693:   {
1694:     $args = new \cassandra\Cassandra_system_update_keyspace_args();
1695:     $args->ks_def = $ks_def;
1696:     $bin_accel = ($this->output_ instanceof \TProtocol::$TBINARYPROTOCOLACCELERATED) && function_exists('thrift_protocol_write_binary');
1697:     if ($bin_accel)
1698:     {
1699:       thrift_protocol_write_binary($this->output_, 'system_update_keyspace', \TMessageType::CALL, $args, $this->seqid_, $this->output_->isStrictWrite());
1700:     }
1701:     else
1702:     {
1703:       $this->output_->writeMessageBegin('system_update_keyspace', \TMessageType::CALL, $this->seqid_);
1704:       $args->write($this->output_);
1705:       $this->output_->writeMessageEnd();
1706:       $this->output_->getTransport()->flush();
1707:     }
1708:   }
1709: 
1710:   public function recv_system_update_keyspace()
1711:   {
1712:     $bin_accel = ($this->input_ instanceof \TProtocol::$TBINARYPROTOCOLACCELERATED) && function_exists('thrift_protocol_read_binary');
1713:     if ($bin_accel) $result = thrift_protocol_read_binary($this->input_, '\cassandra\Cassandra_system_update_keyspace_result', $this->input_->isStrictRead());
1714:     else
1715:     {
1716:       $rseqid = 0;
1717:       $fname = null;
1718:       $mtype = 0;
1719: 
1720:       $this->input_->readMessageBegin($fname, $mtype, $rseqid);
1721:       if ($mtype == \TMessageType::EXCEPTION) {
1722:         $x = new \TApplicationException();
1723:         $x->read($this->input_);
1724:         $this->input_->readMessageEnd();
1725:         throw $x;
1726:       }
1727:       $result = new \cassandra\Cassandra_system_update_keyspace_result();
1728:       $result->read($this->input_);
1729:       $this->input_->readMessageEnd();
1730:     }
1731:     if ($result->success !== null) {
1732:       return $result->success;
1733:     }
1734:     if ($result->ire !== null) {
1735:       throw $result->ire;
1736:     }
1737:     if ($result->sde !== null) {
1738:       throw $result->sde;
1739:     }
1740:     throw new \Exception("system_update_keyspace failed: unknown result");
1741:   }
1742: 
1743:   public function system_update_column_family($cf_def)
1744:   {
1745:     $this->send_system_update_column_family($cf_def);
1746:     return $this->recv_system_update_column_family();
1747:   }
1748: 
1749:   public function send_system_update_column_family($cf_def)
1750:   {
1751:     $args = new \cassandra\Cassandra_system_update_column_family_args();
1752:     $args->cf_def = $cf_def;
1753:     $bin_accel = ($this->output_ instanceof \TProtocol::$TBINARYPROTOCOLACCELERATED) && function_exists('thrift_protocol_write_binary');
1754:     if ($bin_accel)
1755:     {
1756:       thrift_protocol_write_binary($this->output_, 'system_update_column_family', \TMessageType::CALL, $args, $this->seqid_, $this->output_->isStrictWrite());
1757:     }
1758:     else
1759:     {
1760:       $this->output_->writeMessageBegin('system_update_column_family', \TMessageType::CALL, $this->seqid_);
1761:       $args->write($this->output_);
1762:       $this->output_->writeMessageEnd();
1763:       $this->output_->getTransport()->flush();
1764:     }
1765:   }
1766: 
1767:   public function recv_system_update_column_family()
1768:   {
1769:     $bin_accel = ($this->input_ instanceof \TProtocol::$TBINARYPROTOCOLACCELERATED) && function_exists('thrift_protocol_read_binary');
1770:     if ($bin_accel) $result = thrift_protocol_read_binary($this->input_, '\cassandra\Cassandra_system_update_column_family_result', $this->input_->isStrictRead());
1771:     else
1772:     {
1773:       $rseqid = 0;
1774:       $fname = null;
1775:       $mtype = 0;
1776: 
1777:       $this->input_->readMessageBegin($fname, $mtype, $rseqid);
1778:       if ($mtype == \TMessageType::EXCEPTION) {
1779:         $x = new \TApplicationException();
1780:         $x->read($this->input_);
1781:         $this->input_->readMessageEnd();
1782:         throw $x;
1783:       }
1784:       $result = new \cassandra\Cassandra_system_update_column_family_result();
1785:       $result->read($this->input_);
1786:       $this->input_->readMessageEnd();
1787:     }
1788:     if ($result->success !== null) {
1789:       return $result->success;
1790:     }
1791:     if ($result->ire !== null) {
1792:       throw $result->ire;
1793:     }
1794:     if ($result->sde !== null) {
1795:       throw $result->sde;
1796:     }
1797:     throw new \Exception("system_update_column_family failed: unknown result");
1798:   }
1799: 
1800:   public function execute_cql_query($query, $compression)
1801:   {
1802:     $this->send_execute_cql_query($query, $compression);
1803:     return $this->recv_execute_cql_query();
1804:   }
1805: 
1806:   public function send_execute_cql_query($query, $compression)
1807:   {
1808:     $args = new \cassandra\Cassandra_execute_cql_query_args();
1809:     $args->query = $query;
1810:     $args->compression = $compression;
1811:     $bin_accel = ($this->output_ instanceof \TProtocol::$TBINARYPROTOCOLACCELERATED) && function_exists('thrift_protocol_write_binary');
1812:     if ($bin_accel)
1813:     {
1814:       thrift_protocol_write_binary($this->output_, 'execute_cql_query', \TMessageType::CALL, $args, $this->seqid_, $this->output_->isStrictWrite());
1815:     }
1816:     else
1817:     {
1818:       $this->output_->writeMessageBegin('execute_cql_query', \TMessageType::CALL, $this->seqid_);
1819:       $args->write($this->output_);
1820:       $this->output_->writeMessageEnd();
1821:       $this->output_->getTransport()->flush();
1822:     }
1823:   }
1824: 
1825:   public function recv_execute_cql_query()
1826:   {
1827:     $bin_accel = ($this->input_ instanceof \TProtocol::$TBINARYPROTOCOLACCELERATED) && function_exists('thrift_protocol_read_binary');
1828:     if ($bin_accel) $result = thrift_protocol_read_binary($this->input_, '\cassandra\Cassandra_execute_cql_query_result', $this->input_->isStrictRead());
1829:     else
1830:     {
1831:       $rseqid = 0;
1832:       $fname = null;
1833:       $mtype = 0;
1834: 
1835:       $this->input_->readMessageBegin($fname, $mtype, $rseqid);
1836:       if ($mtype == \TMessageType::EXCEPTION) {
1837:         $x = new \TApplicationException();
1838:         $x->read($this->input_);
1839:         $this->input_->readMessageEnd();
1840:         throw $x;
1841:       }
1842:       $result = new \cassandra\Cassandra_execute_cql_query_result();
1843:       $result->read($this->input_);
1844:       $this->input_->readMessageEnd();
1845:     }
1846:     if ($result->success !== null) {
1847:       return $result->success;
1848:     }
1849:     if ($result->ire !== null) {
1850:       throw $result->ire;
1851:     }
1852:     if ($result->ue !== null) {
1853:       throw $result->ue;
1854:     }
1855:     if ($result->te !== null) {
1856:       throw $result->te;
1857:     }
1858:     if ($result->sde !== null) {
1859:       throw $result->sde;
1860:     }
1861:     throw new \Exception("execute_cql_query failed: unknown result");
1862:   }
1863: 
1864:   public function prepare_cql_query($query, $compression)
1865:   {
1866:     $this->send_prepare_cql_query($query, $compression);
1867:     return $this->recv_prepare_cql_query();
1868:   }
1869: 
1870:   public function send_prepare_cql_query($query, $compression)
1871:   {
1872:     $args = new \cassandra\Cassandra_prepare_cql_query_args();
1873:     $args->query = $query;
1874:     $args->compression = $compression;
1875:     $bin_accel = ($this->output_ instanceof \TProtocol::$TBINARYPROTOCOLACCELERATED) && function_exists('thrift_protocol_write_binary');
1876:     if ($bin_accel)
1877:     {
1878:       thrift_protocol_write_binary($this->output_, 'prepare_cql_query', \TMessageType::CALL, $args, $this->seqid_, $this->output_->isStrictWrite());
1879:     }
1880:     else
1881:     {
1882:       $this->output_->writeMessageBegin('prepare_cql_query', \TMessageType::CALL, $this->seqid_);
1883:       $args->write($this->output_);
1884:       $this->output_->writeMessageEnd();
1885:       $this->output_->getTransport()->flush();
1886:     }
1887:   }
1888: 
1889:   public function recv_prepare_cql_query()
1890:   {
1891:     $bin_accel = ($this->input_ instanceof \TProtocol::$TBINARYPROTOCOLACCELERATED) && function_exists('thrift_protocol_read_binary');
1892:     if ($bin_accel) $result = thrift_protocol_read_binary($this->input_, '\cassandra\Cassandra_prepare_cql_query_result', $this->input_->isStrictRead());
1893:     else
1894:     {
1895:       $rseqid = 0;
1896:       $fname = null;
1897:       $mtype = 0;
1898: 
1899:       $this->input_->readMessageBegin($fname, $mtype, $rseqid);
1900:       if ($mtype == \TMessageType::EXCEPTION) {
1901:         $x = new \TApplicationException();
1902:         $x->read($this->input_);
1903:         $this->input_->readMessageEnd();
1904:         throw $x;
1905:       }
1906:       $result = new \cassandra\Cassandra_prepare_cql_query_result();
1907:       $result->read($this->input_);
1908:       $this->input_->readMessageEnd();
1909:     }
1910:     if ($result->success !== null) {
1911:       return $result->success;
1912:     }
1913:     if ($result->ire !== null) {
1914:       throw $result->ire;
1915:     }
1916:     throw new \Exception("prepare_cql_query failed: unknown result");
1917:   }
1918: 
1919:   public function execute_prepared_cql_query($itemId, $values)
1920:   {
1921:     $this->send_execute_prepared_cql_query($itemId, $values);
1922:     return $this->recv_execute_prepared_cql_query();
1923:   }
1924: 
1925:   public function send_execute_prepared_cql_query($itemId, $values)
1926:   {
1927:     $args = new \cassandra\Cassandra_execute_prepared_cql_query_args();
1928:     $args->itemId = $itemId;
1929:     $args->values = $values;
1930:     $bin_accel = ($this->output_ instanceof \TProtocol::$TBINARYPROTOCOLACCELERATED) && function_exists('thrift_protocol_write_binary');
1931:     if ($bin_accel)
1932:     {
1933:       thrift_protocol_write_binary($this->output_, 'execute_prepared_cql_query', \TMessageType::CALL, $args, $this->seqid_, $this->output_->isStrictWrite());
1934:     }
1935:     else
1936:     {
1937:       $this->output_->writeMessageBegin('execute_prepared_cql_query', \TMessageType::CALL, $this->seqid_);
1938:       $args->write($this->output_);
1939:       $this->output_->writeMessageEnd();
1940:       $this->output_->getTransport()->flush();
1941:     }
1942:   }
1943: 
1944:   public function recv_execute_prepared_cql_query()
1945:   {
1946:     $bin_accel = ($this->input_ instanceof \TProtocol::$TBINARYPROTOCOLACCELERATED) && function_exists('thrift_protocol_read_binary');
1947:     if ($bin_accel) $result = thrift_protocol_read_binary($this->input_, '\cassandra\Cassandra_execute_prepared_cql_query_result', $this->input_->isStrictRead());
1948:     else
1949:     {
1950:       $rseqid = 0;
1951:       $fname = null;
1952:       $mtype = 0;
1953: 
1954:       $this->input_->readMessageBegin($fname, $mtype, $rseqid);
1955:       if ($mtype == \TMessageType::EXCEPTION) {
1956:         $x = new \TApplicationException();
1957:         $x->read($this->input_);
1958:         $this->input_->readMessageEnd();
1959:         throw $x;
1960:       }
1961:       $result = new \cassandra\Cassandra_execute_prepared_cql_query_result();
1962:       $result->read($this->input_);
1963:       $this->input_->readMessageEnd();
1964:     }
1965:     if ($result->success !== null) {
1966:       return $result->success;
1967:     }
1968:     if ($result->ire !== null) {
1969:       throw $result->ire;
1970:     }
1971:     if ($result->ue !== null) {
1972:       throw $result->ue;
1973:     }
1974:     if ($result->te !== null) {
1975:       throw $result->te;
1976:     }
1977:     if ($result->sde !== null) {
1978:       throw $result->sde;
1979:     }
1980:     throw new \Exception("execute_prepared_cql_query failed: unknown result");
1981:   }
1982: 
1983:   public function set_cql_version($version)
1984:   {
1985:     $this->send_set_cql_version($version);
1986:     $this->recv_set_cql_version();
1987:   }
1988: 
1989:   public function send_set_cql_version($version)
1990:   {
1991:     $args = new \cassandra\Cassandra_set_cql_version_args();
1992:     $args->version = $version;
1993:     $bin_accel = ($this->output_ instanceof \TProtocol::$TBINARYPROTOCOLACCELERATED) && function_exists('thrift_protocol_write_binary');
1994:     if ($bin_accel)
1995:     {
1996:       thrift_protocol_write_binary($this->output_, 'set_cql_version', \TMessageType::CALL, $args, $this->seqid_, $this->output_->isStrictWrite());
1997:     }
1998:     else
1999:     {
2000:       $this->output_->writeMessageBegin('set_cql_version', \TMessageType::CALL, $this->seqid_);
2001:       $args->write($this->output_);
2002:       $this->output_->writeMessageEnd();
2003:       $this->output_->getTransport()->flush();
2004:     }
2005:   }
2006: 
2007:   public function recv_set_cql_version()
2008:   {
2009:     $bin_accel = ($this->input_ instanceof \TProtocol::$TBINARYPROTOCOLACCELERATED) && function_exists('thrift_protocol_read_binary');
2010:     if ($bin_accel) $result = thrift_protocol_read_binary($this->input_, '\cassandra\Cassandra_set_cql_version_result', $this->input_->isStrictRead());
2011:     else
2012:     {
2013:       $rseqid = 0;
2014:       $fname = null;
2015:       $mtype = 0;
2016: 
2017:       $this->input_->readMessageBegin($fname, $mtype, $rseqid);
2018:       if ($mtype == \TMessageType::EXCEPTION) {
2019:         $x = new \TApplicationException();
2020:         $x->read($this->input_);
2021:         $this->input_->readMessageEnd();
2022:         throw $x;
2023:       }
2024:       $result = new \cassandra\Cassandra_set_cql_version_result();
2025:       $result->read($this->input_);
2026:       $this->input_->readMessageEnd();
2027:     }
2028:     if ($result->ire !== null) {
2029:       throw $result->ire;
2030:     }
2031:     return;
2032:   }
2033: 
2034: }
2035: 
2036: 
2037: ?>
2038: