Subversion Repositories php-qbpwcf

Rev

Details | Last modification | View Log | RSS feed

Rev Author Line No. Line
23 liveuser 1 
<?php
2 
/**
3 
 * Autogenerated by Thrift Compiler (0.9.3)
4 
 *
5 
 * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
6 
 *  @generated
7 
 */
8 
use Thrift\Base\TBase;
9 
use Thrift\Type\TType;
10 
use Thrift\Type\TMessageType;
11 
use Thrift\Exception\TException;
12 
use Thrift\Exception\TProtocolException;
13 
use Thrift\Protocol\TProtocol;
14 
use Thrift\Protocol\TBinaryProtocolAccelerated;
15 
use Thrift\Exception\TApplicationException;
16 
 
17 
 
18 
interface TCLIServiceIf {
19 
  /**
20 
   * @param \TOpenSessionReq $req
21 
   * @return \TOpenSessionResp
22 
   */
23 
  public function OpenSession(\TOpenSessionReq $req);
24 
  /**
25 
   * @param \TCloseSessionReq $req
26 
   * @return \TCloseSessionResp
27 
   */
28 
  public function CloseSession(\TCloseSessionReq $req);
29 
  /**
30 
   * @param \TGetInfoReq $req
31 
   * @return \TGetInfoResp
32 
   */
33 
  public function GetInfo(\TGetInfoReq $req);
34 
  /**
35 
   * @param \TExecuteStatementReq $req
36 
   * @return \TExecuteStatementResp
37 
   */
38 
  public function ExecuteStatement(\TExecuteStatementReq $req);
39 
  /**
40 
   * @param \TGetTypeInfoReq $req
41 
   * @return \TGetTypeInfoResp
42 
   */
43 
  public function GetTypeInfo(\TGetTypeInfoReq $req);
44 
  /**
45 
   * @param \TGetCatalogsReq $req
46 
   * @return \TGetCatalogsResp
47 
   */
48 
  public function GetCatalogs(\TGetCatalogsReq $req);
49 
  /**
50 
   * @param \TGetSchemasReq $req
51 
   * @return \TGetSchemasResp
52 
   */
53 
  public function GetSchemas(\TGetSchemasReq $req);
54 
  /**
55 
   * @param \TGetTablesReq $req
56 
   * @return \TGetTablesResp
57 
   */
58 
  public function GetTables(\TGetTablesReq $req);
59 
  /**
60 
   * @param \TGetTableTypesReq $req
61 
   * @return \TGetTableTypesResp
62 
   */
63 
  public function GetTableTypes(\TGetTableTypesReq $req);
64 
  /**
65 
   * @param \TGetColumnsReq $req
66 
   * @return \TGetColumnsResp
67 
   */
68 
  public function GetColumns(\TGetColumnsReq $req);
69 
  /**
70 
   * @param \TGetFunctionsReq $req
71 
   * @return \TGetFunctionsResp
72 
   */
73 
  public function GetFunctions(\TGetFunctionsReq $req);
74 
  /**
75 
   * @param \TGetOperationStatusReq $req
76 
   * @return \TGetOperationStatusResp
77 
   */
78 
  public function GetOperationStatus(\TGetOperationStatusReq $req);
79 
  /**
80 
   * @param \TCancelOperationReq $req
81 
   * @return \TCancelOperationResp
82 
   */
83 
  public function CancelOperation(\TCancelOperationReq $req);
84 
  /**
85 
   * @param \TCloseOperationReq $req
86 
   * @return \TCloseOperationResp
87 
   */
88 
  public function CloseOperation(\TCloseOperationReq $req);
89 
  /**
90 
   * @param \TGetResultSetMetadataReq $req
91 
   * @return \TGetResultSetMetadataResp
92 
   */
93 
  public function GetResultSetMetadata(\TGetResultSetMetadataReq $req);
94 
  /**
95 
   * @param \TFetchResultsReq $req
96 
   * @return \TFetchResultsResp
97 
   */
98 
  public function FetchResults(\TFetchResultsReq $req);
99 
  /**
100 
   * @param \TGetDelegationTokenReq $req
101 
   * @return \TGetDelegationTokenResp
102 
   */
103 
  public function GetDelegationToken(\TGetDelegationTokenReq $req);
104 
  /**
105 
   * @param \TCancelDelegationTokenReq $req
106 
   * @return \TCancelDelegationTokenResp
107 
   */
108 
  public function CancelDelegationToken(\TCancelDelegationTokenReq $req);
109 
  /**
110 
   * @param \TRenewDelegationTokenReq $req
111 
   * @return \TRenewDelegationTokenResp
112 
   */
113 
  public function RenewDelegationToken(\TRenewDelegationTokenReq $req);
114 
}
115 
 
