Project

General

Profile

1
<?php
2
/*
3
 * Licensed to the Apache Software Foundation (ASF) under one
4
 * or more contributor license agreements. See the NOTICE file
5
 * distributed with this work for additional information
6
 * regarding copyright ownership. The ASF licenses this file
7
 * to you under the Apache License, Version 2.0 (the
8
 * "License"); you may not use this file except in compliance
9
 * with the License. You may obtain a copy of the License at
10
 *
11
 *   http://www.apache.org/licenses/LICENSE-2.0
12
 *
13
 * Unless required by applicable law or agreed to in writing,
14
 * software distributed under the License is distributed on an
15
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
16
 * KIND, either express or implied. See the License for the
17
 * specific language governing permissions and limitations
18
 * under the License.
19
 *
20
 * @package thrift
21
 */
22

    
23

    
24
/**
25
 * Data types that can be sent via Thrift
26
 */
27
class TType {
28
  const STOP   = 0;
29
  const VOID   = 1;
30
  const BOOL   = 2;
31
  const BYTE   = 3;
32
  const I08    = 3;
33
  const DOUBLE = 4;
34
  const I16    = 6;
35
  const I32    = 8;
36
  const I64    = 10;
37
  const STRING = 11;
38
  const UTF7   = 11;
39
  const STRUCT = 12;
40
  const MAP    = 13;
41
  const SET    = 14;
42
  const LST    = 15;    // N.B. cannot use LIST keyword in PHP!
43
  const UTF8   = 16;
44
  const UTF16  = 17;
45
}
46

    
47
/**
48
 * Message types for RPC
49
 */
50
class TMessageType {
51
  const CALL  = 1;
52
  const REPLY = 2;
53
  const EXCEPTION = 3;
54
  const ONEWAY = 4;
55
}
56

    
57
/**
58
 * NOTE(mcslee): This currently contains a ton of duplicated code from TBase
59
 * because we need to save CPU cycles and this is not yet in an extension.
60
 * Ideally we'd multiply-inherit TException from both Exception and Base, but
61
 * that's not possible in PHP and there are no modules either, so for now we
62
 * apologetically take a trip to HackTown.
63
 *
64
 * Can be called with standard Exception constructor (message, code) or with
65
 * Thrift Base object constructor (spec, vals).
66
 *
67
 * @param mixed $p1 Message (string) or type-spec (array)
68
 * @param mixed $p2 Code (integer) or values (array)
69
 */