116 
class TCLIServiceClient implements \TCLIServiceIf {
117 
  protected $input_ = null;
118 
  protected $output_ = null;
119 
 
120 
  protected $seqid_ = 0;
121 
 
122 
  public function __construct($input, $output=null) {
123 
    $this->input_ = $input;
124 
    $this->output_ = $output ? $output : $input;
125 
  }
126 
 
127 
  public function OpenSession(\TOpenSessionReq $req)
128 
  {
129 
    $this->send_OpenSession($req);
130 
    return $this->recv_OpenSession();
131 
  }
132 
 
133 
  public function send_OpenSession(\TOpenSessionReq $req)
134 
  {
135 
    $args = new \TCLIService_OpenSession_args();
136 
    $args->req = $req;
137 
    $bin_accel = ($this->output_ instanceof TBinaryProtocolAccelerated) && function_exists('thrift_protocol_write_binary');
138 
    if ($bin_accel)
139 
    {
140 
      thrift_protocol_write_binary($this->output_, 'OpenSession', TMessageType::CALL, $args, $this->seqid_, $this->output_->isStrictWrite());
141 
    }
142 
    else
143 
    {
144 
      $this->output_->writeMessageBegin('OpenSession', TMessageType::CALL, $this->seqid_);
145 
      $args->write($this->output_);
146 
      $this->output_->writeMessageEnd();
147 
      $this->output_->getTransport()->flush();
148 
    }
149 
  }
150 
 
151 
  public function recv_OpenSession()
152 
  {
153 
    $bin_accel = ($this->input_ instanceof TBinaryProtocolAccelerated) && function_exists('thrift_protocol_read_binary');
154 
    if ($bin_accel) $result = thrift_protocol_read_binary($this->input_, '\TCLIService_OpenSession_result', $this->input_->isStrictRead());
155 
    else
156 
    {
157 
      $rseqid = 0;
158 
      $fname = null;
159 
      $mtype = 0;
160 
 
161 
      $this->input_->readMessageBegin($fname, $mtype, $rseqid);
162 
      if ($mtype == TMessageType::EXCEPTION) {
163 
        $x = new TApplicationException();
164 
        $x->read($this->input_);
165 
        $this->input_->readMessageEnd();
166 
        throw $x;
167 
      }
168 
      $result = new \TCLIService_OpenSession_result();
169 
      $result->read($this->input_);
170 
      $this->input_->readMessageEnd();
171 
    }
172 
    if ($result->success !== null) {
173 
      return $result->success;
174 
    }
175 
    throw new \Exception("OpenSession failed: unknown result");
176 
  }
177 
 
178 
  public function CloseSession(\TCloseSessionReq $req)
179 
  {
180 
    $this->send_CloseSession($req);
181 
    return $this->recv_CloseSession();
182 
  }
183 
 
184 
  public function send_CloseSession(\TCloseSessionReq $req)
185 
  {
186 
    $args = new \TCLIService_CloseSession_args();
187 
    $args->req = $req;
188 
    $bin_accel = ($this->output_ instanceof TBinaryProtocolAccelerated) && function_exists('thrift_protocol_write_binary');
189 
    if ($bin_accel)
190 
    {
191 
      thrift_protocol_write_binary($this->output_, 'CloseSession', TMessageType::CALL, $args, $this->seqid_, $this->output_->isStrictWrite());
192 
    }
193 
    else
194 
    {
195 
      $this->output_->writeMessageBegin('CloseSession', TMessageType::CALL, $this->seqid_);
196 
      $args->write($this->output_);
197 
      $this->output_->writeMessageEnd();
198 
      $this->output_->getTransport()->flush();
199 
    }
200 
  }
201 
 
202 
  public function recv_CloseSession()
203 
  {
204 
    $bin_accel = ($this->input_ instanceof TBinaryProtocolAccelerated) && function_exists('thrift_protocol_read_binary');
205 
    if ($bin_accel) $result = thrift_protocol_read_binary($this->input_, '\TCLIService_CloseSession_result', $this->input_->isStrictRead());
206 
    else
207 
    {
208 
      $rseqid = 0;
209 
      $fname = null;
210 
      $mtype = 0;
211 
 
212 
      $this->input_->readMessageBegin($fname, $mtype, $rseqid);
213 
      if ($mtype == TMessageType::EXCEPTION) {
214 
        $x = new TApplicationException();
215 
        $x->read($this->input_);
216 
        $this->input_->readMessageEnd();
217 
        throw $x;
218 
      }
219 
      $result = new \TCLIService_CloseSession_result();
220 
      $result->read($this->input_);
221 
      $this->input_->readMessageEnd();
222 
    }
223 
    if ($result->success !== null) {
224 
      return $result->success;
225 
    }
226 
    throw new \Exception("CloseSession failed: unknown result");
227 
  }
228 
 
229 
  public function GetInfo(\TGetInfoReq $req)
230 
  {
231 
    $this->send_GetInfo($req);
232 
    return $this->recv_GetInfo();
233 
  }
234 
 
235 
  public function send_GetInfo(\TGetInfoReq $req)
236 
  {
237 
    $args = new \TCLIService_GetInfo_args();
238 
    $args->req = $req;
239 
    $bin_accel = ($this->output_ instanceof TBinaryProtocolAccelerated) && function_exists('thrift_protocol_write_binary');
240 
    if ($bin_accel)
241 
    {
242 
      thrift_protocol_write_binary($this->output_, 'GetInfo', TMessageType::CALL, $args, $this->seqid_, $this->output_->isStrictWrite());
243 
    }
244 
    else
245 
    {
246 
      $this->output_->writeMessageBegin('GetInfo', TMessageType::CALL, $this->seqid_);
247 
      $args->write($this->output_);
248 
      $this->output_->writeMessageEnd();
249 
      $this->output_->getTransport()->flush();
250 
    }
251 
  }
252 
 
253 
  public function recv_GetInfo()
254 
  {
255 
    $bin_accel = ($this->input_ instanceof TBinaryProtocolAccelerated) && function_exists('thrift_protocol_read_binary');
256 
    if ($bin_accel) $result = thrift_protocol_read_binary($this->input_, '\TCLIService_GetInfo_result', $this->input_->isStrictRead());
257 
    else
258 
    {
259 
      $rseqid = 0;
260 
      $fname = null;
261 
      $mtype = 0;
262 
 
263 
      $this->input_->readMessageBegin($fname, $mtype, $rseqid);
264 
      if ($mtype == TMessageType::EXCEPTION) {
265 
        $x = new TApplicationException();
266 
        $x->read($this->input_);
267 
        $this->input_->readMessageEnd();
268 
        throw $x;
269 
      }
270 
      $result = new \TCLIService_GetInfo_result();
271 
      $result->read($this->input_);
272 
      $this->input_->readMessageEnd();
273 
    }
274 
    if ($result->success !== null) {
275 
      return $result->success;
276 
    }
277 
    throw new \Exception("GetInfo failed: unknown result");
278 
  }
279 
 
280 
  public function ExecuteStatement(\TExecuteStatementReq $req)
281 
  {
282 
    $this->send_ExecuteStatement($req);
283 
    return $this->recv_ExecuteStatement();
284 
  }
285 
 
286 
  public function send_ExecuteStatement(\TExecuteStatementReq $req)
287 
  {
288 
    $args = new \TCLIService_ExecuteStatement_args();
289 
    $args->req = $req;
290 
    $bin_accel = ($this->output_ instanceof TBinaryProtocolAccelerated) && function_exists('thrift_protocol_write_binary');
291 
    if ($bin_accel)
292 
    {
293 
      thrift_protocol_write_binary($this->output_, 'ExecuteStatement', TMessageType::CALL, $args, $this->seqid_, $this->output_->isStrictWrite());
294 
    }
295 
    else
296 
    {
297 
      $this->output_->writeMessageBegin('ExecuteStatement', TMessageType::CALL, $this->seqid_);
298 
      $args->write($this->output_);
299 
      $this->output_->writeMessageEnd();
300 
      $this->output_->getTransport()->flush();
301 
    }
302 
  }
303 
 
304 
  public function recv_ExecuteStatement()
305 
  {
306 
    $bin_accel = ($this->input_ instanceof TBinaryProtocolAccelerated) && function_exists('thrift_protocol_read_binary');
307 
    if ($bin_accel) $result = thrift_protocol_read_binary($this->input_, '\TCLIService_ExecuteStatement_result', $this->input_->isStrictRead());
308 
    else
309 
    {
310 
      $rseqid = 0;
311 
      $fname = null;
312 
      $mtype = 0;
313 
 
314 
      $this->input_->readMessageBegin($fname, $mtype, $rseqid);
315 
      if ($mtype == TMessageType::EXCEPTION) {
316 
        $x = new TApplicationException();
317 
        $x->read($this->input_);
318 
        $this->input_->readMessageEnd();
319 
        throw $x;
320 
      }
321 
      $result = new \TCLIService_ExecuteStatement_result();
322 
      $result->read($this->input_);
323 
      $this->input_->readMessageEnd();
324 
    }
325 
    if ($result->success !== null) {
326 
      return $result->success;
327 
    }
328 
    throw new \Exception("ExecuteStatement failed: unknown result");
329 
  }
330 
 
331 
  public function GetTypeInfo(\TGetTypeInfoReq $req)
332 
  {
333 
    $this->send_GetTypeInfo($req);
334 
    return $this->recv_GetTypeInfo();
335 
  }
336 
 
337 
  public function send_GetTypeInfo(\TGetTypeInfoReq $req)
338 
  {
339 
    $args = new \TCLIService_GetTypeInfo_args();
340 
    $args->req = $req;
341 
    $bin_accel = ($this->output_ instanceof TBinaryProtocolAccelerated) && function_exists('thrift_protocol_write_binary');
342 
    if ($bin_accel)
343 
    {
344 
      thrift_protocol_write_binary($this->output_, 'GetTypeInfo', TMessageType::CALL, $args, $this->seqid_, $this->output_->isStrictWrite());
345 
    }
346 
    else
347 
    {
348 
      $this->output_->writeMessageBegin('GetTypeInfo', TMessageType::CALL, $this->seqid_);
349 
      $args->write($this->output_);
350 
      $this->output_->writeMessageEnd();
351 
      $this->output_->getTransport()->flush();
352 
    }
353 
  }
354 
 
355 
  public function recv_GetTypeInfo()
356 
  {
357 
    $bin_accel = ($this->input_ instanceof TBinaryProtocolAccelerated) && function_exists('thrift_protocol_read_binary');
358 
    if ($bin_accel) $result = thrift_protocol_read_binary($this->input_, '\TCLIService_GetTypeInfo_result', $this->input_->isStrictRead());
359 
    else
360 
    {
361 
      $rseqid = 0;
362 
      $fname = null;
363 
      $mtype = 0;
364 
 
365 
      $this->input_->readMessageBegin($fname, $mtype, $rseqid);
366 
      if ($mtype == TMessageType::EXCEPTION) {
367 
        $x = new TApplicationException();
368 
        $x->read($this->input_);
369 
        $this->input_->readMessageEnd();
370 
        throw $x;
371 
      }
372 
      $result = new \TCLIService_GetTypeInfo_result();
373 
      $result->read($this->input_);
374 
      $this->input_->readMessageEnd();
375 
    }
376 
    if ($result->success !== null) {
377 
      return $result->success;
378 
    }
379 
    throw new \Exception("GetTypeInfo failed: unknown result");
380 
  }
381 
 
382 
  public function GetCatalogs(\TGetCatalogsReq $req)
383 
  {
384 
    $this->send_GetCatalogs($req);
385 
    return $this->recv_GetCatalogs();
386 
  }
387 
 
388 
  public function send_GetCatalogs(\TGetCatalogsReq $req)
389 
  {
390 
    $args = new \TCLIService_GetCatalogs_args();
391 
    $args->req = $req;
392 
    $bin_accel = ($this->output_ instanceof TBinaryProtocolAccelerated) && function_exists('thrift_protocol_write_binary');
393 
    if ($bin_accel)
394 
    {
395 
      thrift_protocol_write_binary($this->output_, 'GetCatalogs', TMessageType::CALL, $args, $this->seqid_, $this->output_->isStrictWrite());
396 
    }
397 
    else
398 
    {
399 
      $this->output_->writeMessageBegin('GetCatalogs', TMessageType::CALL, $this->seqid_);
400 
      $args->write($this->output_);
401 
      $this->output_->writeMessageEnd();
402 
      $this->output_->getTransport()->flush();
403 
    }
404 
  }
405 
 
406 
  public function recv_GetCatalogs()
407 
  {
408 
    $bin_accel = ($this->input_ instanceof TBinaryProtocolAccelerated) && function_exists('thrift_protocol_read_binary');
409 
    if ($bin_accel) $result = thrift_protocol_read_binary($this->input_, '\TCLIService_GetCatalogs_result', $this->input_->isStrictRead());
410 
    else
411 
    {
412 
      $rseqid = 0;
413 
      $fname = null;
414 
      $mtype = 0;
415 
 
416 
      $this->input_->readMessageBegin($fname, $mtype, $rseqid);
417 
      if ($mtype == TMessageType::EXCEPTION) {
418 
        $x = new TApplicationException();
419 
        $x->read($this->input_);
420 
        $this->input_->readMessageEnd();
421 
        throw $x;
422 
      }
423 
      $result = new \TCLIService_GetCatalogs_result();
424 
      $result->read($this->input_);
425 
      $this->input_->readMessageEnd();
426 
    }
427 
    if ($result->success !== null) {
428 
      return $result->success;
429 
    }
430 
    throw new \Exception("GetCatalogs failed: unknown result");
431 
  }
432 
 
433 
  public function GetSchemas(\TGetSchemasReq $req)
434 
  {
435 
    $this->send_GetSchemas($req);
436 
    return $this->recv_GetSchemas();
437 
  }
438 
 
439 
  public function send_GetSchemas(\TGetSchemasReq $req)
440 
  {
441 
    $args = new \TCLIService_GetSchemas_args();
442 
    $args->req = $req;
443 
    $bin_accel = ($this->output_ instanceof TBinaryProtocolAccelerated) && function_exists('thrift_protocol_write_binary');
444 
    if ($bin_accel)
445 
    {
446 
      thrift_protocol_write_binary($this->output_, 'GetSchemas', TMessageType::CALL, $args, $this->seqid_, $this->output_->isStrictWrite());
447 
    }
448 
    else
449 
    {
450 
      $this->output_->writeMessageBegin('GetSchemas', TMessageType::CALL, $this->seqid_);
451 
      $args->write($this->output_);
452 
      $this->output_->writeMessageEnd();
453 
      $this->output_->getTransport()->flush();
454 
    }
455 
  }
456 
 
457 
  public function recv_GetSchemas()
458 
  {
459 
    $bin_accel = ($this->input_ instanceof TBinaryProtocolAccelerated) && function_exists('thrift_protocol_read_binary');
460 
    if ($bin_accel) $result = thrift_protocol_read_binary($this->input_, '\TCLIService_GetSchemas_result', $this->input_->isStrictRead());
461 
    else
462 
    {
463 
      $rseqid = 0;
464 
      $fname = null;
465 
      $mtype = 0;
466 
 
467 
      $this->input_->readMessageBegin($fname, $mtype, $rseqid);
468 
      if ($mtype == TMessageType::EXCEPTION) {
469 
        $x = new TApplicationException();
470 
        $x->read($this->input_);
471 
        $this->input_->readMessageEnd();
472 
        throw $x;
473 
      }
474 
      $result = new \TCLIService_GetSchemas_result();
475 
      $result->read($this->input_);
476 
      $this->input_->readMessageEnd();
477 
    }
478 
    if ($result->success !== null) {
479 
      return $result->success;
480 
    }
481 
    throw new \Exception("GetSchemas failed: unknown result");
482 
  }
483 
 
484 
  public function GetTables(\TGetTablesReq $req)
485 
  {
486 
    $this->send_GetTables($req);
487 
    return $this->recv_GetTables();
488 
  }
489 
 
490 
  public function send_GetTables(\TGetTablesReq $req)
491 
  {
492 
    $args = new \TCLIService_GetTables_args();
493 
    $args->req = $req;
494 
    $bin_accel = ($this->output_ instanceof TBinaryProtocolAccelerated) && function_exists('thrift_protocol_write_binary');
495 
    if ($bin_accel)
496 
    {
497 
      thrift_protocol_write_binary($this->output_, 'GetTables', TMessageType::CALL, $args, $this->seqid_, $this->output_->isStrictWrite());
498 
    }
499 
    else
500 
    {
501 
      $this->output_->writeMessageBegin('GetTables', TMessageType::CALL, $this->seqid_);
502 
      $args->write($this->output_);
503 
      $this->output_->writeMessageEnd();
504 
      $this->output_->getTransport()->flush();
505 
    }
506 
  }
507 
 
508 
  public function recv_GetTables()
509 
  {
510 
    $bin_accel = ($this->input_ instanceof TBinaryProtocolAccelerated) && function_exists('thrift_protocol_read_binary');
511 
    if ($bin_accel) $result = thrift_protocol_read_binary($this->input_, '\TCLIService_GetTables_result', $this->input_->isStrictRead());
512 
    else
513 
    {
514 
      $rseqid = 0;
515 
      $fname = null;
516 
      $mtype = 0;
517 
 
518 
      $this->input_->readMessageBegin($fname, $mtype, $rseqid);
519 
      if ($mtype == TMessageType::EXCEPTION) {
520 
        $x = new TApplicationException();
521 
        $x->read($this->input_);
522 
        $this->input_->readMessageEnd();
523 
        throw $x;
524 
      }
525 
      $result = new \TCLIService_GetTables_result();
526 
      $result->read($this->input_);
527 
      $this->input_->readMessageEnd();
528 
    }
529 
    if ($result->success !== null) {
530 
      return $result->success;
531 
    }
532 
    throw new \Exception("GetTables failed: unknown result");
533 
  }
534 
 
535 
  public function GetTableTypes(\TGetTableTypesReq $req)
536 
  {
537 
    $this->send_GetTableTypes($req);
538 
    return $this->recv_GetTableTypes();
539 
  }
540 
 
541 
  public function send_GetTableTypes(\TGetTableTypesReq $req)
542 
  {
543 
    $args = new \TCLIService_GetTableTypes_args();
544 
    $args->req = $req;
545 
    $bin_accel = ($this->output_ instanceof TBinaryProtocolAccelerated) && function_exists('thrift_protocol_write_binary');
546 
    if ($bin_accel)
547 
    {
548 
      thrift_protocol_write_binary($this->output_, 'GetTableTypes', TMessageType::CALL, $args, $this->seqid_, $this->output_->isStrictWrite());
549 
    }
550 
    else
551 
    {
552 
      $this->output_->writeMessageBegin('GetTableTypes', TMessageType::CALL, $this->seqid_);
553 
      $args->write($this->output_);
554 
      $this->output_->writeMessageEnd();
555 
      $this->output_->getTransport()->flush();
556 
    }
557 
  }
558 
 
559 
  public function recv_GetTableTypes()
560 
  {
561 
    $bin_accel = ($this->input_ instanceof TBinaryProtocolAccelerated) && function_exists('thrift_protocol_read_binary');
562 
    if ($bin_accel) $result = thrift_protocol_read_binary($this->input_, '\TCLIService_GetTableTypes_result', $this->input_->isStrictRead());
563 
    else
564 
    {
565 
      $rseqid = 0;
566 
      $fname = null;
567 
      $mtype = 0;
568 
 
569 
      $this->input_->readMessageBegin($fname, $mtype, $rseqid);
570 
      if ($mtype == TMessageType::EXCEPTION) {
571 
        $x = new TApplicationException();
572 
        $x->read($this->input_);
573 
        $this->input_->readMessageEnd();
574 
        throw $x;
575 
      }
576 
      $result = new \TCLIService_GetTableTypes_result();
577 
      $result->read($this->input_);
578 
      $this->input_->readMessageEnd();
579 
    }
580 
    if ($result->success !== null) {
581 
      return $result->success;
582 
    }
583 
    throw new \Exception("GetTableTypes failed: unknown result");
584 
  }
585 
 
586 
  public function GetColumns(\TGetColumnsReq $req)
587 
  {
588 
    $this->send_GetColumns($req);
589 
    return $this->recv_GetColumns();
590 
  }
591 
 
592 
  public function send_GetColumns(\TGetColumnsReq $req)
593 
  {
594 
    $args = new \TCLIService_GetColumns_args();
595 
    $args->req = $req;
596 
    $bin_accel = ($this->output_ instanceof TBinaryProtocolAccelerated) && function_exists('thrift_protocol_write_binary');
597 
    if ($bin_accel)
598 
    {
599 
      thrift_protocol_write_binary($this->output_, 'GetColumns', TMessageType::CALL, $args, $this->seqid_, $this->output_->isStrictWrite());
600 
    }
601 
    else
602 
    {
603 
      $this->output_->writeMessageBegin('GetColumns', TMessageType::CALL, $this->seqid_);
604 
      $args->write($this->output_);
605 
      $this->output_->writeMessageEnd();
606 
      $this->output_->getTransport()->flush();
607 
    }
608 
  }
609 
 
610 
  public function recv_GetColumns()
611 
  {
612 
    $bin_accel = ($this->input_ instanceof TBinaryProtocolAccelerated) && function_exists('thrift_protocol_read_binary');
613 
    if ($bin_accel) $result = thrift_protocol_read_binary($this->input_, '\TCLIService_GetColumns_result', $this->input_->isStrictRead());
614 
    else
615 
    {
616 
      $rseqid = 0;
617 
      $fname = null;
618 
      $mtype = 0;
619 
 
620 
      $this->input_->readMessageBegin($fname, $mtype, $rseqid);
621 
      if ($mtype == TMessageType::EXCEPTION) {
622 
        $x = new TApplicationException();
623 
        $x->read($this->input_);
624 
        $this->input_->readMessageEnd();
625 
        throw $x;
626 
      }
627 
      $result = new \TCLIService_GetColumns_result();
628 
      $result->read($this->input_);
629 
      $this->input_->readMessageEnd();
630 
    }
631 
    if ($result->success !== null) {
632 
      return $result->success;
633 
    }
634 
    throw new \Exception("GetColumns failed: unknown result");
635 
  }
636 
 
637 
  public function GetFunctions(\TGetFunctionsReq $req)
638 
  {
639 
    $this->send_GetFunctions($req);
640 
    return $this->recv_GetFunctions();
641 
  }
642 
 
643 
  public function send_GetFunctions(\TGetFunctionsReq $req)
644 
  {
645 
    $args = new \TCLIService_GetFunctions_args();
646 
    $args->req = $req;
647 
    $bin_accel = ($this->output_ instanceof TBinaryProtocolAccelerated) && function_exists('thrift_protocol_write_binary');
648 
    if ($bin_accel)
649 
    {
650 
      thrift_protocol_write_binary($this->output_, 'GetFunctions', TMessageType::CALL, $args, $this->seqid_, $this->output_->isStrictWrite());
651 
    }
652 
    else
653 
    {
654 
      $this->output_->writeMessageBegin('GetFunctions', TMessageType::CALL, $this->seqid_);
655 
      $args->write($this->output_);
656 
      $this->output_->writeMessageEnd();
657 
      $this->output_->getTransport()->flush();
658 
    }
659 
  }
660 
 
661 
  public function recv_GetFunctions()
662 
  {
663 
    $bin_accel = ($this->input_ instanceof TBinaryProtocolAccelerated) && function_exists('thrift_protocol_read_binary');
664 
    if ($bin_accel) $result = thrift_protocol_read_binary($this->input_, '\TCLIService_GetFunctions_result', $this->input_->isStrictRead());
665 
    else
666 
    {
667 
      $rseqid = 0;
668 
      $fname = null;
669 
      $mtype = 0;
670 
 
671 
      $this->input_->readMessageBegin($fname, $mtype, $rseqid);
672 
      if ($mtype == TMessageType::EXCEPTION) {
673 
        $x = new TApplicationException();
674 
        $x->read($this->input_);
675 
        $this->input_->readMessageEnd();
676 
        throw $x;
677 
      }
678 
      $result = new \TCLIService_GetFunctions_result();
679 
      $result->read($this->input_);
680 
      $this->input_->readMessageEnd();
681 
    }
682 
    if ($result->success !== null) {
683 
      return $result->success;
684 
    }
685 
    throw new \Exception("GetFunctions failed: unknown result");
686 
  }
687 
 
688 
  public function GetOperationStatus(\TGetOperationStatusReq $req)
689 
  {
690 
    $this->send_GetOperationStatus($req);
691 
    return $this->recv_GetOperationStatus();
692 
  }
693 
 
694 
  public function send_GetOperationStatus(\TGetOperationStatusReq $req)
695 
  {
696 
    $args = new \TCLIService_GetOperationStatus_args();
697 
    $args->req = $req;
698 
    $bin_accel = ($this->output_ instanceof TBinaryProtocolAccelerated) && function_exists('thrift_protocol_write_binary');
699 
    if ($bin_accel)
700 
    {
701 
      thrift_protocol_write_binary($this->output_, 'GetOperationStatus', TMessageType::CALL, $args, $this->seqid_, $this->output_->isStrictWrite());
702 
    }
703 
    else
704 
    {
705 
      $this->output_->writeMessageBegin('GetOperationStatus', TMessageType::CALL, $this->seqid_);
706 
      $args->write($this->output_);
707 
      $this->output_->writeMessageEnd();
708 
      $this->output_->getTransport()->flush();
709 
    }
710 
  }
711 
 
712 
  public function recv_GetOperationStatus()
713 
  {
714 
    $bin_accel = ($this->input_ instanceof TBinaryProtocolAccelerated) && function_exists('thrift_protocol_read_binary');
715 
    if ($bin_accel) $result = thrift_protocol_read_binary($this->input_, '\TCLIService_GetOperationStatus_result', $this->input_->isStrictRead());
716 
    else
717 
    {
718 
      $rseqid = 0;
719 
      $fname = null;
720 
      $mtype = 0;
721 
 
722 
      $this->input_->readMessageBegin($fname, $mtype, $rseqid);
723 
      if ($mtype == TMessageType::EXCEPTION) {
724 
        $x = new TApplicationException();
725 
        $x->read($this->input_);
726 
        $this->input_->readMessageEnd();
727 
        throw $x;
728 
      }
729 
      $result = new \TCLIService_GetOperationStatus_result();
730 
      $result->read($this->input_);
731 
      $this->input_->readMessageEnd();
732 
    }
733 
    if ($result->success !== null) {
734 
      return $result->success;
735 
    }
736 
    throw new \Exception("GetOperationStatus failed: unknown result");
737 
  }
738 
 
739 
  public function CancelOperation(\TCancelOperationReq $req)
740 
  {
741 
    $this->send_CancelOperation($req);
742 
    return $this->recv_CancelOperation();
743 
  }
744 
 
745 
  public function send_CancelOperation(\TCancelOperationReq $req)
746 
  {
747 
    $args = new \TCLIService_CancelOperation_args();
748 
    $args->req = $req;
749 
    $bin_accel = ($this->output_ instanceof TBinaryProtocolAccelerated) && function_exists('thrift_protocol_write_binary');
750 
    if ($bin_accel)
751 
    {
752 
      thrift_protocol_write_binary($this->output_, 'CancelOperation', TMessageType::CALL, $args, $this->seqid_, $this->output_->isStrictWrite());
753 
    }
754 
    else
755 
    {
756 
      $this->output_->writeMessageBegin('CancelOperation', TMessageType::CALL, $this->seqid_);
757 
      $args->write($this->output_);
758 
      $this->output_->writeMessageEnd();
759 
      $this->output_->getTransport()->flush();
760 
    }
761 
  }
762 
 
763 
  public function recv_CancelOperation()
764 
  {
765 
    $bin_accel = ($this->input_ instanceof TBinaryProtocolAccelerated) && function_exists('thrift_protocol_read_binary');
766 
    if ($bin_accel) $result = thrift_protocol_read_binary($this->input_, '\TCLIService_CancelOperation_result', $this->input_->isStrictRead());
767 
    else
768 
    {
769 
      $rseqid = 0;
770 
      $fname = null;
771 
      $mtype = 0;
772 
 
773 
      $this->input_->readMessageBegin($fname, $mtype, $rseqid);
774 
      if ($mtype == TMessageType::EXCEPTION) {
775 
        $x = new TApplicationException();
776 
        $x->read($this->input_);
777 
        $this->input_->readMessageEnd();
778 
        throw $x;
779 
      }
780 
      $result = new \TCLIService_CancelOperation_result();
781 
      $result->read($this->input_);
782 
      $this->input_->readMessageEnd();
783 
    }
784 
    if ($result->success !== null) {
785 
      return $result->success;
786 
    }
787 
    throw new \Exception("CancelOperation failed: unknown result");
788 
  }
789 
 
790 
  public function CloseOperation(\TCloseOperationReq $req)
791 
  {
792 
    $this->send_CloseOperation($req);
793 
    return $this->recv_CloseOperation();
794 
  }
795 
 
796 
  public function send_CloseOperation(\TCloseOperationReq $req)
797 
  {
798 
    $args = new \TCLIService_CloseOperation_args();
799 
    $args->req = $req;
800 
    $bin_accel = ($this->output_ instanceof TBinaryProtocolAccelerated) && function_exists('thrift_protocol_write_binary');
801 
    if ($bin_accel)
802 
    {
803 
      thrift_protocol_write_binary($this->output_, 'CloseOperation', TMessageType::CALL, $args, $this->seqid_, $this->output_->isStrictWrite());
804 
    }
805 
    else
806 
    {
807 
      $this->output_->writeMessageBegin('CloseOperation', TMessageType::CALL, $this->seqid_);
808 
      $args->write($this->output_);
809 
      $this->output_->writeMessageEnd();
810 
      $this->output_->getTransport()->flush();
811 
    }
812 
  }
813 
 
814 
  public function recv_CloseOperation()
815 
  {
816 
    $bin_accel = ($this->input_ instanceof TBinaryProtocolAccelerated) && function_exists('thrift_protocol_read_binary');
817 
    if ($bin_accel) $result = thrift_protocol_read_binary($this->input_, '\TCLIService_CloseOperation_result', $this->input_->isStrictRead());
818 
    else
819 
    {
820 
      $rseqid = 0;
821 
      $fname = null;
822 
      $mtype = 0;
823 
 
824 
      $this->input_->readMessageBegin($fname, $mtype, $rseqid);
825 
      if ($mtype == TMessageType::EXCEPTION) {
826 
        $x = new TApplicationException();
827 
        $x->read($this->input_);
828 
        $this->input_->readMessageEnd();
829 
        throw $x;
830 
      }
831 
      $result = new \TCLIService_CloseOperation_result();
832 
      $result->read($this->input_);
833 
      $this->input_->readMessageEnd();
834 
    }
835 
    if ($result->success !== null) {
836 
      return $result->success;
837 
    }
838 
    throw new \Exception("CloseOperation failed: unknown result");
839 
  }
840 
 
841 
  public function GetResultSetMetadata(\TGetResultSetMetadataReq $req)
842 
  {
843 
    $this->send_GetResultSetMetadata($req);
844 
    return $this->recv_GetResultSetMetadata();
845 
  }
846 
 
847 
  public function send_GetResultSetMetadata(\TGetResultSetMetadataReq $req)
848 
  {
849 
    $args = new \TCLIService_GetResultSetMetadata_args();
850 
    $args->req = $req;
851 
    $bin_accel = ($this->output_ instanceof TBinaryProtocolAccelerated) && function_exists('thrift_protocol_write_binary');
852 
    if ($bin_accel)
853 
    {
854 
      thrift_protocol_write_binary($this->output_, 'GetResultSetMetadata', TMessageType::CALL, $args, $this->seqid_, $this->output_->isStrictWrite());
855 
    }
856 
    else
857 
    {
858 
      $this->output_->writeMessageBegin('GetResultSetMetadata', TMessageType::CALL, $this->seqid_);
859 
      $args->write($this->output_);
860 
      $this->output_->writeMessageEnd();
861 
      $this->output_->getTransport()->flush();
862 
    }
863 
  }
864 
 
865 
  public function recv_GetResultSetMetadata()
866 
  {
867 
    $bin_accel = ($this->input_ instanceof TBinaryProtocolAccelerated) && function_exists('thrift_protocol_read_binary');
868 
    if ($bin_accel) $result = thrift_protocol_read_binary($this->input_, '\TCLIService_GetResultSetMetadata_result', $this->input_->isStrictRead());
869 
    else
870 
    {
871 
      $rseqid = 0;
872 
      $fname = null;
873 
      $mtype = 0;
874 
 
875 
      $this->input_->readMessageBegin($fname, $mtype, $rseqid);
876 
      if ($mtype == TMessageType::EXCEPTION) {
877 
        $x = new TApplicationException();
878 
        $x->read($this->input_);
879 
        $this->input_->readMessageEnd();
880 
        throw $x;
881 
      }
882 
      $result = new \TCLIService_GetResultSetMetadata_result();
883 
      $result->read($this->input_);
884 
      $this->input_->readMessageEnd();
885 
    }
886 
    if ($result->success !== null) {
887 
      return $result->success;
888 
    }
889 
    throw new \Exception("GetResultSetMetadata failed: unknown result");
890 
  }
891 
 
892 
  public function FetchResults(\TFetchResultsReq $req)
893 
  {
894 
    $this->send_FetchResults($req);
895 
    return $this->recv_FetchResults();
896 
  }
897 
 
898 
  public function send_FetchResults(\TFetchResultsReq $req)
899 
  {
900 
    $args = new \TCLIService_FetchResults_args();
901 
    $args->req = $req;
902 
    $bin_accel = ($this->output_ instanceof TBinaryProtocolAccelerated) && function_exists('thrift_protocol_write_binary');
903 
    if ($bin_accel)
904 
    {
905 
      thrift_protocol_write_binary($this->output_, 'FetchResults', TMessageType::CALL, $args, $this->seqid_, $this->output_->isStrictWrite());
906 
    }
907 
    else
908 
    {
909 
      $this->output_->writeMessageBegin('FetchResults', TMessageType::CALL, $this->seqid_);
910 
      $args->write($this->output_);
911 
      $this->output_->writeMessageEnd();
912 
      $this->output_->getTransport()->flush();
913 
    }
914 
  }
915 
 
916 
  public function recv_FetchResults()
917 
  {
918 
    $bin_accel = ($this->input_ instanceof TBinaryProtocolAccelerated) && function_exists('thrift_protocol_read_binary');
919 
    if ($bin_accel) $result = thrift_protocol_read_binary($this->input_, '\TCLIService_FetchResults_result', $this->input_->isStrictRead());
920 
    else
921 
    {
922 
      $rseqid = 0;
923 
      $fname = null;
924 
      $mtype = 0;
925 
 
926 
      $this->input_->readMessageBegin($fname, $mtype, $rseqid);
927 
      if ($mtype == TMessageType::EXCEPTION) {
928 
        $x = new TApplicationException();
929 
        $x->read($this->input_);
930 
        $this->input_->readMessageEnd();
931 
        throw $x;
932 
      }
933 
      $result = new \TCLIService_FetchResults_result();
934 
      $result->read($this->input_);
935 
      $this->input_->readMessageEnd();
936 
    }
937 
    if ($result->success !== null) {
938 
      return $result->success;
939 
    }
940 
    throw new \Exception("FetchResults failed: unknown result");
941 
  }
942 
 
943 
  public function GetDelegationToken(\TGetDelegationTokenReq $req)
944 
  {
945 
    $this->send_GetDelegationToken($req);
946 
    return $this->recv_GetDelegationToken();
947 
  }
948 
 
949 
  public function send_GetDelegationToken(\TGetDelegationTokenReq $req)
950 
  {
951 
    $args = new \TCLIService_GetDelegationToken_args();
952 
    $args->req = $req;
953 
    $bin_accel = ($this->output_ instanceof TBinaryProtocolAccelerated) && function_exists('thrift_protocol_write_binary');
954 
    if ($bin_accel)
955 
    {
956 
      thrift_protocol_write_binary($this->output_, 'GetDelegationToken', TMessageType::CALL, $args, $this->seqid_, $this->output_->isStrictWrite());
957 
    }
958 
    else
959 
    {
960 
      $this->output_->writeMessageBegin('GetDelegationToken', TMessageType::CALL, $this->seqid_);
961 
      $args->write($this->output_);
962 
      $this->output_->writeMessageEnd();
963 
      $this->output_->getTransport()->flush();
964 
    }
965 
  }
966 
 
967 
  public function recv_GetDelegationToken()
968 
  {
969 
    $bin_accel = ($this->input_ instanceof TBinaryProtocolAccelerated) && function_exists('thrift_protocol_read_binary');
970 
    if ($bin_accel) $result = thrift_protocol_read_binary($this->input_, '\TCLIService_GetDelegationToken_result', $this->input_->isStrictRead());
971 
    else
972 
    {
973 
      $rseqid = 0;
974 
      $fname = null;
975 
      $mtype = 0;
976 
 
977 
      $this->input_->readMessageBegin($fname, $mtype, $rseqid);
978 
      if ($mtype == TMessageType::EXCEPTION) {
979 
        $x = new TApplicationException();
980 
        $x->read($this->input_);
981 
        $this->input_->readMessageEnd();
982 
        throw $x;
983 
      }
984 
      $result = new \TCLIService_GetDelegationToken_result();
985 
      $result->read($this->input_);
986 
      $this->input_->readMessageEnd();
987 
    }
988 
    if ($result->success !== null) {
989 
      return $result->success;
990 
    }
991 
    throw new \Exception("GetDelegationToken failed: unknown result");
992 
  }
993 
 
994 
  public function CancelDelegationToken(\TCancelDelegationTokenReq $req)
995 
  {
996 
    $this->send_CancelDelegationToken($req);
997 
    return $this->recv_CancelDelegationToken();
998 
  }
999 
 
1000 
  public function send_CancelDelegationToken(\TCancelDelegationTokenReq $req)
1001 
  {
1002 
    $args = new \TCLIService_CancelDelegationToken_args();
1003 
    $args->req = $req;
1004 
    $bin_accel = ($this->output_ instanceof TBinaryProtocolAccelerated) && function_exists('thrift_protocol_write_binary');
1005 
    if ($bin_accel)
1006 
    {
1007 
      thrift_protocol_write_binary($this->output_, 'CancelDelegationToken', TMessageType::CALL, $args, $this->seqid_, $this->output_->isStrictWrite());
1008 
    }
1009 
    else
1010 
    {
1011 
      $this->output_->writeMessageBegin('CancelDelegationToken', TMessageType::CALL, $this->seqid_);
1012 
      $args->write($this->output_);
1013 
      $this->output_->writeMessageEnd();
1014 
      $this->output_->getTransport()->flush();
1015 
    }
1016 
  }
1017 
 
1018 
  public function recv_CancelDelegationToken()
1019 
  {
1020 
    $bin_accel = ($this->input_ instanceof TBinaryProtocolAccelerated) && function_exists('thrift_protocol_read_binary');
1021 
    if ($bin_accel) $result = thrift_protocol_read_binary($this->input_, '\TCLIService_CancelDelegationToken_result', $this->input_->isStrictRead());
1022 
    else
1023 
    {
1024 
      $rseqid = 0;
1025 
      $fname = null;
1026 
      $mtype = 0;
1027 
 
1028 
      $this->input_->readMessageBegin($fname, $mtype, $rseqid);
1029 
      if ($mtype == TMessageType::EXCEPTION) {
1030 
        $x = new TApplicationException();
1031 
        $x->read($this->input_);
1032 
        $this->input_->readMessageEnd();
1033 
        throw $x;
1034 
      }
1035 
      $result = new \TCLIService_CancelDelegationToken_result();
1036 
      $result->read($this->input_);
1037 
      $this->input_->readMessageEnd();
1038 
    }
1039 
    if ($result->success !== null) {
1040 
      return $result->success;
1041 
    }
1042 
    throw new \Exception("CancelDelegationToken failed: unknown result");
1043 
  }
1044 
 
1045 
  public function RenewDelegationToken(\TRenewDelegationTokenReq $req)
1046 
  {
1047 
    $this->send_RenewDelegationToken($req);
1048 
    return $this->recv_RenewDelegationToken();
1049 
  }
1050 
 
1051 
  public function send_RenewDelegationToken(\TRenewDelegationTokenReq $req)
1052 
  {
1053 
    $args = new \TCLIService_RenewDelegationToken_args();
1054 
    $args->req = $req;
1055 
    $bin_accel = ($this->output_ instanceof TBinaryProtocolAccelerated) && function_exists('thrift_protocol_write_binary');
1056 
    if ($bin_accel)
1057 
    {
1058 
      thrift_protocol_write_binary($this->output_, 'RenewDelegationToken', TMessageType::CALL, $args, $this->seqid_, $this->output_->isStrictWrite());
1059 
    }
1060 
    else
1061 
    {
1062 
      $this->output_->writeMessageBegin('RenewDelegationToken', TMessageType::CALL, $this->seqid_);
1063 
      $args->write($this->output_);
1064 
      $this->output_->writeMessageEnd();
1065 
      $this->output_->getTransport()->flush();
1066 
    }
1067 
  }
1068 
 
1069 
  public function recv_RenewDelegationToken()
1070 
  {
1071 
    $bin_accel = ($this->input_ instanceof TBinaryProtocolAccelerated) && function_exists('thrift_protocol_read_binary');
1072 
    if ($bin_accel) $result = thrift_protocol_read_binary($this->input_, '\TCLIService_RenewDelegationToken_result', $this->input_->isStrictRead());
1073 
    else
1074 
    {
1075 
      $rseqid = 0;
1076 
      $fname = null;
1077 
      $mtype = 0;
1078 
 
1079 
      $this->input_->readMessageBegin($fname, $mtype, $rseqid);
1080 
      if ($mtype == TMessageType::EXCEPTION) {
1081 
        $x = new TApplicationException();
1082 
        $x->read($this->input_);
1083 
        $this->input_->readMessageEnd();
1084 
        throw $x;
1085 
      }
1086 
      $result = new \TCLIService_RenewDelegationToken_result();
1087 
      $result->read($this->input_);
1088 
      $this->input_->readMessageEnd();
1089 
    }
1090 
    if ($result->success !== null) {
1091 
      return $result->success;
1092 
    }
1093 
    throw new \Exception("RenewDelegationToken failed: unknown result");
1094 
  }
1095 
 
1096 
}
1097 
 
1098 
// HELPER FUNCTIONS AND STRUCTURES
1099 
 
1100 
class TCLIService_OpenSession_args {
1101 
  static $_TSPEC;
1102 
 
1103 
  /**
1104 
   * @var \TOpenSessionReq
1105 
   */
1106 
  public $req = null;
1107 
 
1108 
  public function __construct($vals=null) {
1109 
    if (!isset(self::$_TSPEC)) {
1110 
      self::$_TSPEC = array(
1111 
        1 => array(
1112 
          'var' => 'req',
1113 
          'type' => TType::STRUCT,
1114 
          'class' => '\TOpenSessionReq',
1115 
          ),
1116 
        );
1117 
    }
1118 
    if (is_array($vals)) {
1119 
      if (isset($vals['req'])) {
1120 
        $this->req = $vals['req'];
1121 
      }
1122 
    }
1123 
  }
1124 
 
1125 
  public function getName() {
1126 
    return 'TCLIService_OpenSession_args';
1127 
  }
1128 
 
1129 
  public function read($input)
1130 
  {
1131 
    $xfer = 0;
1132 
    $fname = null;
1133 
    $ftype = 0;
1134 
    $fid = 0;
1135 
    $xfer += $input->readStructBegin($fname);
1136 
    while (true)
1137 
    {
1138 
      $xfer += $input->readFieldBegin($fname, $ftype, $fid);
1139 
      if ($ftype == TType::STOP) {
1140 
        break;
1141 
      }
1142 
      switch ($fid)
1143 
      {
1144 
        case 1:
1145 
          if ($ftype == TType::STRUCT) {
1146 
            $this->req = new \TOpenSessionReq();
1147 
            $xfer += $this->req->read($input);
1148 
          } else {
1149 
            $xfer += $input->skip($ftype);
1150 
          }
1151 
          break;
1152 
        default:
1153 
          $xfer += $input->skip($ftype);
1154 
          break;
1155 
      }
1156 
      $xfer += $input->readFieldEnd();
1157 
    }
1158 
    $xfer += $input->readStructEnd();
1159 
    return $xfer;
1160 
  }
1161 
 
1162 
  public function write($output) {
1163 
    $xfer = 0;
1164 
    $xfer += $output->writeStructBegin('TCLIService_OpenSession_args');
1165 
    if ($this->req !== null) {
1166 
      if (!is_object($this->req)) {
1167 
        throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
1168 
      }
1169 
      $xfer += $output->writeFieldBegin('req', TType::STRUCT, 1);
1170 
      $xfer += $this->req->write($output);
1171 
      $xfer += $output->writeFieldEnd();
1172 
    }
1173 
    $xfer += $output->writeFieldStop();
1174 
    $xfer += $output->writeStructEnd();
1175 
    return $xfer;
1176 
  }
1177 
 
1178 
}
1179 
 
1180 
class TCLIService_OpenSession_result {
1181 
  static $_TSPEC;
1182 
 
1183 
  /**
1184 
   * @var \TOpenSessionResp
1185 
   */
1186 
  public $success = null;
1187 
 
1188 
  public function __construct($vals=null) {
1189 
    if (!isset(self::$_TSPEC)) {
1190 
      self::$_TSPEC = array(
1191 
 
1192 
          'var' => 'success',
1193 
          'type' => TType::STRUCT,
1194 
          'class' => '\TOpenSessionResp',
1195 
          ),
1196 
        );
1197 
    }
1198 
    if (is_array($vals)) {
1199 
      if (isset($vals['success'])) {
1200 
        $this->success = $vals['success'];
1201 
      }
1202 
    }
1203 
  }
1204 
 
1205 
  public function getName() {
1206 
    return 'TCLIService_OpenSession_result';
1207 
  }
1208 
 
1209 
  public function read($input)
1210 
  {
1211 
    $xfer = 0;
1212 
    $fname = null;
1213 
    $ftype = 0;
1214 
    $fid = 0;
1215 
    $xfer += $input->readStructBegin($fname);
1216 
    while (true)
1217 
    {
1218 
      $xfer += $input->readFieldBegin($fname, $ftype, $fid);
1219 
      if ($ftype == TType::STOP) {
1220 
        break;
1221 
      }
1222 
      switch ($fid)
1223 
      {
1224 
        case 0:
1225 
          if ($ftype == TType::STRUCT) {
1226 
            $this->success = new \TOpenSessionResp();
1227 
            $xfer += $this->success->read($input);
1228 
          } else {
1229 
            $xfer += $input->skip($ftype);
1230 
          }
1231 
          break;
1232 
        default:
1233 
          $xfer += $input->skip($ftype);
1234 
          break;
1235 
      }
1236 
      $xfer += $input->readFieldEnd();
1237 
    }
1238 
    $xfer += $input->readStructEnd();
1239 
    return $xfer;
1240 
  }
1241 
 
1242 
  public function write($output) {
1243 
    $xfer = 0;
1244 
    $xfer += $output->writeStructBegin('TCLIService_OpenSession_result');
1245 
    if ($this->success !== null) {
1246 
      if (!is_object($this->success)) {
1247 
        throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
1248 
      }
1249 
      $xfer += $output->writeFieldBegin('success', TType::STRUCT, 0);
1250 
      $xfer += $this->success->write($output);
1251 
      $xfer += $output->writeFieldEnd();
1252 
    }
1253 
    $xfer += $output->writeFieldStop();
1254 
    $xfer += $output->writeStructEnd();
1255 
    return $xfer;
1256 
  }
1257 
 
1258 
}
1259 
 
1260 
class TCLIService_CloseSession_args {
1261 
  static $_TSPEC;
1262 
 
1263 
  /**
1264 
   * @var \TCloseSessionReq
1265 
   */
1266 
  public $req = null;
1267 
 
1268 
  public function __construct($vals=null) {
1269 
    if (!isset(self::$_TSPEC)) {
1270 
      self::$_TSPEC = array(
1271 
        1 => array(
1272 
          'var' => 'req',
1273 
          'type' => TType::STRUCT,
1274 
          'class' => '\TCloseSessionReq',
1275 
          ),
1276 
        );
1277 
    }
1278 
    if (is_array($vals)) {
1279 
      if (isset($vals['req'])) {
1280 
        $this->req = $vals['req'];
1281 
      }
1282 
    }
1283 
  }
1284 
 
1285 
  public function getName() {
1286 
    return 'TCLIService_CloseSession_args';
1287 
  }
1288 
 
1289 
  public function read($input)
1290 
  {
1291 
    $xfer = 0;
1292 
    $fname = null;
1293 
    $ftype = 0;
1294 
    $fid = 0;
1295 
    $xfer += $input->readStructBegin($fname);
1296 
    while (true)
1297 
    {
1298 
      $xfer += $input->readFieldBegin($fname, $ftype, $fid);
1299 
      if ($ftype == TType::STOP) {
1300 
        break;
1301 
      }
1302 
      switch ($fid)
1303 
      {
1304 
        case 1:
1305 
          if ($ftype == TType::STRUCT) {
1306 
            $this->req = new \TCloseSessionReq();
1307 
            $xfer += $this->req->read($input);
1308 
          } else {
1309 
            $xfer += $input->skip($ftype);
1310 
          }
1311 
          break;
1312 
        default:
1313 
          $xfer += $input->skip($ftype);
1314 
          break;
1315 
      }
1316 
      $xfer += $input->readFieldEnd();
1317 
    }
1318 
    $xfer += $input->readStructEnd();
1319 
    return $xfer;
1320 
  }
1321 
 
1322 
  public function write($output) {
1323 
    $xfer = 0;
1324 
    $xfer += $output->writeStructBegin('TCLIService_CloseSession_args');
1325 
    if ($this->req !== null) {
1326 
      if (!is_object($this->req)) {
1327 
        throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
1328 
      }
1329 
      $xfer += $output->writeFieldBegin('req', TType::STRUCT, 1);
1330 
      $xfer += $this->req->write($output);
1331 
      $xfer += $output->writeFieldEnd();
1332 
    }
1333 
    $xfer += $output->writeFieldStop();
1334 
    $xfer += $output->writeStructEnd();
1335 
    return $xfer;
1336 
  }
1337 
 
1338 
}
1339 
 
1340 
class TCLIService_CloseSession_result {
1341 
  static $_TSPEC;
1342 
 
1343 
  /**
1344 
   * @var \TCloseSessionResp
1345 
   */
1346 
  public $success = null;
1347 
 
1348 
  public function __construct($vals=null) {
1349 
    if (!isset(self::$_TSPEC)) {
1350 
      self::$_TSPEC = array(
1351 
 
1352 
          'var' => 'success',
1353 
          'type' => TType::STRUCT,
1354 
          'class' => '\TCloseSessionResp',
1355 
          ),
1356 
        );
1357 
    }
1358 
    if (is_array($vals)) {
1359 
      if (isset($vals['success'])) {
1360 
        $this->success = $vals['success'];
1361 
      }
1362 
    }
1363 
  }
1364 
 