70
class TException extends Exception {
71
  function __construct($p1=null, $p2=0) {
72
    if (is_array($p1) && is_array($p2)) {
73
      $spec = $p1;
74
      $vals = $p2;
75
      foreach ($spec as $fid => $fspec) {
76
        $var = $fspec['var'];
77
        if (isset($vals[$var])) {
78
          $this->$var = $vals[$var];
79
        }
80
      }
81
    } else {
82
      parent::__construct($p1, $p2);
83
    }
84
  }
85

    
86
  static $tmethod = array(TType::BOOL   => 'Bool',
87
                          TType::BYTE   => 'Byte',
88
                          TType::I16    => 'I16',
89
                          TType::I32    => 'I32',
90
                          TType::I64    => 'I64',
91
                          TType::DOUBLE => 'Double',
92
                          TType::STRING => 'String');
93

    
94
  private function _readMap(&$var, $spec, $input) {
95
    $xfer = 0;
96
    $ktype = $spec['ktype'];
97
    $vtype = $spec['vtype'];
98
    $kread = $vread = null;
99
    if (isset(TBase::$tmethod[$ktype])) {
100
      $kread = 'read'.TBase::$tmethod[$ktype];
101
    } else {
102
      $kspec = $spec['key'];
103
    }
104
    if (isset(TBase::$tmethod[$vtype])) {
105
      $vread = 'read'.TBase::$tmethod[$vtype];
106
    } else {
107
      $vspec = $spec['val'];
108
    }
109
    $var = array();
110
    $_ktype = $_vtype = $size = 0;
111
    $xfer += $input->readMapBegin($_ktype, $_vtype, $size);
112
    for ($i = 0; $i < $size; ++$i) {
113
      $key = $val = null;
114
      if ($kread !== null) {
115
        $xfer += $input->$kread($key);
116
      } else {
117
        switch ($ktype) {
118
        case TType::STRUCT:
119
          $class = $kspec['class'];
120
          $key = new $class();
121
          $xfer += $key->read($input);
122
          break;
123
        case TType::MAP:
124
          $xfer += $this->_readMap($key, $kspec, $input);
125
          break;
126
        case TType::LST:
127
          $xfer += $this->_readList($key, $kspec, $input, false);
128
          break;
129
        case TType::SET:
130
          $xfer += $this->_readList($key, $kspec, $input, true);
131
          break;
132
        }
133
      }
134
      if ($vread !== null) {
135
        $xfer += $input->$vread($val);
136
      } else {
137
        switch ($vtype) {
138
        case TType::STRUCT:
139
          $class = $vspec['class'];
140
          $val = new $class();
141
          $xfer += $val->read($input);
142
          break;
143
        case TType::MAP:
144
          $xfer += $this->_readMap($val, $vspec, $input);
145
          break;
146
        case TType::LST:
147
          $xfer += $this->_readList($val, $vspec, $input, false);
148
          break;
149
        case TType::SET:
150
          $xfer += $this->_readList($val, $vspec, $input, true);
151
          break;
152
        }
153
      }
154
      $var[$key] = $val;
155
    }
156
    $xfer += $input->readMapEnd();
157
    return $xfer;
158
  }
159

    
160
  private function _readList(&$var, $spec, $input, $set=false) {
161
    $xfer = 0;
162
    $etype = $spec['etype'];
163
    $eread = $vread = null;
164
    if (isset(TBase::$tmethod[$etype])) {
165
      $eread = 'read'.TBase::$tmethod[$etype];
166
    } else {
167
      $espec = $spec['elem'];
168
    }
169
    $var = array();
170
    $_etype = $size = 0;
171
    if ($set) {
172
      $xfer += $input->readSetBegin($_etype, $size);
173
    } else {
174
      $xfer += $input->readListBegin($_etype, $size);
175
    }
176
    for ($i = 0; $i < $size; ++$i) {
177
      $elem = null;
178
      if ($eread !== null) {
179
        $xfer += $input->$eread($elem);
180
      } else {
181
        $espec = $spec['elem'];
182
        switch ($etype) {
183
        case TType::STRUCT:
184
          $class = $espec['class'];
185
          $elem = new $class();
186
          $xfer += $elem->read($input);
187
          break;
188
        case TType::MAP:
189
          $xfer += $this->_readMap($elem, $espec, $input);
190
          break;
191
        case TType::LST:
192
          $xfer += $this->_readList($elem, $espec, $input, false);
193
          break;
194
        case TType::SET:
195
          $xfer += $this->_readList($elem, $espec, $input, true);
196
          break;
197
        }
198
      }
199
      if ($set) {
200
        $var[$elem] = true;
201
      } else {
202
        $var []= $elem;
203
      }
204
    }
205
    if ($set) {
206
      $xfer += $input->readSetEnd();
207
    } else {
208
      $xfer += $input->readListEnd();
209
    }
210
    return $xfer;
211
  }
212

    
213
  protected function _read($class, $spec, $input) {
214
    $xfer = 0;
215
    $fname = null;
216
    $ftype = 0;
217
    $fid = 0;
218
    $xfer += $input->readStructBegin($fname);
219
    while (true) {
220
      $xfer += $input->readFieldBegin($fname, $ftype, $fid);
221
      if ($ftype == TType::STOP) {
222
        break;
223
      }
224
      if (isset($spec[$fid])) {
225
        $fspec = $spec[$fid];
226
        $var = $fspec['var'];
227
        if ($ftype == $fspec['type']) {
228
          $xfer = 0;
229
          if (isset(TBase::$tmethod[$ftype])) {
230
            $func = 'read'.TBase::$tmethod[$ftype];
231
            $xfer += $input->$func($this->$var);
232
          } else {
233
            switch ($ftype) {
234
            case TType::STRUCT:
235
              $class = $fspec['class'];
236
              $this->$var = new $class();
237
              $xfer += $this->$var->read($input);
238
              break;
239
            case TType::MAP:
240
              $xfer += $this->_readMap($this->$var, $fspec, $input);
241
              break;
242
            case TType::LST:
243
              $xfer += $this->_readList($this->$var, $fspec, $input, false);
244
              break;
245
            case TType::SET:
246
              $xfer += $this->_readList($this->$var, $fspec, $input, true);
247
              break;
248
            }
249
          }
250
        } else {
251
          $xfer += $input->skip($ftype);
252
        }
253
      } else {
254
        $xfer += $input->skip($ftype);
255
      }
256
      $xfer += $input->readFieldEnd();
257
    }
258
    $xfer += $input->readStructEnd();
259
    return $xfer;
260
  }
261

    
262
  private function _writeMap($var, $spec, $output) {
263
    $xfer = 0;
264
    $ktype = $spec['ktype'];
265
    $vtype = $spec['vtype'];
266
    $kwrite = $vwrite = null;
267
    if (isset(TBase::$tmethod[$ktype])) {
268
      $kwrite = 'write'.TBase::$tmethod[$ktype];
269
    } else {
270
      $kspec = $spec['key'];
271
    }
272
    if (isset(TBase::$tmethod[$vtype])) {
273
      $vwrite = 'write'.TBase::$tmethod[$vtype];
274
    } else {
275
      $vspec = $spec['val'];
276
    }
277
    $xfer += $output->writeMapBegin($ktype, $vtype, count($var));
278
    foreach ($var as $key => $val) {
279
      if (isset($kwrite)) {
280
        $xfer += $output->$kwrite($key);
281
      } else {
282
        switch ($ktype) {
283
        case TType::STRUCT:
284
          $xfer += $key->write($output);
285
          break;
286
        case TType::MAP:
287
          $xfer += $this->_writeMap($key, $kspec, $output);
288
          break;
289
        case TType::LST:
290
          $xfer += $this->_writeList($key, $kspec, $output, false);
291
          break;
292
        case TType::SET:
293
          $xfer += $this->_writeList($key, $kspec, $output, true);
294
          break;
295
        }
296
      }
297
      if (isset($vwrite)) {
298
        $xfer += $output->$vwrite($val);
299
      } else {
300
        switch ($vtype) {
301
        case TType::STRUCT:
302
          $xfer += $val->write($output);
303
          break;
304
        case TType::MAP:
305
          $xfer += $this->_writeMap($val, $vspec, $output);
306
          break;
307
        case TType::LST:
308
          $xfer += $this->_writeList($val, $vspec, $output, false);
309
          break;
310
        case TType::SET:
311
          $xfer += $this->_writeList($val, $vspec, $output, true);
312
          break;
313
        }
314
      }
315
    }
316
    $xfer += $output->writeMapEnd();
317
    return $xfer;
318
  }
319

    
320
  private function _writeList($var, $spec, $output, $set=false) {
321
    $xfer = 0;
322
    $etype = $spec['etype'];
323
    $ewrite = null;
324
    if (isset(TBase::$tmethod[$etype])) {
325
      $ewrite = 'write'.TBase::$tmethod[$etype];
326
    } else {
327
      $espec = $spec['elem'];
328
    }
329
    if ($set) {
330
      $xfer += $output->writeSetBegin($etype, count($var));
331
    } else {
332
      $xfer += $output->writeListBegin($etype, count($var));
333
    }
334
    foreach ($var as $key => $val) {
335
      $elem = $set ? $key : $val;
336
      if (isset($ewrite)) {
337
        $xfer += $output->$ewrite($elem);
338
      } else {
339
        switch ($etype) {
340
        case TType::STRUCT:
341
          $xfer += $elem->write($output);
342
          break;
343
        case TType::MAP:
344
          $xfer += $this->_writeMap($elem, $espec, $output);
345
          break;
346
        case TType::LST:
347
          $xfer += $this->_writeList($elem, $espec, $output, false);
348
          break;
349
        case TType::SET:
350
          $xfer += $this->_writeList($elem, $espec, $output, true);
351
          break;
352
        }
353
      }
354
    }
355
    if ($set) {
356
      $xfer += $output->writeSetEnd();
357
    } else {
358
      $xfer += $output->writeListEnd();
359
    }
360
    return $xfer;
361
  }
362

    
363
  protected function _write($class, $spec, $output) {
364
    $xfer = 0;
365
    $xfer += $output->writeStructBegin($class);
366
    foreach ($spec as $fid => $fspec) {
367
      $var = $fspec['var'];
368
      if ($this->$var !== null) {
369
        $ftype = $fspec['type'];
370
        $xfer += $output->writeFieldBegin($var, $ftype, $fid);
371
        if (isset(TBase::$tmethod[$ftype])) {
372
          $func = 'write'.TBase::$tmethod[$ftype];
373
          $xfer += $output->$func($this->$var);
374
        } else {
375
          switch ($ftype) {
376
          case TType::STRUCT:
377
            $xfer += $this->$var->write($output);
378
            break;
379
          case TType::MAP:
380
            $xfer += $this->_writeMap($this->$var, $fspec, $output);
381
            break;
382
          case TType::LST:
383
            $xfer += $this->_writeList($this->$var, $fspec, $output, false);
384
            break;
385
          case TType::SET:
386
            $xfer += $this->_writeList($this->$var, $fspec, $output, true);
387
            break;
388
          }
389
        }
390
        $xfer += $output->writeFieldEnd();
391
      }
392
    }
393
    $xfer += $output->writeFieldStop();
394
    $xfer += $output->writeStructEnd();
395
    return $xfer;
396
  }
397

    
398
}
399

    
400
/**
401
 * Base class from which other Thrift structs extend. This is so that we can
402
 * cut back on the size of the generated code which is turning out to have a
403
 * nontrivial cost just to load thanks to the wondrously abysmal implementation
404
 * of PHP. Note that code is intentionally duplicated in here to avoid making
405
 * function calls for every field or member of a container..
406
 */