1365 
  public function getName() {
1366 
    return 'TCLIService_CloseSession_result';
1367 
  }
1368 
 
1369 
  public function read($input)
1370 
  {
1371 
    $xfer = 0;
1372 
    $fname = null;
1373 
    $ftype = 0;
1374 
    $fid = 0;
1375 
    $xfer += $input->readStructBegin($fname);
1376 
    while (true)
1377 
    {
1378 
      $xfer += $input->readFieldBegin($fname, $ftype, $fid);
1379 
      if ($ftype == TType::STOP) {
1380 
        break;
1381 
      }
1382 
      switch ($fid)
1383 
      {
1384 
        case 0:
1385 
          if ($ftype == TType::STRUCT) {
1386 
            $this->success = new \TCloseSessionResp();
1387 
            $xfer += $this->success->read($input);
1388 
          } else {
1389 
            $xfer += $input->skip($ftype);
1390 
          }
1391 
          break;
1392 
        default:
1393 
          $xfer += $input->skip($ftype);
1394 
          break;
1395 
      }
1396 
      $xfer += $input->readFieldEnd();
1397 
    }
1398 
    $xfer += $input->readStructEnd();
1399 
    return $xfer;
1400 
  }
1401 
 
1402 
  public function write($output) {
1403 
    $xfer = 0;
1404 
    $xfer += $output->writeStructBegin('TCLIService_CloseSession_result');
1405 
    if ($this->success !== null) {
1406 
      if (!is_object($this->success)) {
1407 
        throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
1408 
      }
1409 
      $xfer += $output->writeFieldBegin('success', TType::STRUCT, 0);
1410 
      $xfer += $this->success->write($output);
1411 
      $xfer += $output->writeFieldEnd();
1412 
    }
1413 
    $xfer += $output->writeFieldStop();
1414 
    $xfer += $output->writeStructEnd();
1415 
    return $xfer;
1416 
  }
1417 
 
1418 
}
1419 
 
1420 
class TCLIService_GetInfo_args {
1421 
  static $_TSPEC;
1422 
 
1423 
  /**
1424 
   * @var \TGetInfoReq
1425 
   */
1426 
  public $req = null;
1427 
 
1428 
  public function __construct($vals=null) {
1429 
    if (!isset(self::$_TSPEC)) {
1430 
      self::$_TSPEC = array(
1431 
        1 => array(
1432 
          'var' => 'req',
1433 
          'type' => TType::STRUCT,
1434 
          'class' => '\TGetInfoReq',
1435 
          ),
1436 
        );
1437 
    }
1438 
    if (is_array($vals)) {
1439 
      if (isset($vals['req'])) {
1440 
        $this->req = $vals['req'];
1441 
      }
1442 
    }
1443 
  }
1444 
 
1445 
  public function getName() {
1446 
    return 'TCLIService_GetInfo_args';
1447 
  }
1448 
 
1449 
  public function read($input)
1450 
  {
1451 
    $xfer = 0;
1452 
    $fname = null;
1453 
    $ftype = 0;
1454 
    $fid = 0;
1455 
    $xfer += $input->readStructBegin($fname);
1456 
    while (true)
1457 
    {
1458 
      $xfer += $input->readFieldBegin($fname, $ftype, $fid);
1459 
      if ($ftype == TType::STOP) {
1460 
        break;
1461 
      }
1462 
      switch ($fid)
1463 
      {
1464 
        case 1:
1465 
          if ($ftype == TType::STRUCT) {
1466 
            $this->req = new \TGetInfoReq();
1467 
            $xfer += $this->req->read($input);
1468 
          } else {
1469 
            $xfer += $input->skip($ftype);
1470 
          }
1471 
          break;
1472 
        default:
1473 
          $xfer += $input->skip($ftype);
1474 
          break;
1475 
      }
1476 
      $xfer += $input->readFieldEnd();
1477 
    }
1478 
    $xfer += $input->readStructEnd();
1479 
    return $xfer;
1480 
  }
1481 
 
1482 
  public function write($output) {
1483 
    $xfer = 0;
1484 
    $xfer += $output->writeStructBegin('TCLIService_GetInfo_args');
1485 
    if ($this->req !== null) {
1486 
      if (!is_object($this->req)) {
1487 
        throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
1488 
      }
1489 
      $xfer += $output->writeFieldBegin('req', TType::STRUCT, 1);
1490 
      $xfer += $this->req->write($output);
1491 
      $xfer += $output->writeFieldEnd();
1492 
    }
1493 
    $xfer += $output->writeFieldStop();
1494 
    $xfer += $output->writeStructEnd();
1495 
    return $xfer;
1496 
  }
1497 
 
1498 
}
1499 
 
1500 
class TCLIService_GetInfo_result {
1501 
  static $_TSPEC;
1502 
 
1503 
  /**
1504 
   * @var \TGetInfoResp
1505 
   */
1506 
  public $success = null;
1507 
 
1508 
  public function __construct($vals=null) {
1509 
    if (!isset(self::$_TSPEC)) {
1510 
      self::$_TSPEC = array(
1511 
 
1512 
          'var' => 'success',
1513 
          'type' => TType::STRUCT,
1514 
          'class' => '\TGetInfoResp',
1515 
          ),
1516 
        );
1517 
    }
1518 
    if (is_array($vals)) {
1519 
      if (isset($vals['success'])) {
1520 
        $this->success = $vals['success'];
1521 
      }
1522 
    }
1523 
  }
1524 
 
1525 
  public function getName() {
1526 
    return 'TCLIService_GetInfo_result';
1527 
  }
1528 
 
1529 
  public function read($input)
1530 
  {
1531 
    $xfer = 0;
1532 
    $fname = null;
1533 
    $ftype = 0;
1534 
    $fid = 0;
1535 
    $xfer += $input->readStructBegin($fname);
1536 
    while (true)
1537 
    {
1538 
      $xfer += $input->readFieldBegin($fname, $ftype, $fid);
1539 
      if ($ftype == TType::STOP) {
1540 
        break;
1541 
      }
1542 
      switch ($fid)
1543 
      {
1544 
        case 0:
1545 
          if ($ftype == TType::STRUCT) {
1546 
            $this->success = new \TGetInfoResp();
1547 
            $xfer += $this->success->read($input);
1548 
          } else {
1549 
            $xfer += $input->skip($ftype);
1550 
          }
1551 
          break;
1552 
        default:
1553 
          $xfer += $input->skip($ftype);
1554 
          break;
1555 
      }
1556 
      $xfer += $input->readFieldEnd();
1557 
    }
1558 
    $xfer += $input->readStructEnd();
1559 
    return $xfer;
1560 
  }
1561 
 
1562 
  public function write($output) {
1563 
    $xfer = 0;
1564 
    $xfer += $output->writeStructBegin('TCLIService_GetInfo_result');
1565 
    if ($this->success !== null) {
1566 
      if (!is_object($this->success)) {
1567 
        throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
1568 
      }
1569 
      $xfer += $output->writeFieldBegin('success', TType::STRUCT, 0);
1570 
      $xfer += $this->success->write($output);
1571 
      $xfer += $output->writeFieldEnd();
1572 
    }
1573 
    $xfer += $output->writeFieldStop();
1574 
    $xfer += $output->writeStructEnd();
1575 
    return $xfer;
1576 
  }
1577 
 
1578 
}
1579 
 
1580 
class TCLIService_ExecuteStatement_args {
1581 
  static $_TSPEC;
1582 
 
1583 
  /**
1584 
   * @var \TExecuteStatementReq
1585 
   */
1586 
  public $req = null;
1587 
 
1588 
  public function __construct($vals=null) {
1589 
    if (!isset(self::$_TSPEC)) {
1590 
      self::$_TSPEC = array(
1591 
        1 => array(
1592 
          'var' => 'req',
1593 
          'type' => TType::STRUCT,
1594 
          'class' => '\TExecuteStatementReq',
1595 
          ),
1596 
        );
1597 
    }
1598 
    if (is_array($vals)) {
1599 
      if (isset($vals['req'])) {
1600 
        $this->req = $vals['req'];
1601 
      }
1602 
    }
1603 
  }
1604 
 
1605 
  public function getName() {
1606 
    return 'TCLIService_ExecuteStatement_args';
1607 
  }
1608 
 
1609 
  public function read($input)
1610 
  {
1611 
    $xfer = 0;
1612 
    $fname = null;
1613 
    $ftype = 0;
1614 
    $fid = 0;
1615 
    $xfer += $input->readStructBegin($fname);
1616 
    while (true)
1617 
    {
1618 
      $xfer += $input->readFieldBegin($fname, $ftype, $fid);
1619 
      if ($ftype == TType::STOP) {
1620 
        break;
1621 
      }
1622 
      switch ($fid)
1623 
      {
1624 
        case 1:
1625 
          if ($ftype == TType::STRUCT) {
1626 
            $this->req = new \TExecuteStatementReq();
1627 
            $xfer += $this->req->read($input);
1628 
          } else {
1629 
            $xfer += $input->skip($ftype);
1630 
          }
1631 
          break;
1632 
        default:
1633 
          $xfer += $input->skip($ftype);
1634 
          break;
1635 
      }
1636 
      $xfer += $input->readFieldEnd();
1637 
    }
1638 
    $xfer += $input->readStructEnd();
1639 
    return $xfer;
1640 
  }
1641 
 
1642 
  public function write($output) {
1643 
    $xfer = 0;
1644 
    $xfer += $output->writeStructBegin('TCLIService_ExecuteStatement_args');
1645 
    if ($this->req !== null) {
1646 
      if (!is_object($this->req)) {
1647 
        throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
1648 
      }
1649 
      $xfer += $output->writeFieldBegin('req', TType::STRUCT, 1);
1650 
      $xfer += $this->req->write($output);
1651 
      $xfer += $output->writeFieldEnd();
1652 
    }
1653 
    $xfer += $output->writeFieldStop();
1654 
    $xfer += $output->writeStructEnd();
1655 
    return $xfer;
1656 
  }
1657 
 
1658 
}
1659 
 
1660 
class TCLIService_ExecuteStatement_result {
1661 
  static $_TSPEC;
1662 
 
1663 
  /**
1664 
   * @var \TExecuteStatementResp
1665 
   */
1666 
  public $success = null;
1667 
 
1668 
  public function __construct($vals=null) {
1669 
    if (!isset(self::$_TSPEC)) {
1670 
      self::$_TSPEC = array(
1671 
 
1672 
          'var' => 'success',
1673 
          'type' => TType::STRUCT,
1674 
          'class' => '\TExecuteStatementResp',
1675 
          ),
1676 
        );
1677 
    }
1678 
    if (is_array($vals)) {
1679 
      if (isset($vals['success'])) {
1680 
        $this->success = $vals['success'];
1681 
      }
1682 
    }
1683 
  }
1684 
 
1685 
  public function getName() {
1686 
    return 'TCLIService_ExecuteStatement_result';
1687 
  }
1688 
 
1689 
  public function read($input)
1690 
  {
1691 
    $xfer = 0;
1692 
    $fname = null;
1693 
    $ftype = 0;
1694 
    $fid = 0;
1695 
    $xfer += $input->readStructBegin($fname);
1696 
    while (true)
1697 
    {
1698 
      $xfer += $input->readFieldBegin($fname, $ftype, $fid);
1699 
      if ($ftype == TType::STOP) {
1700 
        break;
1701 
      }
1702 
      switch ($fid)
1703 
      {
1704 
        case 0:
1705 
          if ($ftype == TType::STRUCT) {
1706 
            $this->success = new \TExecuteStatementResp();
1707 
            $xfer += $this->success->read($input);
1708 
          } else {
1709 
            $xfer += $input->skip($ftype);
1710 
          }
1711 
          break;
1712 
        default:
1713 
          $xfer += $input->skip($ftype);
1714 
          break;
1715 
      }
1716 
      $xfer += $input->readFieldEnd();
1717 
    }
1718 
    $xfer += $input->readStructEnd();
1719 
    return $xfer;
1720 
  }
1721 
 
1722 
  public function write($output) {
1723 
    $xfer = 0;
1724 
    $xfer += $output->writeStructBegin('TCLIService_ExecuteStatement_result');
1725 
    if ($this->success !== null) {
1726 
      if (!is_object($this->success)) {
1727 
        throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
1728 
      }
1729 
      $xfer += $output->writeFieldBegin('success', TType::STRUCT, 0);
1730 
      $xfer += $this->success->write($output);
1731 
      $xfer += $output->writeFieldEnd();
1732 
    }
1733 
    $xfer += $output->writeFieldStop();
1734 
    $xfer += $output->writeStructEnd();
1735 
    return $xfer;
1736 
  }
1737 
 
1738 
}
1739 
 
1740 
class TCLIService_GetTypeInfo_args {
1741 
  static $_TSPEC;
1742 
 
1743 
  /**
1744 
   * @var \TGetTypeInfoReq
1745 
   */
1746 
  public $req = null;
1747 
 
1748 
  public function __construct($vals=null) {
1749 
    if (!isset(self::$_TSPEC)) {
1750 
      self::$_TSPEC = array(
1751 
        1 => array(
1752 
          'var' => 'req',
1753 
          'type' => TType::STRUCT,
1754 
          'class' => '\TGetTypeInfoReq',
1755 
          ),
1756 
        );
1757 
    }
1758 
    if (is_array($vals)) {
1759 
      if (isset($vals['req'])) {
1760 
        $this->req = $vals['req'];
1761 
      }
1762 
    }
1763 
  }
1764 
 
1765 
  public function getName() {
1766 
    return 'TCLIService_GetTypeInfo_args';
1767 
  }
1768 
 
1769 
  public function read($input)
1770 
  {
1771 
    $xfer = 0;
1772 
    $fname = null;
1773 
    $ftype = 0;
1774 
    $fid = 0;
1775 
    $xfer += $input->readStructBegin($fname);
1776 
    while (true)
1777 
    {
1778 
      $xfer += $input->readFieldBegin($fname, $ftype, $fid);
1779 
      if ($ftype == TType::STOP) {
1780 
        break;
1781 
      }
1782 
      switch ($fid)
1783 
      {
1784 
        case 1:
1785 
          if ($ftype == TType::STRUCT) {
1786 
            $this->req = new \TGetTypeInfoReq();
1787 
            $xfer += $this->req->read($input);
1788 
          } else {
1789 
            $xfer += $input->skip($ftype);
1790 
          }
1791 
          break;
1792 
        default:
1793 
          $xfer += $input->skip($ftype);
1794 
          break;
1795 
      }
1796 
      $xfer += $input->readFieldEnd();
1797 
    }
1798 
    $xfer += $input->readStructEnd();
1799 
    return $xfer;
1800 
  }
1801 
 
1802 
  public function write($output) {
1803 
    $xfer = 0;
1804 
    $xfer += $output->writeStructBegin('TCLIService_GetTypeInfo_args');
1805 
    if ($this->req !== null) {
1806 
      if (!is_object($this->req)) {
1807 
        throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
1808 
      }
1809 
      $xfer += $output->writeFieldBegin('req', TType::STRUCT, 1);
1810 
      $xfer += $this->req->write($output);
1811 
      $xfer += $output->writeFieldEnd();
1812 
    }
1813 
    $xfer += $output->writeFieldStop();
1814 
    $xfer += $output->writeStructEnd();
1815 
    return $xfer;
1816 
  }
1817 
 
1818 
}
1819 
 
1820 
class TCLIService_GetTypeInfo_result {
1821 
  static $_TSPEC;
1822 
 
1823 
  /**
1824 
   * @var \TGetTypeInfoResp
1825 
   */
1826 
  public $success = null;
1827 
 
1828 
  public function __construct($vals=null) {
1829 
    if (!isset(self::$_TSPEC)) {
1830 
      self::$_TSPEC = array(
1831 
 
1832 
          'var' => 'success',
1833 
          'type' => TType::STRUCT,
1834 
          'class' => '\TGetTypeInfoResp',
1835 
          ),
1836 
        );
1837 
    }
1838 
    if (is_array($vals)) {
1839 
      if (isset($vals['success'])) {
1840 
        $this->success = $vals['success'];
1841 
      }
1842 
    }
1843 
  }
1844 
 
1845 
  public function getName() {
1846 
    return 'TCLIService_GetTypeInfo_result';
1847 
  }
1848 
 
1849 
  public function read($input)
1850 
  {
1851 
    $xfer = 0;
1852 
    $fname = null;
1853 
    $ftype = 0;
1854 
    $fid = 0;
1855 
    $xfer += $input->readStructBegin($fname);
1856 
    while (true)
1857 
    {
1858 
      $xfer += $input->readFieldBegin($fname, $ftype, $fid);
1859 
      if ($ftype == TType::STOP) {
1860 
        break;
1861 
      }
1862 
      switch ($fid)
1863 
      {
1864 
        case 0:
1865 
          if ($ftype == TType::STRUCT) {
1866 
            $this->success = new \TGetTypeInfoResp();
1867 
            $xfer += $this->success->read($input);
1868 
          } else {
1869 
            $xfer += $input->skip($ftype);
1870 
          }
1871 
          break;
1872 
        default:
1873 
          $xfer += $input->skip($ftype);
1874 
          break;
1875 
      }
1876 
      $xfer += $input->readFieldEnd();
1877 
    }
1878 
    $xfer += $input->readStructEnd();
1879 
    return $xfer;
1880 
  }
1881 
 
1882 
  public function write($output) {
1883 
    $xfer = 0;
1884 
    $xfer += $output->writeStructBegin('TCLIService_GetTypeInfo_result');
1885 
    if ($this->success !== null) {
1886 
      if (!is_object($this->success)) {
1887 
        throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
1888 
      }
1889 
      $xfer += $output->writeFieldBegin('success', TType::STRUCT, 0);
1890 
      $xfer += $this->success->write($output);
1891 
      $xfer += $output->writeFieldEnd();
1892 
    }
1893 
    $xfer += $output->writeFieldStop();
1894 
    $xfer += $output->writeStructEnd();
1895 
    return $xfer;
1896 
  }
1897 
 
1898 
}
1899 
 
1900 
class TCLIService_GetCatalogs_args {
1901 
  static $_TSPEC;
1902 
 
1903 
  /**
1904 
   * @var \TGetCatalogsReq
1905 
   */
1906 
  public $req = null;
1907 
 
1908 
  public function __construct($vals=null) {
1909 
    if (!isset(self::$_TSPEC)) {
1910 
      self::$_TSPEC = array(
1911 
        1 => array(
1912 
          'var' => 'req',
1913 
          'type' => TType::STRUCT,
1914 
          'class' => '\TGetCatalogsReq',
1915 
          ),
1916 
        );
1917 
    }
1918 
    if (is_array($vals)) {
1919 
      if (isset($vals['req'])) {
1920 
        $this->req = $vals['req'];
1921 
      }
1922 
    }
1923 
  }
1924 
 
1925 
  public function getName() {
1926 
    return 'TCLIService_GetCatalogs_args';
1927 
  }
1928 
 
1929 
  public function read($input)
1930 
  {
1931 
    $xfer = 0;
1932 
    $fname = null;
1933 
    $ftype = 0;
1934 
    $fid = 0;
1935 
    $xfer += $input->readStructBegin($fname);
1936 
    while (true)
1937 
    {
1938 
      $xfer += $input->readFieldBegin($fname, $ftype, $fid);
1939 
      if ($ftype == TType::STOP) {
1940 
        break;
1941 
      }
1942 
      switch ($fid)
1943 
      {
1944 
        case 1:
1945 
          if ($ftype == TType::STRUCT) {
1946 
            $this->req = new \TGetCatalogsReq();
1947 
            $xfer += $this->req->read($input);
1948 
          } else {
1949 
            $xfer += $input->skip($ftype);
1950 
          }
1951 
          break;
1952 
        default:
1953 
          $xfer += $input->skip($ftype);
1954 
          break;
1955 
      }
1956 
      $xfer += $input->readFieldEnd();
1957 
    }
1958 
    $xfer += $input->readStructEnd();
1959 
    return $xfer;
1960 
  }
1961 
 
1962 
  public function write($output) {
1963 
    $xfer = 0;
1964 
    $xfer += $output->writeStructBegin('TCLIService_GetCatalogs_args');
1965 
    if ($this->req !== null) {
1966 
      if (!is_object($this->req)) {
1967 
        throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
1968 
      }
1969 
      $xfer += $output->writeFieldBegin('req', TType::STRUCT, 1);
1970 
      $xfer += $this->req->write($output);
1971 
      $xfer += $output->writeFieldEnd();
1972 
    }
1973 
    $xfer += $output->writeFieldStop();
1974 
    $xfer += $output->writeStructEnd();
1975 
    return $xfer;
1976 
  }
1977 
 
1978 
}
1979 
 
1980 
class TCLIService_GetCatalogs_result {
1981 
  static $_TSPEC;
1982 
 
1983 
  /**
1984 
   * @var \TGetCatalogsResp
1985 
   */
1986 
  public $success = null;
1987 
 
1988 
  public function __construct($vals=null) {
1989 
    if (!isset(self::$_TSPEC)) {
1990 
      self::$_TSPEC = array(
1991 
 
1992 
          'var' => 'success',
1993 
          'type' => TType::STRUCT,
1994 
          'class' => '\TGetCatalogsResp',
1995 
          ),
1996 
        );
1997 
    }
1998 
    if (is_array($vals)) {
1999 
      if (isset($vals['success'])) {
2000 
        $this->success = $vals['success'];
2001 
      }
2002 
    }
2003 
  }
2004 
 
2005 
  public function getName() {
2006 
    return 'TCLIService_GetCatalogs_result';
2007 
  }
2008 
 
2009 
  public function read($input)
2010 
  {
2011 
    $xfer = 0;
2012 
    $fname = null;
2013 
    $ftype = 0;
2014 
    $fid = 0;
2015 
    $xfer += $input->readStructBegin($fname);
2016 
    while (true)
2017 
    {
2018 
      $xfer += $input->readFieldBegin($fname, $ftype, $fid);
2019 
      if ($ftype == TType::STOP) {
2020 
        break;
2021 
      }
2022 
      switch ($fid)
2023 
      {
2024 
        case 0:
2025 
          if ($ftype == TType::STRUCT) {
2026 
            $this->success = new \TGetCatalogsResp();
2027 
            $xfer += $this->success->read($input);
2028 
          } else {
2029 
            $xfer += $input->skip($ftype);
2030 
          }
2031 
          break;
2032 
        default:
2033 
          $xfer += $input->skip($ftype);
2034 
          break;
2035 
      }
2036 
      $xfer += $input->readFieldEnd();
2037 
    }
2038 
    $xfer += $input->readStructEnd();
2039 
    return $xfer;
2040 
  }
2041 
 
2042 
  public function write($output) {
2043 
    $xfer = 0;
2044 
    $xfer += $output->writeStructBegin('TCLIService_GetCatalogs_result');
2045 
    if ($this->success !== null) {
2046 
      if (!is_object($this->success)) {
2047 
        throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
2048 
      }
2049 
      $xfer += $output->writeFieldBegin('success', TType::STRUCT, 0);
2050 
      $xfer += $this->success->write($output);
2051 
      $xfer += $output->writeFieldEnd();
2052 
    }
2053 
    $xfer += $output->writeFieldStop();
2054 
    $xfer += $output->writeStructEnd();
2055 
    return $xfer;
2056 
  }
2057 
 
2058 
}
2059 
 
2060 
class TCLIService_GetSchemas_args {
2061 
  static $_TSPEC;
2062 
 
2063 
  /**
2064 
   * @var \TGetSchemasReq
2065 
   */
2066 
  public $req = null;
2067 
 
2068 
  public function __construct($vals=null) {
2069 
    if (!isset(self::$_TSPEC)) {
2070 
      self::$_TSPEC = array(
2071 
        1 => array(
2072 
          'var' => 'req',
2073 
          'type' => TType::STRUCT,
2074 
          'class' => '\TGetSchemasReq',
2075 
          ),
2076 
        );
2077 
    }
2078 
    if (is_array($vals)) {
2079 
      if (isset($vals['req'])) {
2080 
        $this->req = $vals['req'];
2081 
      }
2082 
    }
2083 
  }
2084 
 
2085 
  public function getName() {
2086 
    return 'TCLIService_GetSchemas_args';
2087 
  }
2088 
 
2089 
  public function read($input)
2090 
  {
2091 
    $xfer = 0;
2092 
    $fname = null;
2093 
    $ftype = 0;
2094 
    $fid = 0;
2095 
    $xfer += $input->readStructBegin($fname);
2096 
    while (true)
2097 
    {
2098 
      $xfer += $input->readFieldBegin($fname, $ftype, $fid);
2099 
      if ($ftype == TType::STOP) {
2100 
        break;
2101 
      }
2102 
      switch ($fid)
2103 
      {
2104 
        case 1:
2105 
          if ($ftype == TType::STRUCT) {
2106 
            $this->req = new \TGetSchemasReq();
2107 
            $xfer += $this->req->read($input);
2108 
          } else {
2109 
            $xfer += $input->skip($ftype);
2110 
          }
2111 
          break;
2112 
        default:
2113 
          $xfer += $input->skip($ftype);
2114 
          break;
2115 
      }
2116 
      $xfer += $input->readFieldEnd();
2117 
    }
2118 
    $xfer += $input->readStructEnd();
2119 
    return $xfer;
2120 
  }
2121 
 
2122 
  public function write($output) {
2123 
    $xfer = 0;
2124 
    $xfer += $output->writeStructBegin('TCLIService_GetSchemas_args');
2125 
    if ($this->req !== null) {
2126 
      if (!is_object($this->req)) {
2127 
        throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
2128 
      }
2129 
      $xfer += $output->writeFieldBegin('req', TType::STRUCT, 1);
2130 
      $xfer += $this->req->write($output);
2131 
      $xfer += $output->writeFieldEnd();
2132 
    }
2133 
    $xfer += $output->writeFieldStop();
2134 
    $xfer += $output->writeStructEnd();
2135 
    return $xfer;
2136 
  }
2137 
 
2138 
}
2139 
 
2140 
class TCLIService_GetSchemas_result {
2141 
  static $_TSPEC;
2142 
 
2143 
  /**
2144 
   * @var \TGetSchemasResp
2145 
   */
2146 
  public $success = null;
2147 
 
2148 
  public function __construct($vals=null) {
2149 
    if (!isset(self::$_TSPEC)) {
2150 
      self::$_TSPEC = array(
2151 
 
2152 
          'var' => 'success',
2153 
          'type' => TType::STRUCT,
2154 
          'class' => '\TGetSchemasResp',
2155 
          ),
2156 
        );
2157 
    }
2158 
    if (is_array($vals)) {
2159 
      if (isset($vals['success'])) {
2160 
        $this->success = $vals['success'];
2161 
      }
2162 
    }
2163 
  }
2164 
 
2165 
  public function getName() {
2166 
    return 'TCLIService_GetSchemas_result';
2167 
  }
2168 
 
2169 
  public function read($input)
2170 
  {
2171 
    $xfer = 0;
2172 
    $fname = null;
2173 
    $ftype = 0;
2174 
    $fid = 0;
2175 
    $xfer += $input->readStructBegin($fname);
2176 
    while (true)
2177 
    {
2178 
      $xfer += $input->readFieldBegin($fname, $ftype, $fid);
2179 
      if ($ftype == TType::STOP) {
2180 
        break;
2181 
      }
2182 
      switch ($fid)
2183 
      {
2184 
        case 0:
2185 
          if ($ftype == TType::STRUCT) {
2186 
            $this->success = new \TGetSchemasResp();
2187 
            $xfer += $this->success->read($input);
2188 
          } else {
2189 
            $xfer += $input->skip($ftype);
2190 
          }
2191 
          break;
2192 
        default:
2193 
          $xfer += $input->skip($ftype);
2194 
          break;
2195 
      }
2196 
      $xfer += $input->readFieldEnd();
2197 
    }
2198 
    $xfer += $input->readStructEnd();
2199 
    return $xfer;
2200 
  }
2201 
 
2202 
  public function write($output) {
2203 
    $xfer = 0;
2204 
    $xfer += $output->writeStructBegin('TCLIService_GetSchemas_result');
2205 
    if ($this->success !== null) {
2206 
      if (!is_object($this->success)) {
2207 
        throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
2208 
      }
2209 
      $xfer += $output->writeFieldBegin('success', TType::STRUCT, 0);
2210 
      $xfer += $this->success->write($output);
2211 
      $xfer += $output->writeFieldEnd();
2212 
    }
2213 
    $xfer += $output->writeFieldStop();
2214 
    $xfer += $output->writeStructEnd();
2215 
    return $xfer;
2216 
  }
2217 
 
2218 
}
2219 
 
2220 
class TCLIService_GetTables_args {
2221 
  static $_TSPEC;
2222 
 
2223 
  /**
2224 
   * @var \TGetTablesReq
2225 
   */
2226 
  public $req = null;
2227 
 
2228 
  public function __construct($vals=null) {
2229 
    if (!isset(self::$_TSPEC)) {
2230 
      self::$_TSPEC = array(
2231 
        1 => array(
2232 
          'var' => 'req',
2233 
          'type' => TType::STRUCT,
2234 
          'class' => '\TGetTablesReq',
2235 
          ),
2236 
        );
2237 
    }
2238 
    if (is_array($vals)) {
2239 
      if (isset($vals['req'])) {
2240 
        $this->req = $vals['req'];
2241 
      }
2242 
    }
2243 
  }
2244 
 
2245 
  public function getName() {
2246 
    return 'TCLIService_GetTables_args';
2247 
  }
2248 
 
2249 
  public function read($input)
2250 
  {
2251 
    $xfer = 0;
2252 
    $fname = null;
2253 
    $ftype = 0;
2254 
    $fid = 0;
2255 
    $xfer += $input->readStructBegin($fname);
2256 
    while (true)
2257 
    {
2258 
      $xfer += $input->readFieldBegin($fname, $ftype, $fid);
2259 
      if ($ftype == TType::STOP) {
2260 
        break;
2261 
      }
2262 
      switch ($fid)
2263 
      {
2264 
        case 1:
2265 
          if ($ftype == TType::STRUCT) {
2266 
            $this->req = new \TGetTablesReq();
2267 
            $xfer += $this->req->read($input);
2268 
          } else {
2269 
            $xfer += $input->skip($ftype);
2270 
          }
2271 
          break;
2272 
        default:
2273 
          $xfer += $input->skip($ftype);
2274 
          break;
2275 
      }
2276 
      $xfer += $input->readFieldEnd();
2277 
    }
2278 
    $xfer += $input->readStructEnd();
2279 
    return $xfer;
2280 
  }
2281 
 
2282 
  public function write($output) {
2283 
    $xfer = 0;
2284 
    $xfer += $output->writeStructBegin('TCLIService_GetTables_args');
2285 
    if ($this->req !== null) {
2286 
      if (!is_object($this->req)) {
2287 
        throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
2288 
      }
2289 
      $xfer += $output->writeFieldBegin('req', TType::STRUCT, 1);
2290 
      $xfer += $this->req->write($output);
2291 
      $xfer += $output->writeFieldEnd();
2292 
    }
2293 
    $xfer += $output->writeFieldStop();
2294 
    $xfer += $output->writeStructEnd();
2295 
    return $xfer;
2296 
  }
2297 
 
2298 
}
2299 
 
2300 
class TCLIService_GetTables_result {
2301 
  static $_TSPEC;
2302 
 
2303 
  /**
2304 
   * @var \TGetTablesResp
2305 
   */
2306 
  public $success = null;
2307 
 
2308 
  public function __construct($vals=null) {
2309 
    if (!isset(self::$_TSPEC)) {
2310 
      self::$_TSPEC = array(
2311 
 
2312 
          'var' => 'success',
2313 
          'type' => TType::STRUCT,
2314 
          'class' => '\TGetTablesResp',
2315 
          ),
2316 
        );
2317 
    }
2318 
    if (is_array($vals)) {
2319 
      if (isset($vals['success'])) {
2320 
        $this->success = $vals['success'];
2321 
      }
2322 
    }
2323 
  }
2324 
 
2325 
  public function getName() {
2326 
    return 'TCLIService_GetTables_result';
2327 
  }
2328 
 
2329 
  public function read($input)
2330 
  {
2331 
    $xfer = 0;
2332 
    $fname = null;
2333 
    $ftype = 0;
2334 
    $fid = 0;
2335 
    $xfer += $input->readStructBegin($fname);
2336 
    while (true)
2337 
    {
2338 
      $xfer += $input->readFieldBegin($fname, $ftype, $fid);
2339 
      if ($ftype == TType::STOP) {
2340 
        break;
2341 
      }
2342 
      switch ($fid)
2343 
      {
2344 
        case 0:
2345 
          if ($ftype == TType::STRUCT) {
2346 
            $this->success = new \TGetTablesResp();
2347 
            $xfer += $this->success->read($input);
2348 
          } else {
2349 
            $xfer += $input->skip($ftype);
2350 
          }
2351 
          break;
2352 
        default:
2353 
          $xfer += $input->skip($ftype);
2354 
          break;
2355 
      }
2356 
      $xfer += $input->readFieldEnd();
2357 
    }
2358 
    $xfer += $input->readStructEnd();
2359 
    return $xfer;
2360 
  }
2361 
 
2362 
  public function write($output) {
2363 
    $xfer = 0;
2364 
    $xfer += $output->writeStructBegin('TCLIService_GetTables_result');
2365 
    if ($this->success !== null) {
2366 
      if (!is_object($this->success)) {
2367 
        throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
2368 
      }
2369 
      $xfer += $output->writeFieldBegin('success', TType::STRUCT, 0);
2370 
      $xfer += $this->success->write($output);
2371 
      $xfer += $output->writeFieldEnd();
2372 
    }
2373 
    $xfer += $output->writeFieldStop();
2374 
    $xfer += $output->writeStructEnd();
2375 
    return $xfer;
2376 
  }
2377 
 
2378 
}
2379 
 
2380 
class TCLIService_GetTableTypes_args {
2381 
  static $_TSPEC;
2382 
 
2383 
  /**
2384 
   * @var \TGetTableTypesReq
2385 
   */
2386 
  public $req = null;
2387 
 
2388 
  public function __construct($vals=null) {
2389 
    if (!isset(self::$_TSPEC)) {
2390 
      self::$_TSPEC = array(
2391 
        1 => array(
2392 
          'var' => 'req',
2393 
          'type' => TType::STRUCT,
2394 
          'class' => '\TGetTableTypesReq',
2395 
          ),
2396 
        );
2397 
    }
2398 
    if (is_array($vals)) {
2399 
      if (isset($vals['req'])) {
2400 
        $this->req = $vals['req'];
2401 
      }
2402 
    }
2403 
  }
2404 
 
2405 
  public function getName() {
2406 
    return 'TCLIService_GetTableTypes_args';
2407 
  }
2408 
 
2409 
  public function read($input)
2410 
  {
2411 
    $xfer = 0;
2412 
    $fname = null;
2413 
    $ftype = 0;
2414 
    $fid = 0;
2415 
    $xfer += $input->readStructBegin($fname);
2416 
    while (true)
2417 
    {
2418 
      $xfer += $input->readFieldBegin($fname, $ftype, $fid);
2419 
      if ($ftype == TType::STOP) {
2420 
        break;
2421 
      }
2422 
      switch ($fid)
2423 
      {
2424 
        case 1:
2425 
          if ($ftype == TType::STRUCT) {
2426 
            $this->req = new \TGetTableTypesReq();
2427 
            $xfer += $this->req->read($input);
2428 
          } else {
2429 
            $xfer += $input->skip($ftype);
2430 
          }
2431 
          break;
2432 
        default:
2433 
          $xfer += $input->skip($ftype);
2434 
          break;
2435 
      }
2436 
      $xfer += $input->readFieldEnd();
2437 
    }
2438 
    $xfer += $input->readStructEnd();
2439 
    return $xfer;
2440 
  }
2441 
 
2442 
  public function write($output) {
2443 
    $xfer = 0;
2444 
    $xfer += $output->writeStructBegin('TCLIService_GetTableTypes_args');
2445 
    if ($this->req !== null) {
2446 
      if (!is_object($this->req)) {
2447 
        throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
2448 
      }
2449 
      $xfer += $output->writeFieldBegin('req', TType::STRUCT, 1);
2450 
      $xfer += $this->req->write($output);
2451 
      $xfer += $output->writeFieldEnd();
2452 
    }
2453 
    $xfer += $output->writeFieldStop();
2454 
    $xfer += $output->writeStructEnd();
2455 
    return $xfer;
2456 
  }
2457 
 
2458 
}
2459 
 
2460 
class TCLIService_GetTableTypes_result {
2461 
  static $_TSPEC;
2462 
 
2463 
  /**
2464 
   * @var \TGetTableTypesResp
2465 
   */
2466 
  public $success = null;
2467 
 
2468 
  public function __construct($vals=null) {
2469 
    if (!isset(self::$_TSPEC)) {
2470 
      self::$_TSPEC = array(
2471 
 
2472 
          'var' => 'success',
2473 
          'type' => TType::STRUCT,
2474 
          'class' => '\TGetTableTypesResp',
2475 
          ),
2476 
        );
2477 
    }
2478 
    if (is_array($vals)) {
2479 
      if (isset($vals['success'])) {
2480 
        $this->success = $vals['success'];
2481 
      }
2482 
    }
2483 
  }