407
abstract class TBase {
408

    
409
  static $tmethod = array(TType::BOOL   => 'Bool',
410
                          TType::BYTE   => 'Byte',
411
                          TType::I16    => 'I16',
412
                          TType::I32    => 'I32',
413
                          TType::I64    => 'I64',
414
                          TType::DOUBLE => 'Double',
415
                          TType::STRING => 'String');
416

    
417
  abstract function read($input);
418

    
419
  abstract function write($output);
420

    
421
  public function __construct($spec=null, $vals=null) {
422
    if (is_array($spec) && is_array($vals)) {
423
      foreach ($spec as $fid => $fspec) {
424
        $var = $fspec['var'];
425
        if (isset($vals[$var])) {
426
          $this->$var = $vals[$var];
427
        }
428
      }
429
    }
430
  }
431

    
432
  private function _readMap(&$var, $spec, $input) {
433
    $xfer = 0;
434
    $ktype = $spec['ktype'];
435
    $vtype = $spec['vtype'];
436
    $kread = $vread = null;
437
    if (isset(TBase::$tmethod[$ktype])) {
438
      $kread = 'read'.TBase::$tmethod[$ktype];
439
    } else {
440
      $kspec = $spec['key'];
441
    }
442
    if (isset(TBase::$tmethod[$vtype])) {
443
      $vread = 'read'.TBase::$tmethod[$vtype];
444
    } else {
445
      $vspec = $spec['val'];
446
    }
447
    $var = array();
448
    $_ktype = $_vtype = $size = 0;
449
    $xfer += $input->readMapBegin($_ktype, $_vtype, $size);
450
    for ($i = 0; $i < $size; ++$i) {
451
      $key = $val = null;
452
      if ($kread !== null) {
453
        $xfer += $input->$kread($key);
454
      } else {
455
        switch ($ktype) {
456
        case TType::STRUCT:
457
          $class = $kspec['class'];
458
          $key = new $class();
459
          $xfer += $key->read($input);
460
          break;
461
        case TType::MAP:
462
          $xfer += $this->_readMap($key, $kspec, $input);
463
          break;
464
        case TType::LST:
465
          $xfer += $this->_readList($key, $kspec, $input, false);
466
          break;
467
        case TType::SET:
468
          $xfer += $this->_readList($key, $kspec, $input, true);
469
          break;
470
        }
471
      }
472
      if ($vread !== null) {
473
        $xfer += $input->$vread($val);
474
      } else {
475
        switch ($vtype) {
476
        case TType::STRUCT:
477
          $class = $vspec['class'];
478
          $val = new $class();
479
          $xfer += $val->read($input);
480
          break;
481
        case TType::MAP:
482
          $xfer += $this->_readMap($val, $vspec, $input);
483
          break;
484
        case TType::LST:
485
          $xfer += $this->_readList($val, $vspec, $input, false);
486
          break;
487
        case TType::SET:
488
          $xfer += $this->_readList($val, $vspec, $input, true);
489
          break;
490
        }
491
      }
492
      $var[$key] = $val;
493
    }
494
    $xfer += $input->readMapEnd();
495
    return $xfer;
496
  }
497

    
498
  private function _readList(&$var, $spec, $input, $set=false) {
499
    $xfer = 0;
500
    $etype = $spec['etype'];
501
    $eread = $vread = null;
502
    if (isset(TBase::$tmethod[$etype])) {
503
      $eread = 'read'.TBase::$tmethod[$etype];
504
    } else {
505
      $espec = $spec['elem'];
506
    }
507
    $var = array();
508
    $_etype = $size = 0;
509
    if ($set) {
510
      $xfer += $input->readSetBegin($_etype, $size);
511
    } else {
512
      $xfer += $input->readListBegin($_etype, $size);
513
    }
514
    for ($i = 0; $i < $size; ++$i) {
515
      $elem = null;
516
      if ($eread !== null) {
517
        $xfer += $input->$eread($elem);
518
      } else {
519
        $espec = $spec['elem'];
520
        switch ($etype) {
521
        case TType::STRUCT:
522
          $class = $espec['class'];
523
          $elem = new $class();
524
          $xfer += $elem->read($input);
525
          break;
526
        case TType::MAP:
527
          $xfer += $this->_readMap($elem, $espec, $input);
528
          break;
529
        case TType::LST:
530
          $xfer += $this->_readList($elem, $espec, $input, false);
531
          break;
532
        case TType::SET:
533
          $xfer += $this->_readList($elem, $espec, $input, true);
534
          break;
535
        }
536
      }
537
      if ($set) {
538
        $var[$elem] = true;
539
      } else {
540
        $var []= $elem;
541
      }
542
    }
543
    if ($set) {
544
      $xfer += $input->readSetEnd();
545
    } else {
546
      $xfer += $input->readListEnd();
547
    }
548
    return $xfer;
549
  }
550

    
551
  protected function _read($class, $spec, $input) {
552
    $xfer = 0;
553
    $fname = null;
554
    $ftype = 0;
555
    $fid = 0;
556
    $xfer += $input->readStructBegin($fname);
557
    while (true) {
558
      $xfer += $input->readFieldBegin($fname, $ftype, $fid);
559
      if ($ftype == TType::STOP) {
560
        break;
561
      }
562
      if (isset($spec[$fid])) {
563
        $fspec = $spec[$fid];
564
        $var = $fspec['var'];
565
        if ($ftype == $fspec['type']) {
566
          $xfer = 0;
567
          if (isset(TBase::$tmethod[$ftype])) {
568
            $func = 'read'.TBase::$tmethod[$ftype];
569
            $xfer += $input->$func($this->$var);
570
          } else {
571
            switch ($ftype) {
572
            case TType::STRUCT:
573
              $class = $fspec['class'];
574
              $this->$var = new $class();
575
              $xfer += $this->$var->read($input);
576
              break;
577
            case TType::MAP:
578
              $xfer += $this->_readMap($this->$var, $fspec, $input);
579
              break;
580
            case TType::LST:
581
              $xfer += $this->_readList($this->$var, $fspec, $input, false);
582
              break;
583
            case TType::SET:
584
              $xfer += $this->_readList($this->$var, $fspec, $input, true);
585
              break;
586
            }
587
          }
588
        } else {
589
          $xfer += $input->skip($ftype);
590
        }
591
      } else {
592
        $xfer += $input->skip($ftype);
593
      }
594
      $xfer += $input->readFieldEnd();
595
    }
596
    $xfer += $input->readStructEnd();
597
    return $xfer;
598
  }
599

    
600
  private function _writeMap($var, $spec, $output) {
601
    $xfer = 0;
602
    $ktype = $spec['ktype'];
603
    $vtype = $spec['vtype'];
604
    $kwrite = $vwrite = null;
605
    if (isset(TBase::$tmethod[$ktype])) {
606
      $kwrite = 'write'.TBase::$tmethod[$ktype];
607
    } else {
608
      $kspec = $spec['key'];
609
    }
610
    if (isset(TBase::$tmethod[$vtype])) {
611
      $vwrite = 'write'.TBase::$tmethod[$vtype];
612
    } else {
613
      $vspec = $spec['val'];
614
    }
615
    $xfer += $output->writeMapBegin($ktype, $vtype, count($var));
616
    foreach ($var as $key => $val) {
617
      if (isset($kwrite)) {
618
        $xfer += $output->$kwrite($key);
619
      } else {
620
        switch ($ktype) {
621
        case TType::STRUCT:
622
          $xfer += $key->write($output);
623
          break;
624
        case TType::MAP:
625
          $xfer += $this->_writeMap($key, $kspec, $output);
626
          break;
627
        case TType::LST:
628
          $xfer += $this->_writeList($key, $kspec, $output, false);
629
          break;
630
        case TType::SET:
631
          $xfer += $this->_writeList($key, $kspec, $output, true);
632
          break;
633
        }
634
      }
635
      if (isset($vwrite)) {
636
        $xfer += $output->$vwrite($val);
637
      } else {
638
        switch ($vtype) {
639
        case TType::STRUCT:
640
          $xfer += $val->write($output);
641
          break;
642
        case TType::MAP:
643
          $xfer += $this->_writeMap($val, $vspec, $output);
644
          break;
645
        case TType::LST:
646
          $xfer += $this->_writeList($val, $vspec, $output, false);
647
          break;
648
        case TType::SET:
649
          $xfer += $this->_writeList($val, $vspec, $output, true);
650
          break;
651
        }
652
      }
653
    }
654
    $xfer += $output->writeMapEnd();
655
    return $xfer;
656
  }
657

    
658
  private function _writeList($var, $spec, $output, $set=false) {
659
    $xfer = 0;
660
    $etype = $spec['etype'];
661
    $ewrite = null;
662
    if (isset(TBase::$tmethod[$etype])) {
663
      $ewrite = 'write'.TBase::$tmethod[$etype];
664
    } else {
665
      $espec = $spec['elem'];
666
    }
667
    if ($set) {
668
      $xfer += $output->writeSetBegin($etype, count($var));
669
    } else {
670
      $xfer += $output->writeListBegin($etype, count($var));
671
    }
672
    foreach ($var as $key => $val) {
673
      $elem = $set ? $key : $val;
674
      if (isset($ewrite)) {
675
        $xfer += $output->$ewrite($elem);
676
      } else {
677
        switch ($etype) {
678
        case TType::STRUCT:
679
          $xfer += $elem->write($output);
680
          break;
681
        case TType::MAP:
682
          $xfer += $this->_writeMap($elem, $espec, $output);
683
          break;
684
        case TType::LST:
685
          $xfer += $this->_writeList($elem, $espec, $output, false);
686
          break;
687
        case TType::SET:
688
          $xfer += $this->_writeList($elem, $espec, $output, true);
689
          break;
690
        }
691
      }
692
    }
693
    if ($set) {
694
      $xfer += $output->writeSetEnd();
695
    } else {
696
      $xfer += $output->writeListEnd();
697
    }
698
    return $xfer;
699
  }
700

    
701
  protected function _write($class, $spec, $output) {
702
    $xfer = 0;
703
    $xfer += $output->writeStructBegin($class);
704
    foreach ($spec as $fid => $fspec) {
705
      $var = $fspec['var'];
706
      if ($this->$var !== null) {
707
        $ftype = $fspec['type'];
708
        $xfer += $output->writeFieldBegin($var, $ftype, $fid);
709
        if (isset(TBase::$tmethod[$ftype])) {
710
          $func = 'write'.TBase::$tmethod[$ftype];
711
          $xfer += $output->$func($this->$var);
712
        } else {
713
          switch ($ftype) {
714
          case TType::STRUCT:
715
            $xfer += $this->$var->write($output);
716
            break;
717
          case TType::MAP:
718
            $xfer += $this->_writeMap($this->$var, $fspec, $output);
719
            break;
720
          case TType::LST:
721
            $xfer += $this->_writeList($this->$var, $fspec, $output, false);
722
            break;
723
          case TType::SET:
724
            $xfer += $this->_writeList($this->$var, $fspec, $output, true);
725
            break;
726
          }
727
        }
728
        $xfer += $output->writeFieldEnd();
729
      }
730
    }
731
    $xfer += $output->writeFieldStop();
732
    $xfer += $output->writeStructEnd();
733
    return $xfer;
734
  }
735
}
736

    
737
class TApplicationException extends TException {
738
  static $_TSPEC =
739
    array(1 => array('var' => 'message',
740
                     'type' => TType::STRING),
741
          2 => array('var' => 'code',
742
                     'type' => TType::I32));
743

    
744
  const UNKNOWN = 0;
745
  const UNKNOWN_METHOD = 1;
746
  const INVALID_MESSAGE_TYPE = 2;
747
  const WRONG_METHOD_NAME = 3;
748
  const BAD_SEQUENCE_ID = 4;
749
  const MISSING_RESULT = 5;
750
  const INTERNAL_ERROR = 6;
751
  const PROTOCOL_ERROR = 7;
752

    
753
  function __construct($message=null, $code=0) {
754
    parent::__construct($message, $code);
755
  }
756

    
757
  public function read($output) {
758
    return $this->_read('TApplicationException', self::$_TSPEC, $output);
759
  }
760

    
761
  public function write($output) {
762
    $xfer = 0;
763
    $xfer += $output->writeStructBegin('TApplicationException');
764
    if ($message = $this->getMessage()) {
765
      $xfer += $output->writeFieldBegin('message', TType::STRING, 1);
766
      $xfer += $output->writeString($message);
767
      $xfer += $output->writeFieldEnd();
768
    }
769
    if ($code = $this->getCode()) {
770
      $xfer += $output->writeFieldBegin('type', TType::I32, 2);
771
      $xfer += $output->writeI32($code);
772
      $xfer += $output->writeFieldEnd();
773
    }
774
    $xfer += $output->writeFieldStop();
775
    $xfer += $output->writeStructEnd();
776
    return $xfer;
777
  }
778
}
779

    
780
/**
781
 * Set global THRIFT ROOT automatically via inclusion here
782
 */
783
if (!isset($GLOBALS['THRIFT_ROOT'])) {
784
  $GLOBALS['THRIFT_ROOT'] = dirname(__FILE__);
785
}
786
include_once $GLOBALS['THRIFT_ROOT'].'/protocol/TProtocol.php';
787
include_once $GLOBALS['THRIFT_ROOT'].'/transport/TTransport.php';
(1-1/2)