2484 
 
2485 
  public function getName() {
2486 
    return 'TCLIService_GetTableTypes_result';
2487 
  }
2488 
 
2489 
  public function read($input)
2490 
  {
2491 
    $xfer = 0;
2492 
    $fname = null;
2493 
    $ftype = 0;
2494 
    $fid = 0;
2495 
    $xfer += $input->readStructBegin($fname);
2496 
    while (true)
2497 
    {
2498 
      $xfer += $input->readFieldBegin($fname, $ftype, $fid);
2499 
      if ($ftype == TType::STOP) {
2500 
        break;
2501 
      }
2502 
      switch ($fid)
2503 
      {
2504 
        case 0:
2505 
          if ($ftype == TType::STRUCT) {
2506 
            $this->success = new \TGetTableTypesResp();
2507 
            $xfer += $this->success->read($input);
2508 
          } else {
2509 
            $xfer += $input->skip($ftype);
2510 
          }
2511 
          break;
2512 
        default:
2513 
          $xfer += $input->skip($ftype);
2514 
          break;
2515 
      }
2516 
      $xfer += $input->readFieldEnd();
2517 
    }
2518 
    $xfer += $input->readStructEnd();
2519 
    return $xfer;
2520 
  }
2521 
 
2522 
  public function write($output) {
2523 
    $xfer = 0;
2524 
    $xfer += $output->writeStructBegin('TCLIService_GetTableTypes_result');
2525 
    if ($this->success !== null) {
2526 
      if (!is_object($this->success)) {
2527 
        throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
2528 
      }
2529 
      $xfer += $output->writeFieldBegin('success', TType::STRUCT, 0);
2530 
      $xfer += $this->success->write($output);
2531 
      $xfer += $output->writeFieldEnd();
2532 
    }
2533 
    $xfer += $output->writeFieldStop();
2534 
    $xfer += $output->writeStructEnd();
2535 
    return $xfer;
2536 
  }
2537 
 
2538 
}
2539 
 
2540 
class TCLIService_GetColumns_args {
2541 
  static $_TSPEC;
2542 
 
2543 
  /**
2544 
   * @var \TGetColumnsReq
2545 
   */
2546 
  public $req = null;
2547 
 
2548 
  public function __construct($vals=null) {
2549 
    if (!isset(self::$_TSPEC)) {
2550 
      self::$_TSPEC = array(
2551 
        1 => array(
2552 
          'var' => 'req',
2553 
          'type' => TType::STRUCT,
2554 
          'class' => '\TGetColumnsReq',
2555 
          ),
2556 
        );
2557 
    }
2558 
    if (is_array($vals)) {
2559 
      if (isset($vals['req'])) {
2560 
        $this->req = $vals['req'];
2561 
      }
2562 
    }
2563 
  }
2564 
 
2565 
  public function getName() {
2566 
    return 'TCLIService_GetColumns_args';
2567 
  }
2568 
 
2569 
  public function read($input)
2570 
  {
2571 
    $xfer = 0;
2572 
    $fname = null;
2573 
    $ftype = 0;
2574 
    $fid = 0;
2575 
    $xfer += $input->readStructBegin($fname);
2576 
    while (true)
2577 
    {
2578 
      $xfer += $input->readFieldBegin($fname, $ftype, $fid);
2579 
      if ($ftype == TType::STOP) {
2580 
        break;
2581 
      }
2582 
      switch ($fid)
2583 
      {
2584 
        case 1:
2585 
          if ($ftype == TType::STRUCT) {
2586 
            $this->req = new \TGetColumnsReq();
2587 
            $xfer += $this->req->read($input);
2588 
          } else {
2589 
            $xfer += $input->skip($ftype);
2590 
          }
2591 
          break;
2592 
        default:
2593 
          $xfer += $input->skip($ftype);
2594 
          break;
2595 
      }
2596 
      $xfer += $input->readFieldEnd();
2597 
    }
2598 
    $xfer += $input->readStructEnd();
2599 
    return $xfer;
2600 
  }
2601 
 
2602 
  public function write($output) {
2603 
    $xfer = 0;
2604 
    $xfer += $output->writeStructBegin('TCLIService_GetColumns_args');
2605 
    if ($this->req !== null) {
2606 
      if (!is_object($this->req)) {
2607 
        throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
2608 
      }
2609 
      $xfer += $output->writeFieldBegin('req', TType::STRUCT, 1);
2610 
      $xfer += $this->req->write($output);
2611 
      $xfer += $output->writeFieldEnd();
2612 
    }
2613 
    $xfer += $output->writeFieldStop();
2614 
    $xfer += $output->writeStructEnd();
2615 
    return $xfer;
2616 
  }
2617 
 
2618 
}
2619 
 
2620 
class TCLIService_GetColumns_result {
2621 
  static $_TSPEC;
2622 
 
2623 
  /**
2624 
   * @var \TGetColumnsResp
2625 
   */
2626 
  public $success = null;
2627 
 
2628 
  public function __construct($vals=null) {
2629 
    if (!isset(self::$_TSPEC)) {
2630 
      self::$_TSPEC = array(
2631 
 
2632 
          'var' => 'success',
2633 
          'type' => TType::STRUCT,
2634 
          'class' => '\TGetColumnsResp',
2635 
          ),
2636 
        );
2637 
    }
2638 
    if (is_array($vals)) {
2639 
      if (isset($vals['success'])) {
2640 
        $this->success = $vals['success'];
2641 
      }
2642 
    }
2643 
  }
2644 
 
2645 
  public function getName() {
2646 
    return 'TCLIService_GetColumns_result';
2647 
  }
2648 
 
2649 
  public function read($input)
2650 
  {
2651 
    $xfer = 0;
2652 
    $fname = null;
2653 
    $ftype = 0;
2654 
    $fid = 0;
2655 
    $xfer += $input->readStructBegin($fname);
2656 
    while (true)
2657 
    {
2658 
      $xfer += $input->readFieldBegin($fname, $ftype, $fid);
2659 
      if ($ftype == TType::STOP) {
2660 
        break;
2661 
      }
2662 
      switch ($fid)
2663 
      {
2664 
        case 0:
2665 
          if ($ftype == TType::STRUCT) {
2666 
            $this->success = new \TGetColumnsResp();
2667 
            $xfer += $this->success->read($input);
2668 
          } else {
2669 
            $xfer += $input->skip($ftype);
2670 
          }
2671 
          break;
2672 
        default:
2673 
          $xfer += $input->skip($ftype);
2674 
          break;
2675 
      }
2676 
      $xfer += $input->readFieldEnd();
2677 
    }
2678 
    $xfer += $input->readStructEnd();
2679 
    return $xfer;
2680 
  }
2681 
 
2682 
  public function write($output) {
2683 
    $xfer = 0;
2684 
    $xfer += $output->writeStructBegin('TCLIService_GetColumns_result');
2685 
    if ($this->success !== null) {
2686 
      if (!is_object($this->success)) {
2687 
        throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
2688 
      }
2689 
      $xfer += $output->writeFieldBegin('success', TType::STRUCT, 0);
2690 
      $xfer += $this->success->write($output);
2691 
      $xfer += $output->writeFieldEnd();
2692 
    }
2693 
    $xfer += $output->writeFieldStop();
2694 
    $xfer += $output->writeStructEnd();
2695 
    return $xfer;
2696 
  }
2697 
 
2698 
}
2699 
 
2700 
class TCLIService_GetFunctions_args {
2701 
  static $_TSPEC;
2702 
 
2703 
  /**
2704 
   * @var \TGetFunctionsReq
2705 
   */
2706 
  public $req = null;
2707 
 
2708 
  public function __construct($vals=null) {
2709 
    if (!isset(self::$_TSPEC)) {
2710 
      self::$_TSPEC = array(
2711 
        1 => array(
2712 
          'var' => 'req',
2713 
          'type' => TType::STRUCT,
2714 
          'class' => '\TGetFunctionsReq',
2715 
          ),
2716 
        );
2717 
    }
2718 
    if (is_array($vals)) {
2719 
      if (isset($vals['req'])) {
2720 
        $this->req = $vals['req'];
2721 
      }
2722 
    }
2723 
  }
2724 
 
2725 
  public function getName() {
2726 
    return 'TCLIService_GetFunctions_args';
2727 
  }
2728 
 
2729 
  public function read($input)
2730 
  {
2731 
    $xfer = 0;
2732 
    $fname = null;
2733 
    $ftype = 0;
2734 
    $fid = 0;
2735 
    $xfer += $input->readStructBegin($fname);
2736 
    while (true)
2737 
    {
2738 
      $xfer += $input->readFieldBegin($fname, $ftype, $fid);
2739 
      if ($ftype == TType::STOP) {
2740 
        break;
2741 
      }
2742 
      switch ($fid)
2743 
      {
2744 
        case 1:
2745 
          if ($ftype == TType::STRUCT) {
2746 
            $this->req = new \TGetFunctionsReq();
2747 
            $xfer += $this->req->read($input);
2748 
          } else {
2749 
            $xfer += $input->skip($ftype);
2750 
          }
2751 
          break;
2752 
        default:
2753 
          $xfer += $input->skip($ftype);
2754 
          break;
2755 
      }
2756 
      $xfer += $input->readFieldEnd();
2757 
    }
2758 
    $xfer += $input->readStructEnd();
2759 
    return $xfer;
2760 
  }
2761 
 
2762 
  public function write($output) {
2763 
    $xfer = 0;
2764 
    $xfer += $output->writeStructBegin('TCLIService_GetFunctions_args');
2765 
    if ($this->req !== null) {
2766 
      if (!is_object($this->req)) {
2767 
        throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
2768 
      }
2769 
      $xfer += $output->writeFieldBegin('req', TType::STRUCT, 1);
2770 
      $xfer += $this->req->write($output);
2771 
      $xfer += $output->writeFieldEnd();
2772 
    }
2773 
    $xfer += $output->writeFieldStop();
2774 
    $xfer += $output->writeStructEnd();
2775 
    return $xfer;
2776 
  }
2777 
 
2778 
}
2779 
 
2780 
class TCLIService_GetFunctions_result {
2781 
  static $_TSPEC;
2782 
 
2783 
  /**
2784 
   * @var \TGetFunctionsResp
2785 
   */
2786 
  public $success = null;
2787 
 
2788 
  public function __construct($vals=null) {
2789 
    if (!isset(self::$_TSPEC)) {
2790 
      self::$_TSPEC = array(
2791 
 
2792 
          'var' => 'success',
2793 
          'type' => TType::STRUCT,
2794 
          'class' => '\TGetFunctionsResp',
2795 
          ),
2796 
        );
2797 
    }
2798 
    if (is_array($vals)) {
2799 
      if (isset($vals['success'])) {
2800 
        $this->success = $vals['success'];
2801 
      }
2802 
    }
2803 
  }
2804 
 
2805 
  public function getName() {
2806 
    return 'TCLIService_GetFunctions_result';
2807 
  }
2808 
 
2809 
  public function read($input)
2810 
  {
2811 
    $xfer = 0;
2812 
    $fname = null;
2813 
    $ftype = 0;
2814 
    $fid = 0;
2815 
    $xfer += $input->readStructBegin($fname);
2816 
    while (true)
2817 
    {
2818 
      $xfer += $input->readFieldBegin($fname, $ftype, $fid);
2819 
      if ($ftype == TType::STOP) {
2820 
        break;
2821 
      }
2822 
      switch ($fid)
2823 
      {
2824 
        case 0:
2825 
          if ($ftype == TType::STRUCT) {
2826 
            $this->success = new \TGetFunctionsResp();
2827 
            $xfer += $this->success->read($input);
2828 
          } else {
2829 
            $xfer += $input->skip($ftype);
2830 
          }
2831 
          break;
2832 
        default:
2833 
          $xfer += $input->skip($ftype);
2834 
          break;
2835 
      }
2836 
      $xfer += $input->readFieldEnd();
2837 
    }
2838 
    $xfer += $input->readStructEnd();
2839 
    return $xfer;
2840 
  }
2841 
 
2842 
  public function write($output) {
2843 
    $xfer = 0;
2844 
    $xfer += $output->writeStructBegin('TCLIService_GetFunctions_result');
2845 
    if ($this->success !== null) {
2846 
      if (!is_object($this->success)) {
2847 
        throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
2848 
      }
2849 
      $xfer += $output->writeFieldBegin('success', TType::STRUCT, 0);
2850 
      $xfer += $this->success->write($output);
2851 
      $xfer += $output->writeFieldEnd();
2852 
    }
2853 
    $xfer += $output->writeFieldStop();
2854 
    $xfer += $output->writeStructEnd();
2855 
    return $xfer;
2856 
  }
2857 
 
2858 
}
2859 
 
2860 
class TCLIService_GetOperationStatus_args {
2861 
  static $_TSPEC;
2862 
 
2863 
  /**
2864 
   * @var \TGetOperationStatusReq
2865 
   */
2866 
  public $req = null;
2867 
 
2868 
  public function __construct($vals=null) {
2869 
    if (!isset(self::$_TSPEC)) {
2870 
      self::$_TSPEC = array(
2871 
        1 => array(
2872 
          'var' => 'req',
2873 
          'type' => TType::STRUCT,
2874 
          'class' => '\TGetOperationStatusReq',
2875 
          ),
2876 
        );
2877 
    }
2878 
    if (is_array($vals)) {
2879 
      if (isset($vals['req'])) {
2880 
        $this->req = $vals['req'];
2881 
      }
2882 
    }
2883 
  }
2884 
 
2885 
  public function getName() {
2886 
    return 'TCLIService_GetOperationStatus_args';
2887 
  }
2888 
 
2889 
  public function read($input)
2890 
  {
2891 
    $xfer = 0;
2892 
    $fname = null;
2893 
    $ftype = 0;
2894 
    $fid = 0;
2895 
    $xfer += $input->readStructBegin($fname);
2896 
    while (true)
2897 
    {
2898 
      $xfer += $input->readFieldBegin($fname, $ftype, $fid);
2899 
      if ($ftype == TType::STOP) {
2900 
        break;
2901 
      }
2902 
      switch ($fid)
2903 
      {
2904 
        case 1:
2905 
          if ($ftype == TType::STRUCT) {
2906 
            $this->req = new \TGetOperationStatusReq();
2907 
            $xfer += $this->req->read($input);
2908 
          } else {
2909 
            $xfer += $input->skip($ftype);
2910 
          }
2911 
          break;
2912 
        default:
2913 
          $xfer += $input->skip($ftype);
2914 
          break;
2915 
      }
2916 
      $xfer += $input->readFieldEnd();
2917 
    }
2918 
    $xfer += $input->readStructEnd();
2919 
    return $xfer;
2920 
  }
2921 
 
2922 
  public function write($output) {
2923 
    $xfer = 0;
2924 
    $xfer += $output->writeStructBegin('TCLIService_GetOperationStatus_args');
2925 
    if ($this->req !== null) {
2926 
      if (!is_object($this->req)) {
2927 
        throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
2928 
      }
2929 
      $xfer += $output->writeFieldBegin('req', TType::STRUCT, 1);
2930 
      $xfer += $this->req->write($output);
2931 
      $xfer += $output->writeFieldEnd();
2932 
    }
2933 
    $xfer += $output->writeFieldStop();
2934 
    $xfer += $output->writeStructEnd();
2935 
    return $xfer;
2936 
  }
2937 
 
2938 
}
2939 
 
2940 
class TCLIService_GetOperationStatus_result {
2941 
  static $_TSPEC;
2942 
 
2943 
  /**
2944 
   * @var \TGetOperationStatusResp
2945 
   */
2946 
  public $success = null;
2947 
 
2948 
  public function __construct($vals=null) {
2949 
    if (!isset(self::$_TSPEC)) {
2950 
      self::$_TSPEC = array(
2951 
 
2952 
          'var' => 'success',
2953 
          'type' => TType::STRUCT,
2954 
          'class' => '\TGetOperationStatusResp',
2955 
          ),
2956 
        );
2957 
    }
2958 
    if (is_array($vals)) {
2959 
      if (isset($vals['success'])) {
2960 
        $this->success = $vals['success'];
2961 
      }
2962 
    }
2963 
  }
2964 
 
2965 
  public function getName() {
2966 
    return 'TCLIService_GetOperationStatus_result';
2967 
  }
2968 
 
2969 
  public function read($input)
2970 
  {
2971 
    $xfer = 0;
2972 
    $fname = null;
2973 
    $ftype = 0;
2974 
    $fid = 0;
2975 
    $xfer += $input->readStructBegin($fname);
2976 
    while (true)
2977 
    {
2978 
      $xfer += $input->readFieldBegin($fname, $ftype, $fid);
2979 
      if ($ftype == TType::STOP) {
2980 
        break;
2981 
      }
2982 
      switch ($fid)
2983 
      {
2984 
        case 0:
2985 
          if ($ftype == TType::STRUCT) {
2986 
            $this->success = new \TGetOperationStatusResp();
2987 
            $xfer += $this->success->read($input);
2988 
          } else {
2989 
            $xfer += $input->skip($ftype);
2990 
          }
2991 
          break;
2992 
        default:
2993 
          $xfer += $input->skip($ftype);
2994 
          break;
2995 
      }
2996 
      $xfer += $input->readFieldEnd();
2997 
    }
2998 
    $xfer += $input->readStructEnd();
2999 
    return $xfer;
3000 
  }
3001 
 
3002 
  public function write($output) {
3003 
    $xfer = 0;
3004 
    $xfer += $output->writeStructBegin('TCLIService_GetOperationStatus_result');
3005 
    if ($this->success !== null) {
3006 
      if (!is_object($this->success)) {
3007 
        throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
3008 
      }
3009 
      $xfer += $output->writeFieldBegin('success', TType::STRUCT, 0);
3010 
      $xfer += $this->success->write($output);
3011 
      $xfer += $output->writeFieldEnd();
3012 
    }
3013 
    $xfer += $output->writeFieldStop();
3014 
    $xfer += $output->writeStructEnd();
3015 
    return $xfer;
3016 
  }
3017 
 
3018 
}
3019 
 
3020 
class TCLIService_CancelOperation_args {
3021 
  static $_TSPEC;
3022 
 
3023 
  /**
3024 
   * @var \TCancelOperationReq
3025 
   */
3026 
  public $req = null;
3027 
 
3028 
  public function __construct($vals=null) {
3029 
    if (!isset(self::$_TSPEC)) {
3030 
      self::$_TSPEC = array(
3031 
        1 => array(
3032 
          'var' => 'req',
3033 
          'type' => TType::STRUCT,
3034 
          'class' => '\TCancelOperationReq',
3035 
          ),
3036 
        );
3037 
    }
3038 
    if (is_array($vals)) {
3039 
      if (isset($vals['req'])) {
3040 
        $this->req = $vals['req'];
3041 
      }
3042 
    }
3043 
  }
3044 
 
3045 
  public function getName() {
3046 
    return 'TCLIService_CancelOperation_args';
3047 
  }
3048 
 
3049 
  public function read($input)
3050 
  {
3051 
    $xfer = 0;
3052 
    $fname = null;
3053 
    $ftype = 0;
3054 
    $fid = 0;
3055 
    $xfer += $input->readStructBegin($fname);
3056 
    while (true)
3057 
    {
3058 
      $xfer += $input->readFieldBegin($fname, $ftype, $fid);
3059 
      if ($ftype == TType::STOP) {
3060 
        break;
3061 
      }
3062 
      switch ($fid)
3063 
      {
3064 
        case 1:
3065 
          if ($ftype == TType::STRUCT) {
3066 
            $this->req = new \TCancelOperationReq();
3067 
            $xfer += $this->req->read($input);
3068 
          } else {
3069 
            $xfer += $input->skip($ftype);
3070 
          }
3071 
          break;
3072 
        default:
3073 
          $xfer += $input->skip($ftype);
3074 
          break;
3075 
      }
3076 
      $xfer += $input->readFieldEnd();
3077 
    }
3078 
    $xfer += $input->readStructEnd();
3079 
    return $xfer;
3080 
  }
3081 
 
3082 
  public function write($output) {
3083 
    $xfer = 0;
3084 
    $xfer += $output->writeStructBegin('TCLIService_CancelOperation_args');
3085 
    if ($this->req !== null) {
3086 
      if (!is_object($this->req)) {
3087 
        throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
3088 
      }
3089 
      $xfer += $output->writeFieldBegin('req', TType::STRUCT, 1);
3090 
      $xfer += $this->req->write($output);
3091 
      $xfer += $output->writeFieldEnd();
3092 
    }
3093 
    $xfer += $output->writeFieldStop();
3094 
    $xfer += $output->writeStructEnd();
3095 
    return $xfer;
3096 
  }
3097 
 
3098 
}
3099 
 
3100 
class TCLIService_CancelOperation_result {
3101 
  static $_TSPEC;
3102 
 
3103 
  /**
3104 
   * @var \TCancelOperationResp
3105 
   */
3106 
  public $success = null;
3107 
 
3108 
  public function __construct($vals=null) {
3109 
    if (!isset(self::$_TSPEC)) {
3110 
      self::$_TSPEC = array(
3111 
 
3112 
          'var' => 'success',
3113 
          'type' => TType::STRUCT,
3114 
          'class' => '\TCancelOperationResp',
3115 
          ),
3116 
        );
3117 
    }
3118 
    if (is_array($vals)) {
3119 
      if (isset($vals['success'])) {
3120 
        $this->success = $vals['success'];
3121 
      }
3122 
    }
3123 
  }
3124 
 
3125 
  public function getName() {
3126 
    return 'TCLIService_CancelOperation_result';
3127 
  }
3128 
 
3129 
  public function read($input)
3130 
  {
3131 
    $xfer = 0;
3132 
    $fname = null;
3133 
    $ftype = 0;
3134 
    $fid = 0;
3135 
    $xfer += $input->readStructBegin($fname);
3136 
    while (true)
3137 
    {
3138 
      $xfer += $input->readFieldBegin($fname, $ftype, $fid);
3139 
      if ($ftype == TType::STOP) {
3140 
        break;
3141 
      }
3142 
      switch ($fid)
3143 
      {
3144 
        case 0:
3145 
          if ($ftype == TType::STRUCT) {
3146 
            $this->success = new \TCancelOperationResp();
3147 
            $xfer += $this->success->read($input);
3148 
          } else {
3149 
            $xfer += $input->skip($ftype);
3150 
          }
3151 
          break;
3152 
        default:
3153 
          $xfer += $input->skip($ftype);
3154 
          break;
3155 
      }
3156 
      $xfer += $input->readFieldEnd();
3157 
    }
3158 
    $xfer += $input->readStructEnd();
3159 
    return $xfer;
3160 
  }
3161 
 
3162 
  public function write($output) {
3163 
    $xfer = 0;
3164 
    $xfer += $output->writeStructBegin('TCLIService_CancelOperation_result');
3165 
    if ($this->success !== null) {
3166 
      if (!is_object($this->success)) {
3167 
        throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
3168 
      }
3169 
      $xfer += $output->writeFieldBegin('success', TType::STRUCT, 0);
3170 
      $xfer += $this->success->write($output);
3171 
      $xfer += $output->writeFieldEnd();
3172 
    }
3173 
    $xfer += $output->writeFieldStop();
3174 
    $xfer += $output->writeStructEnd();
3175 
    return $xfer;
3176 
  }
3177 
 
3178 
}
3179 
 
3180 
class TCLIService_CloseOperation_args {
3181 
  static $_TSPEC;
3182 
 
3183 
  /**
3184 
   * @var \TCloseOperationReq
3185 
   */
3186 
  public $req = null;
3187 
 
3188 
  public function __construct($vals=null) {
3189 
    if (!isset(self::$_TSPEC)) {
3190 
      self::$_TSPEC = array(
3191 
        1 => array(
3192 
          'var' => 'req',
3193 
          'type' => TType::STRUCT,
3194 
          'class' => '\TCloseOperationReq',
3195 
          ),
3196 
        );
3197 
    }
3198 
    if (is_array($vals)) {
3199 
      if (isset($vals['req'])) {
3200 
        $this->req = $vals['req'];
3201 
      }
3202 
    }
3203 
  }
3204 
 
3205 
  public function getName() {
3206 
    return 'TCLIService_CloseOperation_args';
3207 
  }
3208 
 
3209 
  public function read($input)
3210 
  {
3211 
    $xfer = 0;
3212 
    $fname = null;
3213 
    $ftype = 0;
3214 
    $fid = 0;
3215 
    $xfer += $input->readStructBegin($fname);
3216 
    while (true)
3217 
    {
3218 
      $xfer += $input->readFieldBegin($fname, $ftype, $fid);
3219 
      if ($ftype == TType::STOP) {
3220 
        break;
3221 
      }
3222 
      switch ($fid)
3223 
      {
3224 
        case 1:
3225 
          if ($ftype == TType::STRUCT) {
3226 
            $this->req = new \TCloseOperationReq();
3227 
            $xfer += $this->req->read($input);
3228 
          } else {
3229 
            $xfer += $input->skip($ftype);
3230 
          }
3231 
          break;
3232 
        default:
3233 
          $xfer += $input->skip($ftype);
3234 
          break;
3235 
      }
3236 
      $xfer += $input->readFieldEnd();
3237 
    }
3238 
    $xfer += $input->readStructEnd();
3239 
    return $xfer;
3240 
  }
3241 
 
3242 
  public function write($output) {
3243 
    $xfer = 0;
3244 
    $xfer += $output->writeStructBegin('TCLIService_CloseOperation_args');
3245 
    if ($this->req !== null) {
3246 
      if (!is_object($this->req)) {
3247 
        throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
3248 
      }
3249 
      $xfer += $output->writeFieldBegin('req', TType::STRUCT, 1);
3250 
      $xfer += $this->req->write($output);
3251 
      $xfer += $output->writeFieldEnd();
3252 
    }
3253 
    $xfer += $output->writeFieldStop();
3254 
    $xfer += $output->writeStructEnd();
3255 
    return $xfer;
3256 
  }
3257 
 
3258 
}
3259 
 
3260 
class TCLIService_CloseOperation_result {
3261 
  static $_TSPEC;
3262 
 
3263 
  /**
3264 
   * @var \TCloseOperationResp
3265 
   */
3266 
  public $success = null;
3267 
 
3268 
  public function __construct($vals=null) {
3269 
    if (!isset(self::$_TSPEC)) {
3270 
      self::$_TSPEC = array(
3271 
 
3272 
          'var' => 'success',
3273 
          'type' => TType::STRUCT,
3274 
          'class' => '\TCloseOperationResp',
3275 
          ),
3276 
        );
3277 
    }
3278 
    if (is_array($vals)) {
3279 
      if (isset($vals['success'])) {
3280 
        $this->success = $vals['success'];
3281 
      }
3282 
    }
3283 
  }
3284 
 
3285 
  public function getName() {
3286 
    return 'TCLIService_CloseOperation_result';
3287 
  }
3288 
 
3289 
  public function read($input)
3290 
  {
3291 
    $xfer = 0;
3292 
    $fname = null;
3293 
    $ftype = 0;
3294 
    $fid = 0;
3295 
    $xfer += $input->readStructBegin($fname);
3296 
    while (true)
3297 
    {
3298 
      $xfer += $input->readFieldBegin($fname, $ftype, $fid);
3299 
      if ($ftype == TType::STOP) {
3300 
        break;
3301 
      }
3302 
      switch ($fid)
3303 
      {
3304 
        case 0:
3305 
          if ($ftype == TType::STRUCT) {
3306 
            $this->success = new \TCloseOperationResp();
3307 
            $xfer += $this->success->read($input);
3308 
          } else {
3309 
            $xfer += $input->skip($ftype);
3310 
          }
3311 
          break;
3312 
        default:
3313 
          $xfer += $input->skip($ftype);
3314 
          break;
3315 
      }
3316 
      $xfer += $input->readFieldEnd();
3317 
    }
3318 
    $xfer += $input->readStructEnd();
3319 
    return $xfer;
3320 
  }
3321 
 
3322 
  public function write($output) {
3323 
    $xfer = 0;
3324 
    $xfer += $output->writeStructBegin('TCLIService_CloseOperation_result');
3325 
    if ($this->success !== null) {
3326 
      if (!is_object($this->success)) {
3327 
        throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
3328 
      }
3329 
      $xfer += $output->writeFieldBegin('success', TType::STRUCT, 0);
3330 
      $xfer += $this->success->write($output);
3331 
      $xfer += $output->writeFieldEnd();
3332 
    }
3333 
    $xfer += $output->writeFieldStop();
3334 
    $xfer += $output->writeStructEnd();
3335 
    return $xfer;
3336 
  }
3337 
 
3338 
}
3339 
 
3340 
class TCLIService_GetResultSetMetadata_args {
3341 
  static $_TSPEC;
3342 
 
3343 
  /**
3344 
   * @var \TGetResultSetMetadataReq
3345 
   */
3346 
  public $req = null;
3347 
 
3348 
  public function __construct($vals=null) {
3349 
    if (!isset(self::$_TSPEC)) {
3350 
      self::$_TSPEC = array(
3351 
        1 => array(
3352 
          'var' => 'req',
3353 
          'type' => TType::STRUCT,
3354 
          'class' => '\TGetResultSetMetadataReq',
3355 
          ),
3356 
        );
3357 
    }
3358 
    if (is_array($vals)) {
3359 
      if (isset($vals['req'])) {
3360 
        $this->req = $vals['req'];
3361 
      }
3362 
    }
3363 
  }
3364 
 
3365 
  public function getName() {
3366 
    return 'TCLIService_GetResultSetMetadata_args';
3367 
  }
3368 
 
3369 
  public function read($input)
3370 
  {
3371 
    $xfer = 0;
3372 
    $fname = null;
3373 
    $ftype = 0;
3374 
    $fid = 0;
3375 
    $xfer += $input->readStructBegin($fname);
3376 
    while (true)
3377 
    {
3378 
      $xfer += $input->readFieldBegin($fname, $ftype, $fid);
3379 
      if ($ftype == TType::STOP) {
3380 
        break;
3381 
      }
3382 
      switch ($fid)
3383 
      {
3384 
        case 1:
3385 
          if ($ftype == TType::STRUCT) {
3386 
            $this->req = new \TGetResultSetMetadataReq();
3387 
            $xfer += $this->req->read($input);
3388 
          } else {
3389 
            $xfer += $input->skip($ftype);
3390 
          }
3391 
          break;
3392 
        default:
3393 
          $xfer += $input->skip($ftype);
3394 
          break;
3395 
      }
3396 
      $xfer += $input->readFieldEnd();
3397 
    }
3398 
    $xfer += $input->readStructEnd();
3399 
    return $xfer;
3400 
  }
3401 
 
3402 
  public function write($output) {
3403 
    $xfer = 0;
3404 
    $xfer += $output->writeStructBegin('TCLIService_GetResultSetMetadata_args');
3405 
    if ($this->req !== null) {
3406 
      if (!is_object($this->req)) {
3407 
        throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
3408 
      }
3409 
      $xfer += $output->writeFieldBegin('req', TType::STRUCT, 1);
3410 
      $xfer += $this->req->write($output);
3411 
      $xfer += $output->writeFieldEnd();
3412 
    }
3413 
    $xfer += $output->writeFieldStop();
3414 
    $xfer += $output->writeStructEnd();
3415 
    return $xfer;
3416 
  }
3417 
 
3418 
}
3419 
 
3420 
class TCLIService_GetResultSetMetadata_result {
3421 
  static $_TSPEC;
3422 
 
3423 
  /**
3424 
   * @var \TGetResultSetMetadataResp
3425 
   */
3426 
  public $success = null;
3427 
 
3428 
  public function __construct($vals=null) {
3429 
    if (!isset(self::$_TSPEC)) {
3430 
      self::$_TSPEC = array(
3431 
 
3432 
          'var' => 'success',
3433 
          'type' => TType::STRUCT,
3434 
          'class' => '\TGetResultSetMetadataResp',
3435 
          ),
3436 
        );
3437 
    }
3438 
    if (is_array($vals)) {
3439 
      if (isset($vals['success'])) {
3440 
        $this->success = $vals['success'];
3441 
      }
3442 
    }
3443 
  }
3444 
 
3445 
  public function getName() {
3446 
    return 'TCLIService_GetResultSetMetadata_result';
3447 
  }
3448 
 
3449 
  public function read($input)
3450 
  {
3451 
    $xfer = 0;
3452 
    $fname = null;
3453 
    $ftype = 0;
3454 
    $fid = 0;
3455 
    $xfer += $input->readStructBegin($fname);
3456 
    while (true)
3457 
    {
3458 
      $xfer += $input->readFieldBegin($fname, $ftype, $fid);
3459 
      if ($ftype == TType::STOP) {
3460 
        break;
3461 
      }
3462 
      switch ($fid)
3463 
      {
3464 
        case 0:
3465 
          if ($ftype == TType::STRUCT) {
3466 
            $this->success = new \TGetResultSetMetadataResp();
3467 
            $xfer += $this->success->read($input);
3468 
          } else {
3469 
            $xfer += $input->skip($ftype);
3470 
          }
3471 
          break;
3472 
        default:
3473 
          $xfer += $input->skip($ftype);
3474 
          break;
3475 
      }
3476 
      $xfer += $input->readFieldEnd();
3477 
    }
3478 
    $xfer += $input->readStructEnd();
3479 
    return $xfer;
3480 
  }
3481 
 
3482 
  public function write($output) {
3483 
    $xfer = 0;
3484 
    $xfer += $output->writeStructBegin('TCLIService_GetResultSetMetadata_result');
3485 
    if ($this->success !== null) {
3486 
      if (!is_object($this->success)) {
3487 
        throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
3488 
      }
3489 
      $xfer += $output->writeFieldBegin('success', TType::STRUCT, 0);
3490 
      $xfer += $this->success->write($output);
3491 
      $xfer += $output->writeFieldEnd();
3492 
    }
3493 
    $xfer += $output->writeFieldStop();
3494 
    $xfer += $output->writeStructEnd();
3495 
    return $xfer;
3496 
  }
3497 
 
3498 
}
3499 
 
3500 
class TCLIService_FetchResults_args {
3501 
  static $_TSPEC;
3502 
 
3503 
  /**
3504 
   * @var \TFetchResultsReq
3505 
   */
3506 
  public $req = null;
3507 
 
3508 
  public function __construct($vals=null) {
3509 
    if (!isset(self::$_TSPEC)) {
3510 
      self::$_TSPEC = array(
3511 
        1 => array(
3512 
          'var' => 'req',
3513 
          'type' => TType::STRUCT,
3514 
          'class' => '\TFetchResultsReq',
3515 
          ),
3516 
        );
3517 
    }
3518 
    if (is_array($vals)) {
3519 
      if (isset($vals['req'])) {
3520 
        $this->req = $vals['req'];
3521 
      }
3522 
    }
3523 
  }
3524 
 
3525 
  public function getName() {
3526 
    return 'TCLIService_FetchResults_args';
3527 
  }
3528 
 
3529 
  public function read($input)
3530 
  {
3531 
    $xfer = 0;
3532 
    $fname = null;
3533 
    $ftype = 0;
3534 
    $fid = 0;
3535 
    $xfer += $input->readStructBegin($fname);
3536 
    while (true)
3537 
    {
3538 
      $xfer += $input->readFieldBegin($fname, $ftype, $fid);
3539 
      if ($ftype == TType::STOP) {
3540 
        break;
3541 
      }
3542 
      switch ($fid)
3543 
      {
3544 
        case 1:
3545 
          if ($ftype == TType::STRUCT) {
3546 
            $this->req = new \TFetchResultsReq();
3547 
            $xfer += $this->req->read($input);
3548 
          } else {
3549 
            $xfer += $input->skip($ftype);
3550 
          }
3551 
          break;
3552 
        default:
3553 
          $xfer += $input->skip($ftype);
3554 
          break;
3555 
      }
3556 
      $xfer += $input->readFieldEnd();
3557 
    }
3558 
    $xfer += $input->readStructEnd();
3559 
    return $xfer;
3560 
  }
3561 
 
3562 
  public function write($output) {
3563 
    $xfer = 0;
3564 
    $xfer += $output->writeStructBegin('TCLIService_FetchResults_args');
3565 
    if ($this->req !== null) {
3566 
      if (!is_object($this->req)) {
3567 
        throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
3568 
      }
3569 
      $xfer += $output->writeFieldBegin('req', TType::STRUCT, 1);
3570 
      $xfer += $this->req->write($output);
3571 
      $xfer += $output->writeFieldEnd();
3572 
    }
3573 
    $xfer += $output->writeFieldStop();
3574 
    $xfer += $output->writeStructEnd();
3575 
    return $xfer;
3576 
  }
3577 
 
3578 
}
3579 
 
3580 
class TCLIService_FetchResults_result {
3581 
  static $_TSPEC;
3582 
 
3583 
  /**
3584 
   * @var \TFetchResultsResp
3585 
   */
3586 
  public $success = null;
3587 
 
3588 
  public function __construct($vals=null) {
3589 
    if (!isset(self::$_TSPEC)) {
3590 
      self::$_TSPEC = array(
3591 
 
3592 
          'var' => 'success',
3593 
          'type' => TType::STRUCT,
3594 
          'class' => '\TFetchResultsResp',
3595 
          ),
3596 
        );
3597 
    }
3598 
    if (is_array($vals)) {
3599 
      if (isset($vals['success'])) {
3600 
        $this->success = $vals['success'];
3601 
      }
3602 
    }
3603 
  }
3604 
 
3605 
  public function getName() {
3606 
    return 'TCLIService_FetchResults_result';
3607 
  }
3608 
 
3609 
  public function read($input)
3610 
  {
3611 
    $xfer = 0;
3612 
    $fname = null;
3613 
    $ftype = 0;
3614 
    $fid = 0;
3615 
    $xfer += $input->readStructBegin($fname);
3616 
    while (true)
3617 
    {
3618 
      $xfer += $input->readFieldBegin($fname, $ftype, $fid);
3619 
      if ($ftype == TType::STOP) {
3620 
        break;
3621 
      }
3622 
      switch ($fid)
3623 
      {
3624 
        case 0:
3625 
          if ($ftype == TType::STRUCT) {
3626 
            $this->success = new \TFetchResultsResp();
3627 
            $xfer += $this->success->read($input);
3628 
          } else {
3629 
            $xfer += $input->skip($ftype);
3630 
          }
3631 
          break;
3632 
        default:
3633 
          $xfer += $input->skip($ftype);
3634 
          break;
3635 
      }
3636 
      $xfer += $input->readFieldEnd();
3637 
    }
3638 
    $xfer += $input->readStructEnd();
3639 
    return $xfer;
3640 
  }
3641 
 
3642 
  public function write($output) {
3643 
    $xfer = 0;
3644 
    $xfer += $output->writeStructBegin('TCLIService_FetchResults_result');
3645 
    if ($this->success !== null) {
3646 
      if (!is_object($this->success)) {
3647 
        throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
3648 
      }
3649 
      $xfer += $output->writeFieldBegin('success', TType::STRUCT, 0);
3650 
      $xfer += $this->success->write($output);
3651 
      $xfer += $output->writeFieldEnd();
3652 
    }
3653 
    $xfer += $output->writeFieldStop();
3654 
    $xfer += $output->writeStructEnd();
3655 
    return $xfer;
3656 
  }
3657 
 
3658 
}
3659 
 
3660 
class TCLIService_GetDelegationToken_args {
3661 
  static $_TSPEC;
3662 
 
3663 
  /**
3664 
   * @var \TGetDelegationTokenReq
3665 
   */
3666 
  public $req = null;
3667 
 
3668 
  public function __construct($vals=null) {
3669 
    if (!isset(self::$_TSPEC)) {
3670 
      self::$_TSPEC = array(
3671 
        1 => array(
3672 
          'var' => 'req',
3673 
          'type' => TType::STRUCT,
3674 
          'class' => '\TGetDelegationTokenReq',
3675 
          ),
3676 
        );
3677 
    }
3678 
    if (is_array($vals)) {
3679 
      if (isset($vals['req'])) {
3680 
        $this->req = $vals['req'];
3681 
      }
3682 
    }
3683 
  }
3684 
 
3685 
  public function getName() {
3686 
    return 'TCLIService_GetDelegationToken_args';
3687 
  }
3688 
 
3689 
  public function read($input)
3690 
  {
3691 
    $xfer = 0;
3692 
    $fname = null;
3693 
    $ftype = 0;
3694 
    $fid = 0;
3695 
    $xfer += $input->readStructBegin($fname);
3696 
    while (true)
3697 
    {
3698 
      $xfer += $input->readFieldBegin($fname, $ftype, $fid);
3699 
      if ($ftype == TType::STOP) {
3700 
        break;
3701 
      }
3702 
      switch ($fid)
3703 
      {
3704 
        case 1:
3705 
          if ($ftype == TType::STRUCT) {
3706 
            $this->req = new \TGetDelegationTokenReq();
3707 
            $xfer += $this->req->read($input);
3708 
          } else {
3709 
            $xfer += $input->skip($ftype);
3710 
          }
3711 
          break;
3712 
        default:
3713 
          $xfer += $input->skip($ftype);
3714 
          break;
3715 
      }
3716 
      $xfer += $input->readFieldEnd();
3717 
    }
3718 
    $xfer += $input->readStructEnd();
3719 
    return $xfer;
3720 
  }
3721 
 
3722 
  public function write($output) {
3723 
    $xfer = 0;
3724 
    $xfer += $output->writeStructBegin('TCLIService_GetDelegationToken_args');
3725 
    if ($this->req !== null) {
3726 
      if (!is_object($this->req)) {
3727 
        throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
3728 
      }
3729 
      $xfer += $output->writeFieldBegin('req', TType::STRUCT, 1);
3730 
      $xfer += $this->req->write($output);
3731 
      $xfer += $output->writeFieldEnd();
3732 
    }
3733 
    $xfer += $output->writeFieldStop();
3734 
    $xfer += $output->writeStructEnd();
3735 
    return $xfer;
3736 
  }
3737 
 
3738 
}
3739 
 
3740 
class TCLIService_GetDelegationToken_result {
3741 
  static $_TSPEC;
3742 
 
3743 
  /**
3744 
   * @var \TGetDelegationTokenResp
3745 
   */
3746 
  public $success = null;
3747 
 
3748 
  public function __construct($vals=null) {
3749 
    if (!isset(self::$_TSPEC)) {
3750 
      self::$_TSPEC = array(
3751 
 
3752 
          'var' => 'success',
3753 
          'type' => TType::STRUCT,
3754 
          'class' => '\TGetDelegationTokenResp',
3755 
          ),
3756 
        );
3757 
    }
3758 
    if (is_array($vals)) {
3759 
      if (isset($vals['success'])) {
3760 
        $this->success = $vals['success'];
3761 
      }
3762 
    }
3763 
  }
3764 
 
3765 
  public function getName() {
3766 
    return 'TCLIService_GetDelegationToken_result';
3767 
  }
3768 
 
3769 
  public function read($input)
3770 
  {
3771 
    $xfer = 0;
3772 
    $fname = null;
3773 
    $ftype = 0;
3774 
    $fid = 0;
3775 
    $xfer += $input->readStructBegin($fname);
3776 
    while (true)
3777 
    {
3778 
      $xfer += $input->readFieldBegin($fname, $ftype, $fid);
3779 
      if ($ftype == TType::STOP) {
3780 
        break;
3781 
      }
3782 
      switch ($fid)
3783 
      {
3784 
        case 0:
3785 
          if ($ftype == TType::STRUCT) {
3786 
            $this->success = new \TGetDelegationTokenResp();
3787 
            $xfer += $this->success->read($input);
3788 
          } else {
3789 
            $xfer += $input->skip($ftype);
3790 
          }
3791 
          break;
3792 
        default:
3793 
          $xfer += $input->skip($ftype);
3794 
          break;
3795 
      }
3796 
      $xfer += $input->readFieldEnd();
3797 
    }
3798 
    $xfer += $input->readStructEnd();
3799 
    return $xfer;
3800 
  }
3801 
 
3802 
  public function write($output) {
3803 
    $xfer = 0;
3804 
    $xfer += $output->writeStructBegin('TCLIService_GetDelegationToken_result');
3805 
    if ($this->success !== null) {
3806 
      if (!is_object($this->success)) {
3807 
        throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
3808 
      }
3809 
      $xfer += $output->writeFieldBegin('success', TType::STRUCT, 0);
3810 
      $xfer += $this->success->write($output);
3811 
      $xfer += $output->writeFieldEnd();
3812 
    }
3813 
    $xfer += $output->writeFieldStop();
3814 
    $xfer += $output->writeStructEnd();
3815 
    return $xfer;
3816 
  }
3817 
 
3818 
}
3819 
 
3820 
class TCLIService_CancelDelegationToken_args {
3821 
  static $_TSPEC;
3822 
 
3823 
  /**
3824 
   * @var \TCancelDelegationTokenReq
3825 
   */
3826 
  public $req = null;
3827 
 
3828 
  public function __construct($vals=null) {
3829 
    if (!isset(self::$_TSPEC)) {
3830 
      self::$_TSPEC = array(
3831 
        1 => array(
3832 
          'var' => 'req',
3833 
          'type' => TType::STRUCT,
3834 
          'class' => '\TCancelDelegationTokenReq',
3835 
          ),
3836 
        );
3837 
    }
3838 
    if (is_array($vals)) {
3839 
      if (isset($vals['req'])) {
3840 
        $this->req = $vals['req'];
3841 
      }
3842 
    }
3843 
  }
3844 
 
3845 
  public function getName() {
3846 
    return 'TCLIService_CancelDelegationToken_args';
3847 
  }
3848 
 
3849 
  public function read($input)
3850 
  {
3851 
    $xfer = 0;
3852 
    $fname = null;
3853 
    $ftype = 0;
3854 
    $fid = 0;
3855 
    $xfer += $input->readStructBegin($fname);
3856 
    while (true)
3857 
    {
3858 
      $xfer += $input->readFieldBegin($fname, $ftype, $fid);
3859 
      if ($ftype == TType::STOP) {
3860 
        break;
3861 
      }
3862 
      switch ($fid)
3863 
      {
3864 
        case 1:
3865 
          if ($ftype == TType::STRUCT) {
3866 
            $this->req = new \TCancelDelegationTokenReq();
3867 
            $xfer += $this->req->read($input);
3868 
          } else {
3869 
            $xfer += $input->skip($ftype);
3870 
          }
3871 
          break;
3872 
        default:
3873 
          $xfer += $input->skip($ftype);
3874 
          break;
3875 
      }
3876 
      $xfer += $input->readFieldEnd();
3877 
    }
3878 
    $xfer += $input->readStructEnd();
3879 
    return $xfer;
3880 
  }
3881 
 
3882 
  public function write($output) {
3883 
    $xfer = 0;
3884 
    $xfer += $output->writeStructBegin('TCLIService_CancelDelegationToken_args');
3885 
    if ($this->req !== null) {
3886 
      if (!is_object($this->req)) {
3887 
        throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
3888 
      }
3889 
      $xfer += $output->writeFieldBegin('req', TType::STRUCT, 1);
3890 
      $xfer += $this->req->write($output);
3891 
      $xfer += $output->writeFieldEnd();
3892 
    }
3893 
    $xfer += $output->writeFieldStop();
3894 
    $xfer += $output->writeStructEnd();
3895 
    return $xfer;
3896 
  }
3897 
 
3898 
}
3899 
 
3900 
class TCLIService_CancelDelegationToken_result {
3901 
  static $_TSPEC;
3902 
 
3903 
  /**
3904 
   * @var \TCancelDelegationTokenResp
3905 
   */
3906 
  public $success = null;
3907 
 
3908 
  public function __construct($vals=null) {
3909 
    if (!isset(self::$_TSPEC)) {
3910 
      self::$_TSPEC = array(
3911 
 
3912 
          'var' => 'success',
3913 
          'type' => TType::STRUCT,
3914 
          'class' => '\TCancelDelegationTokenResp',
3915 
          ),
3916 
        );
3917 
    }
3918 
    if (is_array($vals)) {
3919 
      if (isset($vals['success'])) {
3920 
        $this->success = $vals['success'];
3921 
      }
3922 
    }
3923 
  }
3924 
 
3925 
  public function getName() {
3926 
    return 'TCLIService_CancelDelegationToken_result';
3927 
  }
3928 
 
3929 
  public function read($input)
3930 
  {
3931 
    $xfer = 0;
3932 
    $fname = null;
3933 
    $ftype = 0;
3934 
    $fid = 0;
3935 
    $xfer += $input->readStructBegin($fname);
3936 
    while (true)
3937 
    {
3938 
      $xfer += $input->readFieldBegin($fname, $ftype, $fid);
3939 
      if ($ftype == TType::STOP) {
3940 
        break;
3941 
      }
3942 
      switch ($fid)
3943 
      {
3944 
        case 0:
3945 
          if ($ftype == TType::STRUCT) {
3946 
            $this->success = new \TCancelDelegationTokenResp();
3947 
            $xfer += $this->success->read($input);
3948 
          } else {
3949 
            $xfer += $input->skip($ftype);
3950 
          }
3951 
          break;
3952 
        default:
3953 
          $xfer += $input->skip($ftype);
3954 
          break;
3955 
      }
3956 
      $xfer += $input->readFieldEnd();
3957 
    }
3958 
    $xfer += $input->readStructEnd();
3959 
    return $xfer;
3960 
  }
3961 
 
3962 
  public function write($output) {
3963 
    $xfer = 0;
3964 
    $xfer += $output->writeStructBegin('TCLIService_CancelDelegationToken_result');
3965 
    if ($this->success !== null) {
3966 
      if (!is_object($this->success)) {
3967 
        throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
3968 
      }
3969 
      $xfer += $output->writeFieldBegin('success', TType::STRUCT, 0);
3970 
      $xfer += $this->success->write($output);
3971 
      $xfer += $output->writeFieldEnd();
3972 
    }
3973 
    $xfer += $output->writeFieldStop();
3974 
    $xfer += $output->writeStructEnd();
3975 
    return $xfer;
3976 
  }
3977 
 
3978 
}
3979 
 
3980 
class TCLIService_RenewDelegationToken_args {
3981 
  static $_TSPEC;
3982 
 
3983 
  /**
3984 
   * @var \TRenewDelegationTokenReq
3985 
   */
3986 
  public $req = null;
3987 
 
3988 
  public function __construct($vals=null) {
3989 
    if (!isset(self::$_TSPEC)) {
3990 
      self::$_TSPEC = array(
3991 
        1 => array(
3992 
          'var' => 'req',
3993 
          'type' => TType::STRUCT,
3994 
          'class' => '\TRenewDelegationTokenReq',
3995 
          ),
3996 
        );
3997 
    }
3998 
    if (is_array($vals)) {
3999 
      if (isset($vals['req'])) {
4000 
        $this->req = $vals['req'];
4001 
      }
4002 
    }
4003 
  }
4004 
 
4005 
  public function getName() {
4006 
    return 'TCLIService_RenewDelegationToken_args';
4007 
  }
4008 
 
4009 
  public function read($input)
4010 
  {
4011 
    $xfer = 0;
4012 
    $fname = null;
4013 
    $ftype = 0;
4014 
    $fid = 0;
4015 
    $xfer += $input->readStructBegin($fname);
4016 
    while (true)
4017 
    {
4018 
      $xfer += $input->readFieldBegin($fname, $ftype, $fid);
4019 
      if ($ftype == TType::STOP) {
4020 
        break;
4021 
      }
4022 
      switch ($fid)
4023 
      {
4024 
        case 1:
4025 
          if ($ftype == TType::STRUCT) {
4026 
            $this->req = new \TRenewDelegationTokenReq();
4027 
            $xfer += $this->req->read($input);
4028 
          } else {
4029 
            $xfer += $input->skip($ftype);
4030 
          }
4031 
          break;
4032 
        default:
4033 
          $xfer += $input->skip($ftype);
4034 
          break;
4035 
      }
4036 
      $xfer += $input->readFieldEnd();
4037 
    }
4038 
    $xfer += $input->readStructEnd();
4039 
    return $xfer;
4040 
  }
4041 
 
4042 
  public function write($output) {
4043 
    $xfer = 0;
4044 
    $xfer += $output->writeStructBegin('TCLIService_RenewDelegationToken_args');
4045 
    if ($this->req !== null) {
4046 
      if (!is_object($this->req)) {
4047 
        throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
4048 
      }
4049 
      $xfer += $output->writeFieldBegin('req', TType::STRUCT, 1);
4050 
      $xfer += $this->req->write($output);
4051 
      $xfer += $output->writeFieldEnd();
4052 
    }
4053 
    $xfer += $output->writeFieldStop();
4054 
    $xfer += $output->writeStructEnd();
4055 
    return $xfer;
4056 
  }
4057 
 
4058 
}
4059 
 
4060 
class TCLIService_RenewDelegationToken_result {
4061 
  static $_TSPEC;
4062 
 
4063 
  /**
4064 
   * @var \TRenewDelegationTokenResp
4065 
   */
4066 
  public $success = null;
4067 
 
4068 
  public function __construct($vals=null) {
4069 
    if (!isset(self::$_TSPEC)) {
4070 
      self::$_TSPEC = array(
4071 
 
4072 
          'var' => 'success',
4073 
          'type' => TType::STRUCT,
4074 
          'class' => '\TRenewDelegationTokenResp',
4075 
          ),
4076 
        );
4077 
    }
4078 
    if (is_array($vals)) {
4079 
      if (isset($vals['success'])) {
4080 
        $this->success = $vals['success'];
4081 
      }
4082 
    }
4083 
  }
4084 
 
4085 
  public function getName() {
4086 
    return 'TCLIService_RenewDelegationToken_result';
4087 
  }
4088 
 
4089 
  public function read($input)
4090 
  {
4091 
    $xfer = 0;
4092 
    $fname = null;
4093 
    $ftype = 0;
4094 
    $fid = 0;
4095 
    $xfer += $input->readStructBegin($fname);
4096 
    while (true)
4097 
    {
4098 
      $xfer += $input->readFieldBegin($fname, $ftype, $fid);
4099 
      if ($ftype == TType::STOP) {
4100 
        break;
4101 
      }
4102 
      switch ($fid)
4103 
      {
4104 
        case 0:
4105 
          if ($ftype == TType::STRUCT) {
4106 
            $this->success = new \TRenewDelegationTokenResp();
4107 
            $xfer += $this->success->read($input);
4108 
          } else {
4109 
            $xfer += $input->skip($ftype);
4110 
          }
4111 
          break;
4112 
        default:
4113 
          $xfer += $input->skip($ftype);
4114 
          break;
4115 
      }
4116 
      $xfer += $input->readFieldEnd();
4117 
    }
4118 
    $xfer += $input->readStructEnd();
4119 
    return $xfer;
4120 
  }
4121 
 
4122 
  public function write($output) {
4123 
    $xfer = 0;
4124 
    $xfer += $output->writeStructBegin('TCLIService_RenewDelegationToken_result');
4125 
    if ($this->success !== null) {
4126 
      if (!is_object($this->success)) {
4127 
        throw new TProtocolException('Bad type in structure.', TProtocolException::INVALID_DATA);
4128 
      }
4129 
      $xfer += $output->writeFieldBegin('success', TType::STRUCT, 0);
4130 
      $xfer += $this->success->write($output);
4131 
      $xfer += $output->writeFieldEnd();
4132 
    }
4133 
    $xfer += $output->writeFieldStop();
4134 
    $xfer += $output->writeStructEnd();
4135 
    return $xfer;
4136 
  }
4137 
 
4138 
}
4139 
 
4140