summaryrefslogblamecommitdiffstats
path: root/src/main/java/org/openslx/bwlp/thrift/iface/SatelliteServer.java
blob: 3565c4ab714297b5e2b3ca74e6fa198cbacd7520 (plain) (tree)
5175
5176
5177
5178
5179
5180
5181
5182
5183
5184
5185
5186
5187
5188
5189
5190
5191
5192
5193
5194
5195
5196
5197
5198
5199
5200
5201
5202
5203
5204
5205
5206
5207
5208
5209
5210
5211
5212
5213
5214
5215
5216
5217
5218
5219
5220
5221
5222
5223
5224
5225
5226
5227
5228
5229
5230
5231
5232
5233
5234
5235
5236
5237
5238
5239
5240
5241
5242
5243
5244
5245
5246
5247
5248
5249
5250
5251
5252
5253
5254
5255
5256
5257
5258
5259
5260
5261
5262
5263
5264
5265
5266
5267
5268
5269
5270
5271
5272
5273
5274
5275
5276
5277
5278
5279
5280
5281
5282
5283
5284
5285
5286
5287
5288
5289
5290
5291
5292
5293
5294
5295
5296
5297
5298
5299
5300
5301
5302
5303
5304
5305
5306
5307
5308
5309
5310
5311
5312
5313
5314
5315
5316
5317
5318
5319
5320
5321
5322
5323
5324
5325
5326
5327
5328
5329
5330
5331
5332
5333
5334
5335
5336
5337
5338
5339
5340
5341
5342
5343
5344
5345
5346
5347
5348
5349
5350
5351
5352
5353
5354
5355
5356
5357
5358
5359
5360
5361
5362
5363
5364
5365
5366
5367
5368
5369
5370
5371
5372
5373
5374
5375
5376
5377
5378
5379
5380
5381
5382
5383
5384
5385
5386
5387
5388
5389
5390
5391
5392
5393
5394
5395
5396
5397
5398
5399
5400
5401
5402
5403
5404
5405
5406
5407
5408
5409
5410
5411
5412
5413
5414
5415
5416
5417
5418
5419
5420
5421
5422
5423
5424
5425
5426
5427
5428
5429
5430
5431
5432
5433
5434
5435
5436
5437
5438
5439
5440
5441
5442
5443
5444
5445
5446
5447
5448
5449
5450
5451
5452
5453
5454
5455
5456
5457
5458
5459
5460
5461
5462
5463
5464
5465
5466
5467
5468
5469
5470
5471
5472
5473
5474
5475
5476
5477
5478
5479
5480
5481
5482
5483
5484
5485
5486
5487
5488
5489
5490
5491
5492
5493
5494
5495
5496
5497
5498
5499
5500
5501
5502
5503
5504
5505
5506
5507
5508
5509
5510
5511
5512
5513
5514
5515
5516
5517
5518
5519
5520
5521
5522
5523
5524
5525
5526
5527
5528
5529
5530
5531
5532
5533
5534
5535
5536
5537
5538
5539
5540
5541
5542
5543
5544
5545
5546
5547
5548
5549
5550
5551
5552
5553
5554
5555
5556
5557
5558
5559
5560
5561
5562
5563
5564
5565
5566
5567
5568
5569
5570
5571
5572
5573
5574
5575
5576
5577
5578
5579
5580
5581
5582
5583
5584
5585
5586
5587
5588
5589
5590
5591
5592
5593
5594
5595
5596
5597
5598
5599
5600
5601
5602
5603
5604
5605
5606
5607
5608
5609
5610
5611
5612
5613
5614
5615
5616
5617
5618
5619
5620
5621
5622
5623
5624
5625
5626
5627
5628
5629
5630
5631
5632
5633
5634
5635
5636
5637
5638
5639
5640
5641
5642
5643
5644
5645
5646
5647
5648
5649
5650
5651
5652
5653
5654
5655
5656
5657
5658
5659
5660
5661
5662
5663
5664
5665
5666
5667
5668
5669
5670
5671
5672
5673
5674
5675
5676
5677
5678
5679
5680
5681
5682
5683
5684
5685
5686
5687
5688
5689
5690
5691
5692
5693
5694
5695
5696
5697
5698
5699
5700
5701
5702
5703
5704
5705
5706
5707
5708
5709
5710
5711
5712
5713
5714
5715
5716
5717
5718
5719
5720
5721
5722
5723
5724
5725
5726
5727
5728
5729
5730
5731
5732
5733
5734
5735
5736
5737
5738
5739
5740
5741
5742
5743
5744
5745
5746
5747
5748
5749
5750
5751
5752
5753
5754
5755
5756
5757
5758
5759
5760
5761
5762
5763
5764
5765
5766
5767
5768
5769
5770
5771
5772
5773
5774
5775
5776
11406
11407
11408
11409
11410
11411
11412
11413
11414
11415
11416
11417
11418
11419
11420
11421
11422
11423
11424
11425
11426
11427
11428
11429
11430
11431
11432
11433
11434
11435
11436
11437
11438
11439
11440
11441
11442
11443
11444
11445
11446
11447
11448
11449
11450
11451
11452
11453
11454
11455
11456
11457
11458
11459
11460
11461
11462
11463
11464
11465
11466
11467
11468
11469
11470
11471
11472
11473
11474
11475
11476
11477
11478
11479
11480
11481
11482
11483
11484
11485
11486
11487
11488
11489
11490
11491
11492
11493
11494
11495
11496
11497
11498
11499
11500
11501
11502
11503
11504
11505
11506
11507
11508
11509
11510
11511
11512
11513
11514
11515
11516
11517
11518
11519
11520
11521
11522
11523
11524
11525
11526
11527
11528
11529
11530
11531
11532
11533
11534
11535
11536
11537
11538
11539
11540
11541
11542
11543
11544
11545
11546
11547
11548
11549
11550
11551
11552
11553
11554
11555
11556
11557
11558
11559
11560
11561
11562
11563
11564
11565
11566
11567
11568
11569
11570
11571
11572
11573
11574
11575
11576
11577
11578
11579
11580
11581
11582
11583
11584
11585
11586
11587
11588
11589
11590
11591
11592
11593
11594
11595
11596
11597
11598
11599
11600
11601
11602
11603
11604
11605
11606
11607
11608
11609
11610
11611
11612
11613
11614
11615
11616
11617
11618
11619
11620
11621
11622
11623
11624
11625
11626
11627
11628
11629
11630
11631
11632
11633
11634
11635
11636
11637
11638
11639
11640
11641
11642
11643
11644
11645
11646
11647
11648
11649
11650
11651
11652
11653
11654
11655
11656
11657
11658
11659
11660
11661
11662
11663
11664
11665
11666
11667
11668
11669
11670
11671
11672
11673
11674
11675
11676
11677
11678
11679
11680
11681
11682
11683
11684
11685
11686
11687
11688
11689
11690
11691
11692
11693
11694
11695
11696
11697
11698
11699
11700
11701
11702
11703
11704
11705
11706
11707
11708
11709
11710
11711
11712
11713
11714
11715
11716
11717
11718
11719
11720
11721
11722
11723
11724
11725
11726
11727
11728
11729
11730
11731
11732
11733
11734
11735
11736
11737
11738
11739
11740
11741
11742
11743
11744
11745
11746
11747
11748
11749
11750
11751
11752
11753
11754
11755
11756
11757
11758
11759
11760
11761
11762
11763
11764
11765
11766
11767
11768
11769
11770
11771
11772
11773
11774
11775
11776
11777
11778
11779
11780
11781
11782
11783
11784
11785
11786
11787
11788
11789
11790
11791
11792
11793
11794
11795
11796
11797
11798
11799
11800
11801
11802
11803
11804
11805
11806
11807
11808
11809
11810
11811
11812
11813
11814
11815
11816
11817
11818
11819
11820
11821
11822
11823
11824
11825
11826
11827
11828
11829
11830
11831
11832
11833
11834
11835
11836
11837
11838
11839
11840
11841
11842
11843
11844
11845
11846
11847
11848
11849
11850
11851
11852
11853
11854
11855
11856
11857
11858
11859
11860
11861
11862
11863
11864
11865
11866
11867
11868
11869
11870
11871
11872
11873
11874
11875
11876
11877
11878
11879
11880
11881
11882
11883
11884
11885
11886
11887
11888
11889
11890
11891
11892
11893
11894
11895
11896
11897
11898
11899
11900
11901
11902
11903
11904
11905
11906
11907
11908
11909
11910
11911
11912
11913
11914
11915
11916
11917
11918
11919
11920
11921
11922
11923
11924
11925
11926
11927
11928
11929
11930
11931
11932
11933
11934
11935
11936
11937
11938
11939
11940
11941
11942
11943
11944
11945
11946
11947
11948
11949
11950
11951
11952
11953
11954
11955
11956
11957
11958
11959
11960
11961
11962
11963
11964
11965
11966
11967
11968
11969
11970
11971
11972
11973
11974
11975
11976
11977
11978
11979
11980
11981
11982
11983
11984
11985
11986
11987
11988
11989
11990
11991
11992
11993
11994
11995
11996
11997
11998
11999
12000
12001
12002
12003
12004
12005
12006
12007
12008
12009
12010
12011
12012
12013
12014
12015
12016
12017
12018
12019
12020
12021
12022
12023
12024
12025
12026
12027
12028
12029
12030
12031
12032
12033
12034
12035
12036
12037
12038
12039
12040
12041
12042
12043
12044
12045
12046
12047
12048
12049
12050
12051
12052
12053
12054
12055
12056
12057
12058
12059
12060
12061
12062
12063
12064
12065
12066
12067
12068
12069
12070
12071
12072
12073
12074
12075
12076
12077
12078
12079
12080
12081
12082
12083
12084
12085
12086
12087
12088
12089
12090
12091
12092
12093
12094
12095
12096
12097
12098
12099
12100
12101
12102
12103
12104
12105
12106
12107
12108
12109
12110
12111
12112
12113
12114
12115
12116
12117
12118
12119
12120
12121
12122
12123
12124
12125
12126
12127
12128
12129
12130
12131
12132
12133
12134
12135
12136
12137
12138
12139
12140
12141
12142
12143
12144
12145
12146
12147
12148
12149
12150
12151
12152
12153
12154
12155
12156
12157
12158
12159
12160
12161
12162
12163
12164
12165
12166
12167
12168
12169
12170
12171
12172
12173
12174
12175
12176
12177
12178
12179
12180
12181
12182
12183
12184
12185
12186
12187
12188
12189
12190
12191
12192
12193
12194
12195
12196
12197
12198
12199
12200
12201
12202
12203
12204
12205
12206
12207
12208
12209
12210
12211
12212
12213
12214
12215
12216
12217
12218
12219
12220
12221
12222
12223
12224
12225
12226
12227
12228
12229
12230
12231
12232
12233
12234
12235
12236
12237
12238
12239
12240
12241
12242
12243
12244
12245
12246
12247
12248
12249
12250
12251
12252
12253
12254
12255
12256
12257
12258
12259
12260
12261
12262
12263
12264
12265
12266
12267
12268
12269
12270
12271
12272
12273
12274
12275
12276
12277
12278
12279
12280
12281
12282
12283
12284
12285
12286
12287
12288
12289
12290
12291
12292
12293
12294
12295
12296
12297
12298
12299
12300
12301
12302
12303
12304
12305
12306
12307
12308
12309
12310
12311
12312
12313
12314
12315
12316
12317
12318
12319
12320
12321
12322
12323
12324
12325
12326
12327
12328
12329
12330
12331
12332
12333
12334
12335
12336
12337
12338
12339
12340
12341
12342
12343
12344
12345
12346
12347
12348
12349
12350
12351
12352
12353
12354
12355
12356
12357
12358
12359
12360
12361
12362
12363
12364
12365
12366
12367
12368
12369
12370
12371
12372
12373
12374
12375
12376
12377
12378
12379
12380
12381
12382
12383
12384
12385
12386
12387
12388
12389
12390
12391
12392
12393
12394
12395
12396
12397
12398
12399
12400
12401
12402
12403
12404
12405
12406
12407
12408
12409
12410
12411
12412
12413
12414
12415
12416
12417
12418
12419
12420
12421
12422
12423
12424
12425
12426
12427
12428
12429
12430
12431
12432
12433
12434
12435
12436
12437
12438
12439
12440
12441
12442
12443
12444
12445
12446
12447
12448
12449
12450
12451
12452
12453
12454
12455
12456
12457
12458
12459
12460
12461
12462
12463
12464
12465
12466
12467
12468
12469
12470
12471
12472
12473
12474
12475
12476
12477
12478
12479
12480
12481
12482
12483
12484
12485
12486
12487
12488
12489
12490
12491
12492
12493
12494
12495
12496
12497
12498
12499
12500
12501
12502
12503
12504
12505
12506
12507
12508
12509
12510
12511
12512
12513
12514
12515
12516
12517
12518
12519
12520
12521
12522
12523
12524
12525
12526
12527
12528
12529
12530
12531
12532
12533
12534
12535
12536
13354
13355
13356
13357
13358
13359
13360
13361
13362
13363
13364
13365
13366
13367
13368
13369
13370
13371
13372
13373
13374
13375
13376
13377
13378
13379
13380
13381
13382
13383
13384
13385
13386
13387
13388
13389
13390
13391
13392
13393
13394
13395
13396
13397
13398
13399
13400
13401
13402
13403
13404
13405
13406
13407
13408
13409
13410
13411
13412
13413
13414
13415
13416
13417
13418
13419
13420
13421
13422
13423
13424
13425
13426
13427
13428
13429
13430
13431
13432
13433
13434
13435
13436
13437
13438
13439
13440
13441
13442
13443
13444
13445
13446
13447
13448
13449
13450
13451
13452
13453
13454
13455
13456
13457
13458
13459
13460
13461
13462
13463
13464
13465
13466
13467
13468
13469
13470
13471
13472
13473
13474
13475
13476
13477
13478
13479
13480
13481
13482
13483
13484
13485
13486
13487
13488
13489
13490
13491
13492
13493
13494
13495
13496
13497
13498
13499
13500
13501
13502
13503
13504
13505
13506
13507
13508
13509
13510
13511
13512
13513
13514
13515
13516
13517
13518
13519
13520
13521
13522
13523
13524
13525
13526
13527
13528
13529
13530
13531
13532
13533
13534
13535
13536
13537
13538
13539
13540
13541
13542
13543
13544
13545
13546
13547
13548
13549
13550
13551
13552
13553
13554
13555
13556
13557
13558
13559
13560
13561
13562
13563
13564
13565
13566
13567
13568
13569
13570
13571
13572
13573
13574
13575
13576
13577
13578
13579
13580
13581
13582
13583
13584
13585
13586
13587
13588
13589
13590
13591
13592
13593
13594
13595
13596
13597
13598
13599
13600
13601
13602
13603
13604
13605
13606
13607
13608
13609
13610
13611
13612
13613
13614
13615
13616
13617
13618
13619
13620
13621
13622
13623
13624
13625
13626
13627
13628
13629
13630
13631
13632
13633
13634
13635
13636
13637
13638
13639
13640
13641
13642
13643
13644
13645
13646
13647
13648
13649
13650
13651
13652
13653
13654
13655
13656
13657
13658
13659
13660
13661
13662
13663
13664
13665
13666
13667
13668
13669
13670
13671
13672
13673
13674
13675
13676
13677
13678
13679
13680
13681
13682
13683
13684
13685
13686
13687
13688
13689
13690
13691
13692
13693
13694
13695
13696
13697
13698
13699
13700
13701
13702
13703
13704
13705
13706
13707
13708
13709
13710
13711
13712
13713
13714
13715
13716
13717
13718
13719
13720
13721
13722
13723
13724
13725
13726
13727
13728
13729
13730
13731
13732
13733
13734
13735
13736
13737
13738
13739
13740
13741
13742
13743
13744
13745
13746
13747
13748
13749
13750
13751
13752
13753
13754
13755
13756
13757
13758
13759
13760
13761
13762
13763
13764
13765
13766
13767
13768
13769
13770
13771
13772
13773
13774
13775
13776
13777
13778
13779
13780
13781
13782
13783
13784
13785
13786
13787
13788
13789
13790
13791
13792
13793
13794
13795
13796
13797
13798
13799
13800
13801
13802
13803
13804
13805
13806
13807
13808
13809
13810
13811
13812
13813
13814
13815
13816
13817
13818
13819
13820
13821
13822
13823
13824
13825
13826
13827
13828
13829
13830
13831
13832
13833
13834
13835
13836
13837
13838
13839
13840
13841
13842
13843
13844
13845
13846
13847
13848
13849
13850
13851
13852
13853
13854
13855
13856
13857
13858
13859
13860
13861
13862
13863
13864
13865
13866
13867
13868
13869
13870
13871
13872
13873
13874
13875
13876
13877
13878
13879
13880
13881
13882
13883
13884
13885
13886
13887
13888
13889
13890
13891
13892
13893
13894
13895
13896
13897
13898
13899
13900
13901
13902
13903
13904
13905
13906
13907
13908
13909
13910
13911
13912
13913
13914
13915
13916
13917
13918
13919
13920
13921
13922
13923
13924
13925
13926
13927
13928
13929
13930
13931
13932
13933
13934
13935
13936
13937
13938
13939
13940
13941
13942
13943
13944
13945
13946
13947
13948
13949
13950
13951
13952
13953
13954
13955
13956
13957
13958
13959
13960
13961
13962
13963
13964
13965
13966
13967
13968
13969
13970
13971
13972
13973
13974
13975
13976
13977
13978
13979
13980
13981
13982
13983
13984
13985
13986
13987
13988
13989
13990
13991
13992
13993
13994
13995
13996
13997
13998
13999
14000
14001
14002
14003
14004
14005
14006
14007
14008
14009
14010
14011
14012
14013
14014
14015
14016
14017
14018
14019
14020
14021
14022
14023
14024
14025
14026
14027
14028
14029
14030
14031
14032
14033
14034
14035
14036
14037
14038
14039
14040
14041
14042
14043
14044
14045
14046
14047
14048
14049
14050
14051
14052
14053
14054
14055
14056
14057
14058
14059
14060
14061
14062
14063
14064
14065
14066
14067
14068
14069
14070
14071
14072
14073
14074
14075
14076
14077
14078
14079
14080
14081
14082
14083
14084
14085
14086
14087
14088
14089
14090
14091
14092
14093
14094
14095
14096
14097
14098
14099
14100
14101
14102
14103
14104
14105
14106
14107
14108
14109
14110
14111
14112
14113
14114
14115
14116
14117
14118
14119
14120
14121
14122
14123
14124
14125
14126
14127
14128
14129
14130
14131
14132
14133
14134
14135
14136
14137
14138
14139
14140
14141
14142
14143
14144
14145
14146
14147
14148
14149
14150
14151
14152
14153
14154
14155
14156
14157
14158
14159
14160
14161
14162
14163
14164
14165
14166
14167
14168
14169
14170
14171
14172
14173
14174
14175
14176
14177
14178
14179
14180
14181
14182
14183
14184
14185
14186
14187
14188
14189
14190
14191
14192
14193
14194
14195
14196
14197
14198
14199
14200
14201
14202
14203
14204
14205
14206
14207
14208
14209
14210
14211
14212
14213
14214
14215
14216
14217
14218
14219
14220
14221
14222
14223
14224
14225
14226
14227
14228
14229
14230
14231
14232
14233
14234
14235
14236
14237
14238
14239
14240
14241
14242
14243
14244
14245
14246
14247
14248
14249
14250
14251
14252
14253
14254
14255
14256
14257
14258
14259
14260
14261
14262
14263
14264
14265
14266
14267
14268
14269
14270







































                                                                   
                                                                                  
 
                                                                                                                                                                                                                                                                                                              
 
                                                                                                             
 
                                                                                                                            
 
                                                                                                                                                                                                                           
 


                                                                                                                                                                                            
 
                                                                                                                                     
 

                                                                                                                                

                                                                                        
                                                                                                                                                     
 





                                                                                           
                                                                                                                                                                                      
 
                                                                                                                                                                                         
 
                                                                                                                                                                          
 
                                                                                                                                                                                                                        
 
                                                                                                                                                                                                                                 
 
                                                                                                                                                                                   
 
                                                                                                                                                                                                                             
 
                                                                                                                                                                                                         
 
                                                                                                                                                                                              
 
                                                                                                                                                           
 
                                                                                                                                                                                               
 
                                                                                                                                                              
 
                                                                                                                                                                                    
 
                                                                                                                                                                         
 




                                                                                                                                                                                                                               






                                                                                                                          
                                                                                                                                
 
                                                                                                                                                                                                                                                           








                                                                                                                                                                        

                                                                                                                                                                              

                                                                                                                                                 

                                                                                                                                        

                                                                                                                                                   

                                                                                                                                                       





                                                                                                                                   
                                                                                                                                                                                


                                                                                                                                                                     

                                                                                                                                                               





                                                                                                                                                                                                    
                                                                                                                                                                                                                     


                                                                                                                                                                         

                                                                                                                                                                                      



                                                                                                                                                                                       
                                                                                                                                                          


                                                                                                                                                                     





                                                                                                                                                                                                                       

                                                                                                                                                                                      











































                                                                                                                                                     
                                                                                 
     

                                     

     
                                                                           
     

                                                               

     
                                                                                      
     

                                                                     


                                  
                                                                                                                                                           

     
                                                                                                                                                                                                                                                                                                             
     
                                                                                                        


                                              
                                                                                                                                                                                                    





                                                                                 
                                                     


                                                  
                                                                                                                                                                                                  











                                                                                       





                                


                                                                                                                                                                    
                                                                                                            











                                                                                         
                                                                                               


                                                             


                               


             
                                                                                                                           











                                                                                              
                                                                                                              











                                                                                                                                                            
                                                                                                                                                                                                                          












                                                                                                                 
                                                                                                                                                                                        





                                                                   


                                     


                                     





                                


                                                                                                                                                          
                                                                                                                











                                                                                             
                                                                                                 


                                                                 


                               


             
































                                                                                                                                                                                           
                                                                                                                                    

                                      
                             








                                                                                          
                                                                                                                         


                                                                   




                                       
       
             

     




























                                                                                                                                                 



















                                                                                            
                                                                                                                                                    












                                                                                                
                                                                                                                               








                                                           


                                       


                                                                                                                                                      

































































                                                                                                                                                              
                                                                                                                                                                                     
     
                                                    


                                 
                                                                                                                         



                                                       
                         


                                     
                                                                                                                                        








                                                             


                                       


                                                                                                                                                       
                                                                                                                                                                                        












                                                                                                              
                                                                                                                                                         











                                                                   


                                       


                                                                                                                                                          
                                                                                                                                                                         












                                                                                                        
                                                                                                                                            








                                                           





                                       


                                                                                                                                                      
                                                                                                                                                                                                                       

                                                          
                             










                                                                                                                                    
                                                                                                                                                                  


                                                                   


                                     









                                       

     
                                                                                                                                                                                                                                

                                                                
                                










                                                                                                                                             
                                                                                                                                                                     


                                                                         


                                     









                                       

     
                                                                                                                                                                                  

                                                         
                                









                                                                                                                    
                                                                                                                                                


                                                                         





                                     



                                       

     
                                                                                                                                                                                                                            
     
                                                                      
                                   

     
                                                                                                                                                              


                                                                         
                                       



                                              
                                                                                                                                                   


                                                                               





                                     



                                       

     
                                                                                                                                                                                                        












                                                                                                                  
                                                                                                                                                                         











                                                                           


                                       


                                                                                                                                                              































                                                                                                                                                                                             












                                                                                                              
                                                                                                                         








                                                               


                                       


                                                                                                                                                        
                                                                                                                                                                                              

                                                        
                           










                                                                                                                                
                                                                                                                                           


                                                               





                                     



                                       

     
                                                                                                                                                             
     
                                           


                                   
                                                                                                   


                                                           
                         


                                       
                                                                                                                                        








                                                                 


                                       


                                                                                                                                                         
                                                                                                                                                                                   












                                                                                                              
                                                                                                                                                      











                                                                       


                                       


                                                                                                                                                            
                                                                                                                                                                        

                                               
                           









                                                                                                          
                                                                                                                                           


                                                               





                                     



                                       

     
                                                                                                                                                                                                                              

                                                                      
                                     










                                                                                                                                                                
                                                                                                                                                     


                                                                                   





                                     



                                       

     
                                                                                                                                                                                                          












                                                                                                                  
                                                                                                                                                                             











                                                                               


                                       


                                                                                                                                                                






























                                                                                                                                                                                             














































                                                                                                                                                                                                                                                                                                    
                                                                                                                                 
                   
                                                                                                                           



                                          

                                                                                                                                                                                                                                                                                                          



                                                                                                             

                                                                                                                                             



                               
                                                                              




                                                                                                                                                            
                                                          


       
                                                                                                                                                                                                                                                            
                   
                                                                                                                                                                                                                








                                                                                                         

                                                                                                                                                                                                                                                                                                                                                                                                                                     




                                                                        
                                                     








                                                                                                                                                      
                                                       



                               
                                                                                                                                                                                 






























                                                                                                                                                                                                                                                                                                                          
                                                                                           






























                                                                                                                                                                                                                                                                                                                               
                                                                                                     

































                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                 






























                                                                                                                                                                                                                                                                                                                              
                                                                                           








                                                                                                                                                            


































                                                                                                                                                                                                                                                                                                                                                        





















                                                                                                                                                                                                                                                                                                                           
                                                                                                                  




                                                                                                                                                            
                                                  


       































                                                                                                                                                                                                                                                                                                                  































                                                                                                                                                                                                                                                                                                                             
























                                                                                                                                                                                                                                                                                                                                 
                                                                                                                            








                                                                                                                                                            






















































































                                                                                                                                                                                                                                                                                                             
                                                                                                                                                                                 
                   
                                                                                                                                               






                                                                                            

                                                                                                                                                                                                                                                                                                                                                          


                                                                        
                         






                                                                                                                                         
                           



                               
                                                                                                                                    

































                                                                                                                                                                                                                                                                                                                                               
                                                                                                                                                  








                                                                                                                                                            
























                                                                                                                                                                                                                                                                                                                                         
                                                                                                                                         








                                                                                                                                                            



























                                                                                                                                                                                                                                                                                                                                                                     
                                                                                                                                                           




                                                                                                                                                            
                                                  






























                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                           




                                                                                                                                                            
                                                     



























                                                                                                                                                                                                                                                                                                                                                     
                                                                                                                                      




                                                                                                                                                            
                                                     


       
                                                                                                                                                                                                                      
                   
                                                                                                                                                                          





                                                                                                     
                                 
                                                       
                                                                                                                                                                                                                                                                                                                                                                                               

                                                                        
                                       






                                                                                                                                                  
                                         




                                         
                                                                                                                                      




                                                                                                                                                            
                                                        



























                                                                                                                                                                                                                                                                                                                                                   
                                                                                                                                                              








                                                                                                                                                            





































                                                                                                                                                                                                                                                                                                                                                                
























                                                                                                                                                                                                                                                                                                                                               
                                                                                                                    




































                                                                                                                                                                                                                                                                                                                                                                 
                                                                                                                                      




                                                                                                                                                            
                                                


       
                                                                                                                                                           
                   
                                                                                                                                        





                                                                                              

                                                                                                                                                                                                                                                                                                                                    

                                                                        
                         





                                                                                                                                           
                           



                               
                                                                                                                                  

































                                                                                                                                                                                                                                                                                                                                               
                                                                                                                                             








                                                                                                                                                            
























                                                                                                                                                                                                                                                                                                                                           
                                                                                                                                      




                                                                                                                                                            
                                                






























                                                                                                                                                                                                                                                                                                                                                                                                 
                                                                                                                                      




                                                                                                                                                            
                                                          



























                                                                                                                                                                                                                                                                                                                                                   
                                                                                                                                                                








                                                                                                                                                            





































                                                                                                                                                                                                                                                                                                                                                                













                                                                                                                                                                                                                                              
                                                                 




                                                                                   
                                                                           
                                                               
                                             
                                                                   
                                                       




                                                                       
                                                       




                                                                           
                                                           



                                                                   


                                                                               
                                                               























                                                                                                                   


                                                                                                                               

       

                                                           





                                    


                                                                                                                         



                      















                                                                                                                                                 
                                                                                                                                                       



                                                        



                                             



















                                                                                                                       




                                               












































                                                                                                                                 

                                                        

                                                     



                                             



















                                                                                                                           
































                                                                                                                                         


















                                                                                                                             






                                                     



                      

























                                                                                                           



















                                                                                                                                 


















                                                                                                                     

                                                    




                      











































































                                                                                                                                     
                                                                                         

                                                     

                                                    

























                                                                                                                             

                                                    




                      
















                                                                                                                     

                                                     



                                                    




                      















                                                                                                                             
                                                                              

                                                     





                                                    




















                                                                                                                                   
                                                                                    

                                                     





                                                    




















                                                                                                                                   
                                                                        



                                                     

                                                    




















                                                                                                                                         
                                                                                          



                                                     

                                                    

























                                                                                                                                     





























                                                                                                                         























                                                                                                                         

                                                    




















                                                                                                                         
                                                                            



                                                     

                                                    




















                                                                                                                           
                                                                           

                                                     

                                                    

























                                                                                                                                 

                                                    




                      















                                                                                                                         
                                                              



                                                     

                                                    




















                                                                                                                                             
                                                                                          



                                                     

                                                    

























                                                                                                                                         





























                                                                                                                             


















                                                                                                                                                                                                                                                                  
                                                                 




                                                                                   
                                                                           
                                                               
                                             
                                                                   
                                                       




                                                                       
                                                       




                                                                           
                                                           



                                                                   


                                                                               
                                                               






















































                                                                                                                                                                 


                                                                                                                                                          

       

                                                           

       
                                                                                                                
                                                                  


                                                                           
                               










                                                                                                 
                                                                           


















                                                                                                                                                                 

                                                                                                                                                            


       




































                                                                                                                                                                                









                                                                     




















                                                                                                                                                                         
                                                                                                                                                  




























                                                                                                                                       





                                                                























                                                                                                                                                                 
                                                                                                                                                           







                                                            
                                                                                                               
                                                                  

                                                           






































                                                                                                                                                                 
                                                                                                                                                            






























                                                                                                                                                            





                                                                          



                                                                       









                                                                     


















































                                                                                                                                                                 





                                                                























                                                                                                                                                                 


































































                                                                                                                                                                 
                                                                                                                                             







                                                          
                                                                                                     
                                                                  

                                                 
                                                                         











                                                                                                 










                                                                       


















                                                                                                                                                                 
                                                                                                                                                



                                                            





























































                                                                                                                                                                 

















































                                                                                                                                                                 































                                                                                                                                               




                                                                      
























                                                                                                                                                                 
























































































































































































                                                                                                                                                                      




                                                                      




















                                                                                                                                                                 
                                                                                    







































                                                                                                                                                         




                                                                      
























                                                                                                                                                                 
                                                                                                                                       







                                                      
                                                                                                       
                                                                  

                                                   

                                                                 
















                                                                                                 









                                                                      



















                                                                                                                                                                 
                                                                                                                                              



                                                                        
                                                                                                                                             







                                                          
                                                                                                     
                                                                  

                                                 
                                                                         
















                                                                                                 














                                                                      



















                                                                                                                                                                 
                                                                                                                                                



                                                                                          
                                                                                                                                                   







                                                             
                                                                                                     
                                                                  

                                                 
                                                                               
















                                                                                                 














                                                                      



















                                                                                                                                                                 
                                                                                                                                                   



                                                                                                
                                                                                                                                                   







                                                             
                                                                                                     
                                                                  

                                                 
                                                                               





















                                                                                                 




                                                                      



















                                                                                                                                                                 
                                                                                                                                                   



                                                                                    
                                                                                                                                                         







                                                                
                                                                                                     
                                                                  


                                                                                     





















                                                                                                 




                                                                      



















                                                                                                                                                                 
                                                                                                                                                      
                                                                                                      







































                                                                                                                                                                             




                                                                      
























                                                                                                                                                                            

































































                                                                                                                                                                 































                                                                                                                                           




                                                                      
























                                                                                                                                                                 
                                                                                                                                         







                                                        
                                                                                                     
                                                                  

                                                 
                                                                     





















                                                                                                 




                                                                      



















                                                                                                                                                                 
                                                                                                                                              



































                                                                                                                                                           




                                                                      




















                                                                                                                                                                 
                                                                      







































                                                                                                                                                        




                                                                      
























                                                                                                                                                                 
                                                                                                                                         







                                                        
                                                                                                     
                                                                  

                                                 
                                                                     





















                                                                                                 




                                                                      



















                                                                                                                                                                 
                                                                                                                                              



                                                                          
                                                                                                                                                             







                                                                  
                                                                                                     
                                                                  

                                                 
                                                                                         





















                                                                                                 




                                                                      



















                                                                                                                                                                 
                                                                                                                                                        








































                                                                                                                                                                                   




                                                                      
























                                                                                                                                                                                

































































                                                                                                                                                                 

























































































































































































































































































































































































































































































































































































































                                                                                                                                                                                            

                                                                                                                                                                                                            
 


                                                                                                                                       

                                                                                          

     


                                                                                                                    
 













                                                                                        





































                                                                                                       


                                                                                                                                                      
                                                        
                                                                                                               

     
                                    




                                            
                                                               

     

                                             



                         



                                                            




                                                










                                                                                                                







                                        

                                                        


                   
                                                       


                       








                           
                                                       
                                                 
                                                                          
       



















                                                                                                       
                                                                     

                           


















                                                                                                                        





                                                                                                                      


                                                                                              


       
                                                                                                            
 
                                                                                                                                      








                                                                           










                                                                                                     
                                                                                                                                       


                                            





                               


                                                                                           


       
                                                                                                      

               
                                                                                                                                      
                                                     


               
                                                                                                                                     
                                                     




       

                                                                                                                                                                                                                    
 
                                                                                                                                                                                    


                                                                                                                                       

                                                                                            

     
                                               


                                                                                                                    
                                   















                                                                                        









































                                                                                                       

                                                                                                                                                      
                                                                                                                           
                                                        
                                                                                                                 

     
                                      

     

                                   


                             

     


                                            



                                                                   

     

                                               

     

                         
                          

     
                                         
                          

     
                                                                        
                             


                  
                                
                          

     

                                                                                               
                                  

     
                                                


                            







                                                            
                                             








                                                
                            













                                                                                                                







                                        

                                                          


                   
                                                         


                       

                                                                 


                                                            
                                               











                           
                                                         















                                                                                              
















                                                                                                       
                                                                       


                            




                                 







                                                                


                            

















                                                                                                                        


                                                                                                


       
                                                                                                                
 
                                                                                                                                        









                                                                           


                                                                                




                                                                                       










                                                                                                     
                                                                                                                                         


                                            
                                     
                                                    
                                      







                                


                                                                                             


       
                                                                                                          

               
                                                                                                                                        




                                                     
                                        
                                    
                                      



               
                                                                                                                                       
                                                     
                                              
                              

                                                 

                                       




       

                                                                                                                                                                                                                                                
 



                                                                                                                                                                                              
                                                                                                                                                                                                           


                                                                                                                                       

                                                                                                   

     



                                                    
                                                     


                                                                                                                    


                                             

                                                          













                                                                                        







                                  

                                        







































                                                                                                       

                                                     


                                                                                                                                                      
                                                                                                                                                 
                                                                                                                           






                                                                                                                                                      

                                                                                                                                                                   
                                                        
                                                                                                                        

     
                                             

     



                                          

                                    

             




                                     
                                                   




                                            











                                                                                            
       



                                                                                                     

     

                                                      



                         




                              
                                     

     

                                  

     

                                                                          


                  

                                  

     


                                                                                                 

     
                                                  
                   






















































































                                                                                                   


       

































                                                                                                                 

                                                            
                      
                            
                           
                
























                                                  


              







                                                   




                                                










                                           
 


                                       










                                                                                                                







                                  

                                         
































                                                                         
       
 







                                                              
 



                                                                         
                       
                                                       


                       








                                                                                       








                           
                                                                





                                                                          
                                                                                           


                                































                                                                                                      



                                  









                                                                                                                    
















                                                                                                       
                                                                              

                           

                                   

                          




















                                     

                    







                                                                            


















                                                                                                                        

                                                                                                                                      





                                                                                                                      


                                                                                                       


       
                                                                                                                              
 
                                                                                                                                               








                                                                           
                                 
                                                                                
























                                                                                       


                                                                                    
                   


                                                     



                                                 



                                                                                       







                                                                                       










                                                                                                     
                                                                                                                                                


                                            
















                                                                                                                                           
                                                          
             
                                          


                                 

                                




                                                                





                               


                                                                                                    


       
                                                                                                                        

               
                                                                                                                                               

                                                     
                                      

                           








                                        



                                               











                                                      
                                                          
             
                                          

             
         


                                                       


               
                                                                                                                                              
                                                     
                                              
                              












                                                  


                                                                                                                                                       
             


                                               


                                           
         



                                                         




       

                                                                                                                                                                                                                                                        
 


                                                                                                                                                                                         

                                                                                                                                                                              


                                                                                                                                       

                                                                                                     

     


                                                            

                                                 


                                                                                                                    

                                       


                                        













                                                                                        





                               



                         





































                                                                                                       

                           


                                                                                                                                                      





                                                                                                                                                 



                                                                                                                                      
                                                        
                                                                                                                          

     





                                               


                                        




                                 

                       




                                            









                                                                                     





                                                         

     

                                                        



                         


                            

                       







































































                                                                                                 

     















































                                                                                            

                                                            























                                                          















                                               




                                                








                              





                         










                                                                                                                





                                



                           







                                        

                                                                   


                   
                                                                  


                       


























                                                                     

















                                                           








                           
                                                                  





                                                                          





























                                                                                                  



















                                                                                        
















                                                                                                       
                                                                                

                           






















                                   















                                  






                                                                


                            

















                                                                                                                        


                                                                                                         


       
                                                                                                                                  
 
                                                                                                                                                 








                                                                           


























                                                                                       

















                                                                                       










                                                                                                     
                                                                                                                                                  


                                            














                                                       









                                                 





                               


                                                                                                      


       
                                                                                                                            

               
                                                                                                                                                 
                                                     









                                        






                                        








                                        





                                   


               
                                                                                                                                                
                                                     
                                              














                                                              









                                                   




       

                                                                                                                                                                                            




                                                                                                                                                                                             

                                                                                      




































































                                                                                                                                                      
                                                                                                           

     
                                

     
                             








                                            
                                                       




                                             

                                         










                                    
                                                                 

























































                                                                                                                

                                                    


                   
                                                   




















                                                                         
                                                   
































                                                                                                       
                                                                 

































                                                                                                                        


                                                                                          


       
                                                                                                    
 
                                                                                                                                  



























                                                                                                     
                                                                                                                                   













                                                         


                                                                                       


       
                                                                                              

               
                                                                                                                                  











                                                     
                                                                                                                                 










                                                     

                                                                                                                                                                                                    
 
                                                                                                                                                                            


                                                                                                                                       

                                                                                        

     
                                                  


                                                                                                                    
                           













                                                                                        

                        





































                                                                                                       

                           

                                                                                            
                                                                                                                                                      

                                                                                                                                    

                                                                                                             

     
                                  

     






                                 



                                                           


                                                         

     

                                           

     

                         
























                                                                                           



                                                            







                                                




                                                


                        










                                                                                                                

                          







                                        

                                                      


                   
                                                     


                       








                                                         








                           
                                                     





                                                                          









                                                                                      
















                                                                                                       
                                                                   

                           






                             






                                                                

















                                                                                                                        


                                                                                            


       
                                                                                                        
 
                                                                                                                                    








                                                                           








                                                                                       










                                                                                                     
                                                                                                                                     


                                            




                                                





                               


                                                                                         


       
                                                                                                  

               
                                                                                                                                    
                                                     







                                        


               
                                                                                                                                   
                                                     





                                                    




       

                                                                                                                                                                                                                
 
                                                                                                                                                                                             


                                                                                                                                       

                                                                                           

     
                                          


                                                                                                                    
                                            













                                                                                        

                                 










































                                                                                                                                                      



                                                                                                                                                     

     
                                     

     




                                     

     






                                                                 

     

                                              

     


                              

     

                                    

     

                                                                      


                  

                                    

     


                                                                                                   

     
                                                    
                   
                                




                                                            
                        
                            
                             
                
                                        







                                                

                                











                                                                                                                

                                  







                                        

                                                         


                   
                                                        


                       



                                                                         
                       
                                                       











                           
                                                        





                                                                          
                                                                                               


                                

                                                                                                      




















                                                                                                       
                                                                      

                           

                                     

                          
                                    


























                                                                                                                        


                                                                                               


       
                                                                                                              
 
                                                                                                                                       








                                                                           
                                   
                                                                                

                                                        














                                                                                                     
                                                                                                                                        


                                            


                                                         







                                


                                                                                            


       
                                                                                                        

               
                                                                                                                                       

                                                     
                                        

                           


                                                



               
                                                                                                                                      
                                                     
                                              
                              

                                                  





         

                                                                                                                                                                                                                        

                                                                                                                                                                                    
                                                                                                                                                                            


                                                                                                                                       

                                                                                             

     
                                              
                                                  



                                                                                                                    
                           















                                                                                        

                        











































                                                                                                                                                      
                                                                                                                          
                                                                                                                                    

                                                                                                        
                                                                                                                  

     
                                       

     
                                    
                             
                                 


                             
                     




                                            
                                                                     
                                 
                                                         
       

                                                         


       

                                                




                          
                      

     
                                        


                          
                                                                        


















                                                                                               

                                            

     

                                                                        


                  

                            

     


                                                                                           

     
                                            
                   
                        








                                                            
                                            


              
               
                            
                     
                
                                                










                                                

                        













                                                                                                                

                          







                                        

                                                           


                   
                                                          











                                                                 



                                                         
                       
                                       











                           
                                                          















                                                                                              
                                                                               


                                

                                                                                      




















                                                                                                       
                                                                        









                                  

                             

                          
                            





























                                                                                                                        


                                                                                                 


       
                                                                                                                  
 
                                                                                                                                         










                                                                                
                                                      





                                                                                       
                          
                                                                                


                                                          














                                                                                                     
                                                                                                                                          







                                                    


                                                







                                


                                                                                              


       
                                                                                                            

               
                                                                                                                                         




                                                     
                                





                                        

                                  



               
                                                                                                                                        


                                                     
                                                



                                       


                                                    





         

                                                                                                                                                                                                        
 

                                                                                                                                                                                                    


                                                                                                                                       

                                                                                         

     

                                             


                                                                                                                    

                                                   













                                                                                        



                                     










































                                                                                                                                                      



                                                                                                                                                            
                                                        
                                                                                                              

     
                                   

     


                                

             

                                           




                                            





                                                             


       

                                            



                         

                                 

     

                                  

     

                                                                


                  

                                  

     


                                                                                                 

     
                                                  
                   
























                                                                                                      




                                                            
                      
                            
                           
                








                                           







                                                




                                   











                                                                                                                



                                     







                                        

                                                       


                   
                                                      


                       



                                                                     
                       









                                                                               











                           
                                                      





                                                                          
                                                                                           


                                











                                                                                                            




















                                                                                                       
                                                                    

                           

                                   

                          








                                        


























                                                                                                                        


                                                                                             


       
                                                                                                          
 
                                                                                                                                     








                                                                           
                                 
                                                                                









                                                                                       














                                                                                                     
                                                                                                                                      


                                            







                                                             







                                


                                                                                          


       
                                                                                                    

               
                                                                                                                                     

                                                     
                                      

                           








                                                   



               
                                                                                                                                    
                                                     
                                              
                              





                                                     





         

                                                                                                                                                                                                                
 
                                                                                                                                                                                    



                                                                                                                                                                                         


                                                                                                                                       

                                                                                           

     
                                                   
                                                            
                                                         

                                                 


                                                                                                                    
                                   



                                        













                                                                                        

                            


                               
                              



                         





































                                                                                                       

                           


                                                                                                                                                      

                                                                                                                                            

                                                                                                                                                

                                                                                                                                                 



                                                                                                                                      
                                                        
                                                                                                                

     




                                     



                                           


                             
                                 
                                 

                       




                                            



                                                                 


                                                                         


                                                                      





                                                         

     

                                              



                         
                          
                            
                            

                       

























                                                                                               























                                                                                                 





















                                                                                                 

     















































                                                                                            









                                                            







                                                          







                                                       















                                               




                                                


                            


                              


                              





                         










                                                                                                                

                              

                                

                                



                           







                                        

                                                         


                   
                                                        


                       








                                                                 











                                                                     





                                                                

















                                                           








                           
                                                        





                                                                          









                                                                                              









                                                                                                  









                                                                                                  



















                                                                                        
















                                                                                                       
                                                                      

                           







                                  







                                   






                                   















                                  






                                                                


                            

















                                                                                                                        


                                                                                               


       
                                                                                                              
 
                                                                                                                                       








                                                                           








                                                                                       









                                                                                       







                                                                                       

















                                                                                       










                                                                                                     
                                                                                                                                        


                                            




                                                    




                                                      




                                                       









                                                 





                               


                                                                                            


       
                                                                                                        

               
                                                                                                                                       
                                                     



                                        
                                      

                           









                                        


                                      


                                        


                                        





                                   


               
                                                                                                                                      
                                                     
                                              





                                                     




                                                              



                                                           









                                                   




       

                                                                                                                                                                                                    
 
                                                                                                                                                                                                 


                                                                                                                                       

                                                                                        

     
                                            


                                                                                                                    
                                                













                                                                                        

                                   










































                                                                                                                                                      

                                                                                                                                                         
                                                        
                                                                                                             

     
                                  

     

                               

             
                                         




                                            


                                                           


       

                                           



                         
                                

     

                                      

     

                                                                       


                  

                                      

     


                                                                                                     

     
                                                      
                   
                                  




                                                            
                          
                            
                               
                
                                          







                                                

                                  











                                                                                                                

                                    







                                        

                                                      


                   
                                                     


                       



                                                                             
                       
                                                           











                           
                                                     





                                                                          
                                                                                                   


                                

                                                                                                          




















                                                                                                       
                                                                   

                           

                                       

                          
                                      


























                                                                                                                        


                                                                                            


       
                                                                                                        
 
                                                                                                                                    








                                                                           
                                     
                                                                                

                                                          














                                                                                                     
                                                                                                                                     


                                            


                                                           







                                


                                                                                         


       
                                                                                                  

               
                                                                                                                                    

                                                     
                                          


                                        

                                                  



               
                                                                                                                                   


                                                     

                                                    





         

                                                                                                                                                                                                            
 
                                                                                                                                                                            


                                                                                                                                       

                                                                                          

     
                                                  


                                                                                                                    
                           













                                                                                        

                        





































                                                                                                       

                           


                                                                                                                                                      

                                                                                                                                    
                                                        
                                                                                                               

     
                                    

     






                                 


                                            
                                                               


                                                         

     

                                             



                         
























                                                                                           



                                                            







                                                




                                                


                        










                                                                                                                

                          







                                        

                                                        


                   
                                                       


                       








                                                         








                           
                                                       





                                                                          









                                                                                      
















                                                                                                       
                                                                     

                           






                             


















                                                                                                                        





                                                                                                                      


                                                                                              


       
                                                                                                            
 
                                                                                                                                      








                                                                           















                                                                                       



                                                                                                     
                                                                                                                                       


                                            




                                                





                               


                                                                                           


       
                                                                                                      

               
                                                                                                                                      
                                                     







                                        


               
                                                                                                                                     
                                                     










































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































                                                                                                                                                                                                                                        




       

                                                                                                                                                                                                        




                                                                                                                                                                                         

                                                                                         




































































                                                                                                                                                      
                                                                                                              

     
                                   

     
                                








                                            
                                                             




                                         

                                            










                                  
                                                                

























































                                                                                                                

                                                       


                   
                                                      




















                                                                     
                                                      
































                                                                                                       
                                                                    

































                                                                                                                        


                                                                                             


       
                                                                                                          
 
                                                                                                                                     



























                                                                                                     
                                                                                                                                      













                                                       


                                                                                          


       
                                                                                                    

               
                                                                                                                                     











                                                     
                                                                                                                                    










                                                     

                                                                                                                                                                                                                
 

                                                                                                                                                                                             


                                                                                                                                       

                                                                                           

     

                                                         


                                                                                                                    

                                            













                                                                                        



                                 





































                                                                                                       

                           


                                                                                                                                                      



                                                                                                                                                     
                                                        
                                                                                                                

     



                                     

                                        

             

                                     




                                            
                                                                 





                                                                       

     

                                              



                         

                              

     

                                                   

     

                                                                                   


                  

                                  

     


                                                                                                 

     



























                                                                                                   



                                                            
                      
                            
                           
                








                                                       


              




                                                




                                
 










                                                                                                                



                                  







                                        

                                                         


                   
                                                        


                       



                                                                     
                       









                                                                         


                       








                           
                                                        





                                                                          
                                                                                           


                                











                                                                                                      



                                  
















                                                                                                       
                                                                      

                           













                                     
                    
























                                                                                                                        


                                                                                               


       
                                                                                                              
 
                                                                                                                                       








                                                                           













                                                                                       



                                                                                       










                                                                                                     
                                                                                                                                        


                                            







                                                         

                                





                               


                                                                                            


       
                                                                                                        

               
                                                                                                                                       
                                                     
                                        
                                      

                           








                                          
         


               
                                                                                                                                      
                                                     
                                              
                              







                                                           
         




       




















































































































































































































































































































































































































































































































































































































































































































































































































































































































































                                                                                                                                                                                             

                                                                                                                                                                                                                
 
                                                                                                                                                                                         


                                                                                                                                       

                                                                                           

     
                                        


                                                                                                                    
                                        













                                                                                        

                               





































                                                                                                       

                           


                                                                                                                                                      

                                                                                                                                                 
                                                        
                                                                                                                

     
                                     

     

                                  


                                 




                                            
                                                                 


                                         

     

                                              



                         
                            





                                  
                                                                  




                                  
                            

     


                                                                                                 

     



                                                  



                                                            







                                      




                                                


                              










                                                                                                                

                                







                                        

                                                         


                   
                                                        


                       








                                                                     








                           
                                                        





                                                                          









                                                                                                  
















                                                                                                       
                                                                      

                           






                                   
























                                                                                                                        


                                                                                               


       
                                                                                                              
 
                                                                                                                                       








                                                                           







                                                                                       










                                                                                                     
                                                                                                                                        


                                            




                                                       





                               


                                                                                            


       
                                                                                                        

               
                                                                                                                                       




                                                     
                                        


                                              


               
                                                                                                                                      
                                                     
                                              



                                                




       

                                                                                                                                                                                                                        
 


                                                                                                                                       

                                                                                             

     


                                                                                                                    
 













                                                                                        











                                                                                                       
                      
       
 





                                                                               
 

                                      
 



                                                 
 


                                       
 

                                    

       




                                                                                                                                                      

     
                                       

     



                                                                     

     

                                                

     

                         

     

                                                            




                                                










                                                                                                                







                                        

                                                           


                   
                                                          


                       








                           
                                                          





                                                                          
















                                                                                                       
                                                                        

                           

















                                                                                                                        
























                                                                                                                                         










                                                                                                     
                                                                                                                                          


                                            





                               


                                                                                              


       
                                                                                                            

               
                                                                                                                                         
                                                     


               
                                                                                                                                        
                                                     




       

                                                                                                                                                                                        
 

                                                                                                                                                                                         


                                                                                                                                       

                                                                                     

     

                                        


                                                                                                                    

                                        













                                                                                        



                               





































                                                                                                       



                                                 


                                                                                                                                                      



                                                                                                                                                 
                                                        
                                                                                                          

     










                                 




                                            





                                                     

     

                                        



                         

















































                                                                                                 



                                                            















                                      




                                                





                                          










                                                                                                                



                                







                                        

                                                   


                   
                                                  


                       

















                                                                     








                           
                                                  





                                                                          



















                                                                                                  
















                                                                                                       
                                                                

                           










                                   


















                                                                                                                        

                                                                                                                                      





                                                                                                                      


                                                                                         


       
                                                                                                  
 
                                                                                                                                 








                                                                           















                                                                                       










                                                                                                     
                                                                                                                                  


                                            







                                                       





                               


                                                                                      


       
                                                                                            

               
                                                                                                                                 
                                                     













                                              


               
                                                                                                                                
                                                     








                                                




       

                                                                                                                                                                                                

                                                                                                                                                                                  

                                                                                                                                                                                             


                                                                                                                                       

                                                                                       

     


                                                        


                                                                                                                    


                                            















                                                                                        



                                 












































                                                                                                                                                      




                                                                                                                                                     
                                                        
                                                                                                            

     
                                 

     



                                       


                             

                                     




                                            
                                                         
                                 


                                                                                       


                                       





                                                                       

     

                                          




                          

                              





                                                              
                                                              


                                                                     
                                             
                                 
                                                 



                             
                                        


                          
                                                                  


















                                                                                               















































                                                                                                   





                                                            
















                                                      










                                                





                                












                                                                                                                



                                  







                                        

                                                     


                   
                                                    











                                                                 

















                                                                         








                           
                                                    















                                                                                              



















                                                                                                      
















                                                                                                       
                                                                  








                                 















                                     
























                                                                                                                        


                                                                                           


       
                                                                                                      
 
                                                                                                                                   











                                                                              


                                                                                    
                   



                                                 







                                                                                       

















                                                                                       










                                                                                                     
                                                                                                                                    






                                                                                                                                       
                                                    
             
                                    




                                 









                                                         





                               


                                                                                        


       
                                                                                                

               
                                                                                                                                   




                                                     






                                        


                                                  
                                                    
             
                                    


             





                                          


               
                                                                                                                                  
                                                     
                                              

                              


                                                                                                                                                       
             



                                           



                                       









                                                          




       

                                                                                                                                                                                                                        



                                                                                                                                       

                                                                                             





























































                                                                                                                                                      
                                                                                                                  

     
                                       




                                            
                                                                     

     

                                                































                                                                                                                

                                                           


                   
                                                          











                           
                                                          






















                                                                                                       
                                                                        


























                                                                                                                        


                                                                                                 


       
                                                                                                                  
 
                                                                                                                                         



















                                                                                                     
                                                                                                                                          








                                            


                                                                                              


       
                                                                                                            

               
                                                                                                                                         



                                                     
                                                                                                                                        





                                                     

                                                                                                                                                                                                                                




                                                                                                                                                                                  

                                                                                               

     
                                                     
































































                                                                                                                                                      
                                                                                                                                
                                                        
                                                                                                                    

     
                                         

     

                                      







                                            
                                                                         
                                 


                                                                                                     




                                       

                                                  










                                                              
                                                                     


                                                                     
                                                    
                                 
                                                        



                             
                                               


                          
                                                                                 
























                                                                                               
                                                   































                                                                                                                

                                                             


                   
                                                            




















                                                                 
                                                            
































                                                                                                       
                                                                          

































                                                                                                                        


                                                                                                   


       
                                                                                                                      
 
                                                                                                                                           











                                                                              


                                                                                    
                   



                                                     


















                                                                                                     
                                                                                                                                            






                                                                                                                                       
                                                           
             
                                    










                                 


                                                                                                


       
                                                                                                                

               
                                                                                                                                           








                                                     
                                                           
             
                                    





               
                                                                                                                                          



                                                     


                                                                                                                                                       
             



                                               








                                       

                                                                                                                                                                                                        



                                                                                                                                       

                                                                                         





























































                                                                                                                                                      
                                                                                                              

     
                                   




                                            
                                                             

     

                                            































                                                                                                                

                                                       


                   
                                                      











                           
                                                      






















                                                                                                       
                                                                    


























                                                                                                                        


                                                                                             


       
                                                                                                          
 
                                                                                                                                     



















                                                                                                     
                                                                                                                                      








                                            


                                                                                          


       
                                                                                                    

               
                                                                                                                                     



                                                     
                                                                                                                                    





                                                     

                                                                                                                                                                                                                




                                                                                                                                                                                  

                                                                                           

     
                                                 
































































                                                                                                                                                      
                                                                                                                            
                                                        
                                                                                                                

     
                                     

     

                                  







                                            
                                                                 
                                 


                                                                                             




                                       

                                              










                                                              
                                                                 


                                                                     
                                                
                                 
                                                    



                             
                                           


                          
                                                                         
























                                                                                               
                                               































                                                                                                                

                                                         


                   
                                                        




















                                                                 
                                                        
































                                                                                                       
                                                                      

































                                                                                                                        


                                                                                               


       
                                                                                                              
 
                                                                                                                                       











                                                                              


                                                                                    
                   



                                                 


















                                                                                                     
                                                                                                                                        






                                                                                                                                       
                                                       
             
                                    










                                 


                                                                                            


       
                                                                                                        

               
                                                                                                                                       








                                                     
                                                       
             
                                    





               
                                                                                                                                      



                                                     


                                                                                                                                                       
             



                                           








                                       

                                                                                                                                                                                                                        
 


                                                                                                                                       

                                                                                             

     


                                                                                                                    
 













                                                                                        





































                                                                                                       


                                                                                                                                                      
                                                        
                                                                                                                  

     
                                       




                                            
                                                                     

     

                                                



                         



                                                            




                                                










                                                                                                                







                                        

                                                           


                   
                                                          


                       








                           
                                                          





                                                                          
















                                                                                                       
                                                                        

                           
























                                                                                                                        


                                                                                                 
       













                                                                                                                                         










                                                                                                     
                                                                                                                                          


                                            





                               


                                                                                              


       
                                                                                                            

               
                                                                                                                                         
                                                     


               
                                                                                                                                        
                                                     




       

                                                                                                                                                                                                                                

                                                                                                                                                                                  


                                                                                                                                       

                                                                                               

     
                                                  


                                                                                                                    
                                   















                                                                                        












































                                                                                                                                                      
                                                                                                                             
                                                        
                                                                                                                    

     
                                         

     

                                      


                             




                                            
                                                                         
                                 


                                                                                               


                                       

     

                                                  




                          





                                                              
                                                                  


                                                                     
                                                 
                                 
                                                     



                             
                                            


                          
                                                                              


















                                                                                               





                                                            
                                                


              







                                                












                                                                                                                







                                        

                                                             


                   
                                                            



                                                                 


                                                                 
                       
                                               


                       








                           
                                                            















                                                                                              
















                                                                                                       
                                                                          








                                 
























                                                                                                                        


                                                                                                   


       
                                                                                                                      
 
                                                                                                                                           











                                                                              


                                                                                    
                   



                                                  







                                                                                       










                                                                                                     
                                                                                                                                            






                                                                                                                                       
                                                        
             
                                    




                                 





                               


                                                                                                


       
                                                                                                                

               
                                                                                                                                           




                                                     
                                        


                                                  
                                                        
             
                                    


             


               
                                                                                                                                          
                                                     
                                              

                              


                                                                                                                                                       
             



                                            



                                       




       

                                                                                                                                                                                            

                                                                                                                                                                                         

                                                                                                                                                                                       


                                                                                                                                       

                                                                                      


                                        

                                              



                                                                                                                    

                                        















                                                                                        



                               







































                                                                                                       

                                                 




                                                                                                                                                      




                                                                                                                                                 
                                                        
                                                                                                           

     
                                

     
                             
                       

                             


                                 


                                 




                                            

                                                       


                                         


                                                                                
       
                             

     

                                         




                            


                            





                                  
                                                             


















                                                                                                 








































                                                                                                 

     


                                                


                  

                                                                                   

     


                                                                                            

     

                                                                                        











                                                            
                      
                            
                           
                








                                            










                                                




                                          













                                                                                                                



                                







                                        

                                                    


                   
                                                   











                                                                     



                                                                     
                       









                                                      











                           
                                                   















                                                                                                  
                                                                                           


                                











                                                                                                  




















                                                                                                       
                                                                 









                                   

                                   

                          
                                  

                    



                                  


















                                                                                                                        

                                                                                                                                      





                                                                                                                      


                                                                                          


       
                                                                                                    
 
                                                                                                                                  
















                                                                                       


                                                                              


                                                                                    
                   


                                                   











                                                                                       














                                                                                                     
                                                                                                                                   







                                                       



                                                                                                                                         
                                                    
             
                                          


                                 

                                


                                               





                               


                                                                                       


       
                                                                                              

               
                                                                                                                                  




                                                     
                                      

                           



                                        


                                              


                                                    
                                                    
             
                                          




                                      



               
                                                                                                                                 
                                                     
                                              




                                                
           


                                                                                                                                                       
             


                                             






                                         





         

                                                                                                                                                                                                    
 
                                                                                                                                                                                  
                                                                                                                                                                                         
                                                                                                                                                                                             


                                                                                                                                       

                                                                                        

     
                                                      
                                                         
                                                        




                                                                                                                    
                                            

















                                                                                        
                                 
                                











































                                                                                                                                                      

                                                                                                                                 

                                                                                                                                                 

                                                                                                                                                     
                                                        
                                                                                                             

     
                                  

     

                                     
                                        
                                       



                                 
                                     




                                            
                                                           
                                 




                                                                                                       



                                                                      


                                                                       

     

                                           





                            
                              

     















                                                                      


                          
                                                                           






















                                                                                               
                                                                                


















                                                                                                 



                                                  
                                                                                 


















                                                                                                   





                                                            
                                                    










                                                       







                                                      










                                                


                                














                                                                                                                

                                  







                                        

                                                      


                   
                                                     




















                                                                     








                                                                         








                           
                                                     

























                                                                                                  









                                                                                                      
















                                                                                                       
                                                                   

















                                   






                                     






                                                                

















                                                                                                                        


                                                                                            


       
                                                                                                        
 
                                                                                                                                    









                                                                           

                                                                              


                                                                                    
                   



                                                      


                                      













                                                                                       
                                   







                                                                                       










                                                                                                     
                                                                                                                                     




                                                    

                                                                                                                                       
                                                            
             
                                    


                                 






                                                       




                                                         





                               


                                                                                         


       
                                                                                                  

               
                                                                                                                                    







                                                     
                                        
                           
         
                                        
                                    

                                                  
                                                            
             
                                    

             



                                        


                                          


               
                                                                                                                                   
                                                     
                                              
                              
           


                                                                                                                                                       
             



                                                

             







                                                           



                                                          




       

                                                                                                                                                                                                        

                                                                                                                                                                                         
                                                                                                                                                                                              


                                                                                                                                       

                                                                                         


                                        
                                          



                                                                                                                    
                                             















                                                                                        

                                  












































                                                                                                                                                      

                                                                                                                                                      
                                                        
                                                                                                              

     
                                   

     
                                
                       
                         


                                 
                                     




                                            
                                                             


                                         

                                             


       

                                            




                            
                              





                                  
                                                                


















                                                                                                 

                                    

     

                                                                    


                  

                                    

     


                                                                                                   

     
                                                    
                   
                                












                                                            
                         
                            
                             
                
                                        










                                                

                                













                                                                                                                

                                  







                                        

                                                       


                   
                                                      











                                                                     



                                                                         
                       
                                                       











                           
                                                      















                                                                                                  
                                                                                               


                                

                                                                                                      




















                                                                                                       
                                                                    









                                   

                                     

                          
                                    


























                                                                                                                        


                                                                                             


       
                                                                                                          
 
                                                                                                                                     
















                                                                                       
                                    
                                                                                

                                                        














                                                                                                     
                                                                                                                                      







                                                       


                                                          







                                


                                                                                          


       
                                                                                                    

               
                                                                                                                                     




                                                     
                                        





                                              

                                                



               
                                                                                                                                    






                                                     

                                                  





         

                                                                                                                                                                                                                
 
                                                                                                                                                                                    
                                                                                                                                                                                         
                                                                                                                                                                                       
                                                                                                                                                                                             


                                                                                                                                       

                                                                                           

     
                                                
                                                         
                                                   
                                                        



                                                                                                                    
                                        
                                      
                                            

















                                                                                        

                              

                                 







































                                                                                                       



                                                                                                                                                      
                                                                                                                            

                                                                                                                                                 
                                                                                                                                               


                                                                                                                                                     
                                                        
                                                                                                                

     
                                     

     

                                  
                                        
                                  
                                       


                             
                                 
                               
                                     




                                            
                                                                 
                                 
                                                           
       


                                                                      

                                                               



                                                                       

     

                                              



                         
                          
                            
                           
                              

     
                                          


                          
                                                                        
                             



                                
                          



                                                                                               
                                  


                                                


                            





                                                   
                                                                                   


















                                                                                                 

                                             

     

                                                                            


                  

                                 

     


                                                                                                

     
                                                 
                   
                             






                                                  
                                                                                    


















                                                                                                   





                                                            
                                              










                                                       
                     
                            
                          
                
                                                 










                                                      





                                                
                            



                              

                             



                                














                                                                                                                

                               

                                  







                                        

                                                         


                   
                                                        


                       

                                                                 


                                                            
                                               











                                                                     



                                                                   
                       
                                                 











                                                                         








                           
                                                        

























                                                                                                  
                                                                                         


                                

                                                                                                













                                                                                                      
















                                                                                                       
                                                                      


                            




                                 








                                   
                                  

                                  

                          
                                 









                                     






                                                                


                            











                                                                                                                        





                                                                                                                      


                                                                                               


       
                                                                                                              
 
                                                                                                                                       









                                                                           


                                                                                













                                                                                       
                                
                                                                                


                                                           












                                                                                       










                                                                                                     
                                                                                                                                        


                                            
                                     
                                                    
                                      






                                                       


                                                      






                                                         





                               


                                                                                            


       
                                                                                                        

               
                                                                                                                                       







                                                     
                                     





                                        
                                    
                                      



                                        

                                       



                                          


               
                                                                                                                                      
                                                     
                                              
                              

                                                  






                                                           
                              


                                                     





                                                          




       

                                                                                                                                                                                        

                                                                                                                                                                                         
                                                                                                                                                                                         


                                                                                                                                       

                                                                                     


                                        
                                        



                                                                                                                    
                                        















                                                                                        

                               












































                                                                                                                                                      

                                                                                                                                                 
                                                        
                                                                                                          

     
                               

     
                            
                       
                       


                                 
                                 




                                            
                                                     


                                         

                                         


       

                                        




                            
                            





                                  
                                                            


















                                                                                                 

                                  

     

                                                            


                  

                                  

     


                                                                                                 

     
                                                  
                   
                              












                                                            
                      
                            
                           
                
                                      










                                                

                              













                                                                                                                

                                







                                        

                                                   


                   
                                                  











                                                                     



                                                                     
                       
                                                   











                           
                                                  















                                                                                                  
                                                                                           


                                

                                                                                                  




















                                                                                                       
                                                                









                                   

                                   

                          
                                  








                                                                

















                                                                                                                        


                                                                                         


       
                                                                                                  
 
                                                                                                                                 
















                                                                                       
                                 
                                                                                

                                                      














                                                                                                     
                                                                                                                                  







                                                       


                                                       







                                


                                                                                      


       
                                                                                            

               
                                                                                                                                 




                                                     
                                      

                           
                                        


                                              

                                              



               
                                                                                                                                
                                                     
                                              




                                                

                                                





         

                                                                                                                                                                                                
 
                                                                                                                                                                                    
                                                                                                                                                                                         

                                                                                                                                                                                             


                                                                                                                                       

                                                                                       

     
                                      
                                                         

                                                        


                                                                                                                    
                                   
                                        

                                            













                                                                                        

                            

                               
                              
                             
                                 
                                







































                                                                                                       


                                                                                                                                                      

                                                                                                                                            

                                                                                                                                                 



                                                                                                                                                     
                                                        
                                                                                                            

     
                                 

     

                              
                                        

                                       

             
                             
                                 

                                     




                                            



                                                         


                                                                      






                                                                       
 

                                          



                         
                          
                            



                              

                                

     

                                                          


                  

                                

     


                                                                                               

     
                                                
                   
                            


       

                                                   

     

                                                                               


                  

                                  

     


                                                                                                 

     
                                                  
                   
                              






                                              
                                                                         






















                                                                                                
                                                                                




















                                                                                                   
                   
                            
                         
                
                                    


              
                      
                            
                           
                
                                                       























                                                      


                            


                              
















                                                                                                                

                              

                                











                                        

                                                     


                   
                                                    


                       








                                                                 








                                                                     


























                                                                         
                                                    





                                                                          
                                                                                       


                                

                                                                                              



                                  
                                                                                           


                                

                                                                                                  








































                                                                                                       
                                                                  

                           

                                 

                          
                                


                                  

                                   

                          
                                  










































                                                                                                                        


                                                                                           


       
                                                                                                      
 
                                                                                                                                   








                                                                           



                                                                                



                                                                                       
                                 
                                                                                


                                                                 



                                                                                       
                                







                                                                                       
                                   


















                                                                                                     
                                                                                                                                    


                                            




                                                    




                                                       















                                                         


                                                                                        


       
                                                                                                

               
                                                                                                                                   

                                                     
                                    

                           
                                      








                                        


                                            


                                        








                                          
                                                                                                                                  


                                                     



                                              



                                                           














                                                          

                                                                                                                                                                                                        

                                                                                                                                                                                         
                                                                                                                                                                                              



                                                                                                                                                                                

                                                                                         


                                        

                                            



                                                                                                                    
                                             
















                                                                                        

                                  














































                                                                                                                                                      
                                                                                                                                                      

                                                                                                                                        
                                                                                                                          
                                                        
                                                                                                              

     
                                   

     
                                
                       

                           


                                 
                                     





                                            
                                                             


                                         

                                             

                               
                                                     


       

                                            




                            
                              






                                  
                                                                


















                                                                                                 

                                    

     

                                                                    


                  

                                    

     


                                                                                                   

     
                                                    
                   
                                


       
                                      


                        
                                                                




























                                                                                             
                         
                            
                             
                
                                        






                            
                                          










                                                

                                
















                                                                                                                

                                  









                                        

                                                       


                   
                                                      











                                                                     



                                                                         
                       
                                                       




















                                                             
                                                      















                                                                                                  
                                                                                               


                                

                                                                                                      






























                                                                                                       
                                                                    









                                   

                                     

                          
                                    





































                                                                                                                        


                                                                                             


       
                                                                                                          
 
                                                                                                                                     
















                                                                                       
                                    
                                                                                

                                                        





                                                                                       
                                                    
















                                                                                                     
                                                                                                                                      







                                                       


                                                          












                                                  


                                                                                          


       
                                                                                                    

               
                                                                                                                                     




                                                     
                                        








                                              

                                                






                                    
                                                                                                                                    






                                                     

                                                  

                              
                                              







                                     

                                                                                                                                                                                                                







                                                                                                                                                                                             

                                                                                           






















































































                                                                                                                                                      
                                                                                                                

     
                                     

     
                                  














                                            
                                                                 













                                                                       

                                              













                                                   
                                                                                   






















                                                                                                 
                                                                            






















                                                                                                
                                                                             






















                                                                                                
                                                                                    
































































































                                                                                                                

                                                         


                   
                                                        















































                                                                         
                                                        






























































                                                                                                       
                                                                      

























































                                                                                                                        


                                                                                               


       
                                                                                                              
 
                                                                                                                                       























































                                                                                                     
                                                                                                                                        




























                                                         


                                                                                            


       
                                                                                                        

               
                                                                                                                                       





























                                                     
                                                                                                                                      


























                                                           

                                                                                                                                                                                                                    


                                                                                                                                                                                                    
                                                                                                                                                                                


                                                                                                                                       

                                                                                            



                                             
                                               



                                                                                                                    

                                                   

















                                                                                        

                          














































                                                                                                                                                            

                                                                                                                                        
                                                        
                                                                                                                 

     
                                      

     
                                   
                       

                              



                                           
                         




                                            
                                                                   





                                                   


                                                        

     

                                               





                                 
                        





                                  
                                                                   






















                                                                                                 
                                                                             


















                                                                                                      























                                                                                             

















                                                            







                                             










                                                


                          














                                                                                                                

                            







                                        

                                                          


                   
                                                         




















                                                                               








                                                             








                           
                                                         

























                                                                                                            









                                                                                          
















                                                                                                       
                                                                       
















                                        







                                  






                                                                


                          

















                                                                                                                        


                                                                                                


       
                                                                                                                
 
                                                                                                                                        
























                                                                                       








                                                                                       










                                                                                                     
                                                                                                                                         












                                                             




                                                  





                               


                                                                                             


       
                                                                                                          

               
                                                                                                                                        







                                                     



                                        





                                                   


                                    


               
                                                                                                                                       
                                                     
                                              







                                                     




                                                 




       

                                                                                                                                                                                                                            


                                                                                                                                                                                         

                                                                                                                                                                                             


                                                                                                                                       

                                                                                              



                                                         
                                                    





                                                                                                                    

                                            

















                                                                                        


                                 















































                                                                                                                                                      

                                                                                                                                               


                                                                                                                                                     
                                                                                                                   

     
                                        

     
                                     

                                        
                                   




                                       
                               





                                            
                                                                       





                                                                      


                                                                




                                                                       

                                                 





                            
                           






                                                   
                                                                                      










                                                                                                 

     



                                                  

     



                                             
                                                                               
                               


                  

                                 

     


                                                                                                

     



                                                 

     























                                                                                                

                                                  

     
                                                                                       
                                     


                  

                                    

     


                                                                                                   

     
                                                    
                   
                                




                                                            
                      
                            
                           
                
                                                       


              
                     
                            
                          
                



                                                 







                                                  




                                                      







                                                


                              


                             


                             


                                










                                                                                                                

                                

                               

                               

                                  







                                        

                                                            


                   
                                                           


                       








                                                                     








                                                                   








                                                                   








                                                                         








                           
                                                           





                                                                          
                                                                                           


                                

                                                                                                  



                                  
                                                                                         


                                





                                                                                                









                                                                                                





                                                                                                      




















                                                                                                       
                                                                         

                           






                                   








                                  







                                  






                                     


















                                                                                                                        





                                                                                                                      


                                                                                                  


       
                                                                                                                    
 
                                                                                                                                          








                                                                           








                                                                                       








                                                                                       









                                                                                       







                                                                                       










                                                                                                     
                                                                                                                                           


                                            




                                                       




                                                      




                                                      




                                                         





                               


                                                                                               


       
                                                                                                              

               
                                                                                                                                          

                                                     
                                      

                           
                                     

                           
                                     
                           
         



                                        


                                        


                                       


                                       


                                          


               
                                                                                                                                         
                                                     
                                              
                              



                                                           





                                                     




                                                      



                                                          




       

                                                                                                                                                                                                                    

                                                                                                                                                                                         
                                                                                                                                                                                                    


                                                                                                                                       

                                                                                            


                                        
                                             



                                                                                                                    
                                                   















                                                                                        

                                     












































                                                                                                                                                      
                                                                                                                                                            
                                                                                                                          
                                                        
                                                                                                                 

     
                                      

     
                                   
                       
                            


                                 
                                           




                                            
                                                                   


                                         

                                                   


       

                                               




                            
                                 





                                  
                                                                   


















                                                                                                 

                                       
     


                                                                             


                  

                                       

     


                                                                                                      

     
                                                       
                   
                                   












                                                            
                            
                            
                                
                
                                           










                                                

                                   













                                                                                                                

                                     







                                        

                                                          


                   
                                                         











                                                                     



                                                                               
                       
                                                             











                           
                                                         















                                                                                                  
                                                                                                     


                                

                                                                                                            




















                                                                                                       
                                                                       









                                   

                                        

                          
                                       








                                                                

















                                                                                                                        


                                                                                                


       
                                                                                                                
 
                                                                                                                                        
















                                                                                       
                                       
                                                                                

                                                           














                                                                                                     
                                                                                                                                         







                                                       


                                                             







                                


                                                                                             


       
                                                                                                          

               
                                                                                                                                        




                                                     
                                           

                           
                                        


                                              

                                                   



               
                                                                                                                                       
                                                     
                                              




                                                

                                                     





         

                                                                                                                                                                                                                            
 
                                                                                                                                                                                         

                                                                                                                                                                                             


                                                                                                                                       

                                                                                              

     
                                                         

                                                        


                                                                                                                    


                                            













                                                                                        

                               



                                 







































                                                                                                       


                                                                                                                                                      

                                                                                                                                                 



                                                                                                                                                     
                                                        
                                                                                                                   

     
                                        

     
                                     


                                        

             
                                 

                                     




                                            
                                                                       


                                                                      





                                                                       

     

                                                 



                         
                            

                              

     

                                                   

     
                                                                                      
                                 


                  

                                  

     


                                                                                                 

     



                                                  

     

                                             

     
                                                                               
                               


                  

                                 

     


                                                                                                

     
                                                 
                   







                                                  
                                                                                       















                                                                                                   




                                                            
                      
                            
                           
                
                                                       


              
                     
                            
                          
                








                                                      







                                                


                              





                                










                                                                                                                

                                



                                  







                                        

                                                            


                   
                                                           


                       








                                                                     

















                                                                         








                           
                                                           





                                                                          
                                                                                           


                                

                                                                                                  



                                  
                                                                                         


                                











                                                                                                      




















                                                                                                       
                                                                         

                           






                                   















                                     


















                                                                                                                        




                                                                                                                      



                                                                                                  


       
                                                                                                                    
 
                                                                                                                                          








                                                                           








                                                                                       

















                                                                                       










                                                                                                     
                                                                                                                                           


                                            




                                                       









                                                         





                               


                                                                                               


       
                                                                                                              

               
                                                                                                                                          

                                                     
                                      

                           
                                     

                           

                                        
         
                                        


                                        





                                          


               
                                                                                                                                         
                                                     
                                              
                              



                                                           









                                                          




       

                                                                                                                                                                                                                                

                                                                                                                                                                                         
                                                                                                                                                                                              
                                                                                                                                                                                         


                                                                                                                                       

                                                                                               


                                        
                                          
                                                                



                                                                                                                    

                                             















                                                                                        

                                  

                                












































                                                                                                                                                      
                                                                                                                                                      
                                                                                                                          



                                                                                                                                                    
                                                        
                                                                                                                    

     
                                         

     
                                      
                       

                                               


                                 
                                     
                                     




                                            
                                                                         


                                         

                                             
       














                                                                                                                          

     

                                                  




                            
                              
                              





                                  
                                                                      


















                                                                                                 

                                    

     
                                                                          
                                     


                  

                                    

     


                                                                                                   

     
                                                    
                   
                                


       


































                                                                                                   









                                                            
                         
                            
                             
                
                                        


              







                                                              







                                                

                                
 


                                












                                                                                                                

                                  

                                  







                                        

                                                             


                   
                                                            











                                                                     



                                                                         
                       
                                                       


                       








                                                                         








                           
                                                            















                                                                                                  
                                                                                               


                                

                                                                                                      



                                  









                                                                                                      
















                                                                                                       
                                                                          









                                   

                                     

                          
                                    

                    







                                     
























                                                                                                                        


                                                                                                   


       
                                                                                                                      
 
                                                                                                                                           
















                                                                                       
                                    
                                                                                

                                                        



                                                                                       


                                                                             


                                                                                            
                   





                                                             







                                                                                       










                                                                                                     
                                                                                                                                            







                                                       


                                                          

                                



                                                                                                                                                                                  
                                                                                              
             

                                                   




                                





                               


                                                                                                


       
                                                                                                                

               
                                                                                                                                           




                                                     
                                        

                           



                                        


                                              

                                                
         


                                                      
                                                                                              
             

                                                   


             


               
                                                                                                                                          
                                                     
                                              




                                                

                                                  
         

                              


                                                                                                                                                                                             
             





                                                       



                                           




       


                                                                                                                                                                                                                                        

                                                                                                                                                                                         
                                                                                                                                                                                             


                                                                                                                                       

                                                                                                 

     

                                                         
                                                        


                                                                                                                    
                                        

                                            













                                                                                        



                               

                                 







































                                                                                                       


                                                                                                                                                      



                                                                                                                                                 

                                                                                                                                                     
                                                        
                                                                                                                      

     
                                           

     
                                        
                                        

                                       

             

                                 
                                     




                                            
                                                                             





                                                                      


                                                                       

     

                                                    



                         

                            
                              

     



                                                   
                                                                                         






















                                                                                                 
                                                                                  


















                                                                                                



                                                  
                                                                                          


















                                                                                                   

                                                            















                                                       







                                                      




                                                





                              


                                










                                                                                                                



                                

                                  







                                        

                                                               


                   
                                                              


                       

















                                                                     








                                                                         








                           
                                                              





                                                                          



















                                                                                                  









                                                                                                      
















                                                                                                       
                                                                            

                           














                                   







                                     


















                                                                                                                        





                                                                                                                      


                                                                                                     


       
                                                                                                                          
 
                                                                                                                                             








                                                                           

















                                                                                       








                                                                                       










                                                                                                     
                                                                                                                                              


                                            









                                                       




                                                         





                               


                                                                                                  


       
                                                                                                                    

               
                                                                                                                                             

                                                     
                                      
                           

                                     
                           
         
                                        
                           
         
                                        





                                        


                                          


               
                                                                                                                                            
                                                     
                                              
                              



                                                           
                              



                                                     
                              



                                                          




       

                                                                                                                                                                                                                        

                                                                                                                                                                                         
                                                                                                                                                                                              


                                                                                                                                       

                                                                                             


                                        
                                          



                                                                                                                    
                                             















                                                                                        

                                  












































                                                                                                                                                      
                                                                                                                                                      
                                                                                                                          
                                                        
                                                                                                                  

     
                                       

     
                                    
                       
                         


                                 
                                     




                                            
                                                                     


                                         

                                             
       

     

                                                




                            
                              





                                  
                                                                    


















                                                                                                 

                                    

     
                                                                        
                                     


                  

                                    

     


                                                                                                   

     
                                                    
                   
                                


       









                                                            
                         
                            
                             
                
                                        


              







                                                

                                
 












                                                                                                                

                                  







                                        

                                                           


                   
                                                          











                                                                     



                                                                         
                       
                                                       


                       








                           
                                                          















                                                                                                  
                                                                                               


                                

                                                                                                      



                                  
















                                                                                                       
                                                                        









                                   

                                     

                          
                                    

                    
























                                                                                                                        


                                                                                                 


       
                                                                                                                  
 
                                                                                                                                         
















                                                                                       
                                    
                                                                                

                                                        



                                                                                       










                                                                                                     
                                                                                                                                          







                                                       


                                                          

                                





                               


                                                                                              


       
                                                                                                            

               
                                                                                                                                         




                                                     
                                        

                           
                                        


                                              

                                                
         


               
                                                                                                                                        
                                                     
                                              




                                                

                                                  
         




       

                                                                                                                                                                                                                                
 
                                                                                                                                                                                 

                                                                                                                                                                                         
                                                                                                                                                                                             


                                                                                                                                       

                                                                                               

     
                                                            

                                                         
                                                        


                                                                                                                    
                                   
                                        

                                            













                                                                                        

                            



                               

                                 







































                                                                                                       


                                                                                                                                                      



                                                                                                                                            



                                                                                                                                                 

                                                                                                                                                     
                                                        
                                                                                                                    

     
                                         

     

                                           
                                        

                                       

             
                             

                                 
                                     




                                            















                                                                                                                  





                                                                      


                                                                       

     

                                                  



                         
                          

                            
                              

     


































                                                                                               



                                                   
                                                                                       






















                                                                                                 
                                                                                


















                                                                                                



                                                  
                                                                                        


















                                                                                                   

                                                            







                                                          















                                                       







                                                      




                                                


                            





                              


                                










                                                                                                                

                              



                                

                                  







                                        

                                                             


                   
                                                            


                       








                                                                 

















                                                                     








                                                                         








                           
                                                            





                                                                          









                                                                                              
                                                                                           


                                

                                                                                                  



                                  
                                                                                         


                                

                                                                                                



                                  
                                                                                               


                                

                                                                                                      




















                                                                                                       
                                                                          

                           







                                  














                                   







                                     


















                                                                                                                        





                                                                                                                      


                                                                                                   


       
                                                                                                                      
 
                                                                                                                                           







                                                                           
                                   


                                                                             


                                                                                        
                   





                                                         







                                                                                       

















                                                                                       








                                                                                       










                                                                                                     
                                                                                                                                            


                                            



                                                                                                                                                                              
                                                                                          
             

                                                   




                                









                                                       




                                                         





                               


                                                                                                


       
                                                                                                                

               
                                                                                                                                           

                                                     
                                    

                           
                                      

                           
                                     

                           






                                                  
                                                                                          
             

                                                   


             





                                        


                                          


               
                                                                                                                                          
                                                     
                                              
                              
           


                                                                                                                                                                                             
             





                                                   




                                       



                                                           
                              



                                                     
                              



                                                          




       

                                                                                                                                                                                                

                                                                                                                                                                                         

                                                                                                                                                                                              


                                                                                                                                       

                                                                                       


                                        

                                          



                                                                                                                    

                                             















                                                                                        



                                  












































                                                                                                                                                      



                                                                                                                                                      
                                                        
                                                                                                            

     
                                 

     
                              
                       

                         


                                 

                                     




                                            
                                                         


                                         




                                             


       

                                          




                            

                              





                                  
                                                              


















                                                                                                 

                                    

     

                                                                  


                  

                                    

     


                                                                                                   

     
                                                    
                   
























                                                                                                  












                                                            
                         
                            
                             
                








                                        










                                                




                                













                                                                                                                



                                  







                                        

                                                     


                   
                                                    











                                                                     



                                                                         
                       









                                                                       











                           
                                                    















                                                                                                  
                                                                                               


                                











                                                                                                      




















                                                                                                       
                                                                  









                                   

                                     

                          








                                    


























                                                                                                                        


                                                                                           


       
                                                                                                      
 
                                                                                                                                   
















                                                                                       











                                                                                       














                                                                                                     
                                                                                                                                    







                                                       







                                                          







                                


                                                                                        


       
                                                                                                

               
                                                                                                                                   




                                                     
                                        

                           



                                        


                                              




                                                



               
                                                                                                                                  
                                                     
                                              




                                                





                                                  





         

                                                                                                                                                                                                        
 
                                                                                                                                                                                         

                                                                                                                                                                                             


                                                                                                                                       

                                                                                         

     
                                                         
                                                   
                                                        


                                                                                                                    
                                        

                                            













                                                                                        

                               


                                 
                                










































                                                                                                                                                      

                                                                                                                                                 

                                                                                                                                               
                                                                                                                                                     

                                                                                                        
                                                                                                              

     
                                   

     
                                
                                        
                                  
                                       

             
                                 
                               
                                     




                                            
                                                             


                                                                      


                                                               

                                                                       


       

                                            



                         
                            
                           
                              

     

                                                   

     

                                                                                 


                  

                                  

     


                                                                                                 

     
                                                  
                   
                              


       

                                             

     

                                                                          


                  

                                 

     


                                                                                                

     
                                                 
                   
                             


       

                                                  

     
                                                                                  
                                     


                  

                                    

     


                                                                                                   

     
                                                    
                   
                                




                                                            
                      
                            
                           
                
                                                       


              
                     
                            
                          
                
                                                 


              
                        
                            
                             
                
                                                      







                                                


                              


                             

                                











                                                                                                                

                                

                               

                                  







                                        

                                                       


                   
                                                      


                       








                                                                     








                                                                   



                                                                         
                       
                                                       











                           
                                                      





                                                                          
                                                                                           


                                

                                                                                                  



                                  
                                                                                         


                                

                                                                                                



                                  
                                                                                               


                                

                                                                                                      




















                                                                                                       
                                                                    

                           

                                   

                          
                                  


                                  

                                  

                          
                                 


                                  

                                     

                          
                                    


























                                                                                                                        


                                                                                             


       
                                                                                                          
 
                                                                                                                                     








                                                                           








                                                                                       









                                                                                       
                                                                                


                                                                














                                                                                                     
                                                                                                                                      


                                            




                                                       




                                                      


                                                         







                                


                                                                                          


       
                                                                                                    

               
                                                                                                                                     

                                                     
                                      

                           
                                     

                           
                                        


                                        


                                        


                                       

                                          



               
                                                                                                                                    


                                                     



                                                           




                                                     
                              


                                                          





         

                                                                                                                                                                                                

                                                                                                                                                                                         
                                                                                                                                                                                    


                                                                                                                                       

                                                                                       







                                                                                                                    
                                   















                                                                                        
                            
















































                                                                                                                                                      
                                                                                                            

     
                                 

     
                              










                                            
                                                         







                                                       

                                          











                                  
                                                              






















                                                                                                 
                                                                






































































                                                                                                                

                                                     


                   
                                                    





























                                                                     
                                                    


                                                                          












                                                                                                  


























                                                                                                       
                                                                  
                           


                                   

                          
                                  


                                  


































                                                                                                                        


                                                                                           


       
                                                                                                      
 
                                                                                                                                   
















                                                                                       
                              


















                                                                                                     
                                                                                                                                    


















                                                       


                                                                                        


       
                                                                                                

               
                                                                                                                                   




                                                     
                                    
                           
         
                                        








                                              
                                                                                                                                  
                                                     
                                              













                                                

                                                                                                                                                                                                        
 
                                                                                                                                                                                    
                                                                                                                                                                                         
                                                                                                                                                                                             


                                                                                                                                       

                                                                                         

     
                                      
                                                         
                                                        


                                                                                                                    
                                   
                                        
                                            













                                                                                        

                            

                               
                                 
                                










































                                                                                                                                                      

                                                                                                                                            

                                                                                                                                                 

                                                                                                                                                     
                                                        
                                                                                                              

     
                                   

     

                                
                                        
                                       

             
                             
                                 
                                     




                                            



                                                             


                                                                      


                                                                       

     

                                            



                         
                          
                            
                              

     

                                

     

                                                            


                  

                                

     


                                                                                               

     
                                                
                   
                            


       

                                                   

     

                                                                                 


                  

                                  

     


                                                                                                 

     
                                                  
                   
                              






                                                  
                                                                                  















                                                                                                   




                                                            
                   
                            
                         
                
                                    


              
                      
                            
                           
                
                                                       







                                                      







                                                


                            


                              


                                










                                                                                                                

                              

                                

                                  







                                        

                                                       


                   
                                                      


                       








                                                                 








                                                                     








                                                                         








                           
                                                      





                                                                          
                                                                                       


                                

                                                                                              



                                  
                                                                                           


                                

                                                                                                  




                                                                                               


                                

                                                                                                      




















                                                                                                       
                                                                    

                           

                                 

                          
                                


                                  

                                   

                          
                                  







                                     


























                                                                                                                        


                                                                                             


       
                                                                                                          
 
                                                                                                                                     








                                                                           



                                                                                



                                                                                       
                                 
                                                                                


                                                                 



                                                                                       
                                   







                                                                                       










                                                                                                     
                                                                                                                                      


                                            




                                                    




                                                       




                                                         





                               


                                                                                          


       
                                                                                                    

               
                                                                                                                                     

                                                     
                                    

                           
                                      

                           

                                        
         
                                        


                                            


                                        


                                          


               
                                                                                                                                    
                                                     
                                              
                              



                                              



                                                           




                                                          




       

                                                                                                                                                                                                

                                                                                                                                                                                         

                                                                                                                                                                                         


                                                                                                                                       

                                                                                       


                                        

                                            


                                                                                                                    


                                        















                                                                                        



                               












































                                                                                                                                                      



                                                                                                                                                 
                                                        
                                                                                                            

     
                                 

     



                              


                                 

                                 




                                            
                                                         


                                         





                                                       

     

                                          




                            

                            





                                  
                                                              


















                                                                                                 















































                                                                                                 









                                                            















                                          







                                                





                              












                                                                                                                



                                







                                        

                                                     


                   
                                                    







                                                                     
                                                   


                       

















                                                                     








                           
                                                    















                                                                                                  



















                                                                                                  
















                                                                                                       
                                                                  








                                   















                                   






                                                                


                            

















                                                                                                                        


                                                                                           


       
                                                                                                      
 
                                                                                                                                   
















                                                                                       
















                                                                                       










                                                                                                     
                                                                                                                                    







                                                       









                                                       





                               


                                                                                        


       
                                                                                                

               
                                                                                                                                   




                                                     






                                        


                                              





                                              


               
                                                                                                                                  
                                                     
                                              



                                                








                                                




       

                                                                                                                                                                                                        
 
                                                                                                                                                                                         

                                                                                                                                                                                             


                                                                                                                                       

                                                                                         

     
                                                         
                                                   
                                                        


                                                                                                                    
                                        

                                            













                                                                                        

                               


                                 
                                







































                                                                                                       


                                                                                                                                                      

                                                                                                                                                 

                                                                                                                                               
                                                                                                                                                     

                                                                                                        
                                                                                                              

     
                                   

     
                                
                                        
                                  
                                       

             
                                 
                               
                                     




                                            
                                                             


                                                                      


                                                               

                                                                       


       

                                            



                         
                            
                           
                              

     

                                                   

     

                                                                                 


                  

                                  

     


                                                                                                 

     
                                                  
                   
                              
       

     

                                             

     

                                                                          


                  

                                 

     


                                                                                                

     
                                                 
                   
                             


       

                                                  

     
                                                                                  
                                     


                  

                                    

     


                                                                                                   

     
                                                    
                   
                                




                                                            
                      
                            
                           
                
                                                       


              
                     
                            
                          
                
                                                 


              
                        
                            
                             
                
                                                      







                                                


                              


                             

                                











                                                                                                                

                                

                               

                                  







                                        

                                                       


                   
                                                      


                       








                                                                     








                                                                   



                                                                         
                       
                                                       











                           
                                                      





                                                                          
                                                                                           


                                

                                                                                                  



                                  
                                                                                         


                                

                                                                                                



                                  
                                                                                               


                                

                                                                                                      




















                                                                                                       
                                                                    

                           

                                   

                          
                                  
       

                                  

                                  

                          
                                 

                    


                                     

                          
                                    




















                                                                                                                        





                                                                                                                      


                                                                                             


       
                                                                                                          
 
                                                                                                                                     








                                                                           








                                                                                       









                                                                                       
                                                                                


                                                                














                                                                                                     
                                                                                                                                      


                                            




                                                       




                                                      


                                                         







                                


                                                                                          


       
                                                                                                    

               
                                                                                                                                     

                                                     
                                      

                           
                                     

                           
                                        


                                        


                                        


                                       

                                          



               
                                                                                                                                    


                                                     



                                                           




                                                     
                              


                                                          





         

                                                                                                                                                                                                    

                                                                                                                                                                                         
                                                                                                                                                                           


                                                                                                                                       

                                                                                        


                                        
                                


                                                                                                                    
                                        
                             















                                                                                        

                         







































                                                                                                       

                                                 




                                                                                                                                                      

                                                                                                                                      
                                                        
                                                                                                             

     
                                  

     
                               
                       
               


                                 

                         




                                            

                                                           


                                         
                             

     

                                           




                            

                          





                                  
                                                               


















                                                                                                 

                          

     


                                                  


                  

                                                                                   

     


                                                                                            

     

                                                                                        

     









                                                            
                
                            
                      
                
                                  


              







                                                

                                          
 












                                                                                                                

                           







                                        

                                                      


                   
                                                     











                                                                     



                                                      
                       
                                   


                       








                           
                                                     















                                                                                                  
                                                                                 


                                

                                                                                        



                                  
















                                                                                                       
                                                                   








                                   
                                  

                           
                    


















                                                                                                                        

                                                                                                                                      





                                                                                                                      


                                                                                            


       
                                                                                                        
 
                                                                                                                                    
















                                                                                       



                                                                             



                                                                                       










                                                                                                     
                                                                                                                                     


                                            


                                                       

                                


                                               





                               


                                                                                         


       
                                                                                                  

               
                                                                                                                                    




                                                     
                                 


                                        


                                              

                                      
         


               
                                                                                                                                   
                                                     
                                              



                                                
                              

                                        
         




       

                                                                                                                                                                                                            
 
                                                                                                                                                                                  
                                                                                                                                                                                         
                                                                                                                                                                                             


                                                                                                                                       

                                                                                          

     
                                                    
                                                         
                                                        



                                                                                                                    
                                        
                                            

















                                                                                        
                                 
                                











































                                                                                                                                                      

                                                                                                                               

                                                                                                                                                 

                                                                                                                                                     
                                                        
                                                                                                               

     
                                    

     

                                   
                                        
                                       



                                 
                                     




                                            
                                                               
                                 




                                                                                                   



                                                                      


                                                                       

     

                                             





                            
                              

     















                                                                     


                          
                                                                           






















                                                                                               
                                                                                  


















                                                                                                 



                                                  
                                                                                   


















                                                                                                   





                                                            
                                                  










                                                       







                                                      










                                                


                                














                                                                                                                

                                  







                                        

                                                        


                   
                                                       




















                                                                     








                                                                         








                           
                                                       

























                                                                                                  









                                                                                                      
















                                                                                                       
                                                                     
















                                   
                                  






                                     
























                                                                                                                        


                                                                                              


       
                                                                                                            
 
                                                                                                                                      









                                                                           

                                                                              


                                                                                    
                   



                                                    


                                      













                                                                                       
                                   







                                                                                       










                                                                                                     
                                                                                                                                       




                                                    

                                                                                                                                       
                                                          
             
                                    


                                 






                                                       




                                                         





                               


                                                                                           


       
                                                                                                      

               
                                                                                                                                      




                                                     


                                      
                                        
                           
         
                                        
                                    

                                                  
                                                          
             
                                    

             



                                        


                                          


               
                                                                                                                                     
                                                     
                                              
                              
           


                                                                                                                                                       
             



                                              

             






                                                           
                              



                                                          




       

                                                                                                                                                                                                                

                                                                                                                                                                                         
                                                                                                                                                                                         


                                                                                                                                       

                                                                                           


                                        
                                        



                                                                                                                    
                                        















                                                                                        

                               












































                                                                                                                                                      
                                                                                                                                                 

                                                                                                                          
                                                                                                                

     
                                     

     
                                  
                       
                       


                                 
                                 




                                            
                                                                 


                                         

                                         


       

                                              




                            
                            





                                  
                                                                  


















                                                                                                 

                                  

     

                                                                  


                  

                                  

     


                                                                                                 

     
                                                  
                   
                              












                                                            
                      
                            
                           
                
                                      










                                                

                              













                                                                                                                

                                







                                        

                                                         


                   
                                                        











                                                                     



                                                                     
                       
                                                   











                           
                                                        















                                                                                                  
                                                                                           


                                

                                                                                                  




















                                                                                                       
                                                                      









                                   

                                   

                          
                                  


























                                                                                                                        


                                                                                               


       
                                                                                                              
 
                                                                                                                                       
















                                                                                       
                                 
                                                                                

                                                      














                                                                                                     
                                                                                                                                        







                                                       


                                                       







                                


                                                                                            


       
                                                                                                        

               
                                                                                                                                       




                                                     
                                      





                                              

                                              



               
                                                                                                                                      






                                                     

                                                





         

                                                                                                                                                                                                                        
 
                                                                                                                                                                                    

                                                                                                                                                                                         
                                                                                                                                                                                             


                                                                                                                                       

                                                                                             

     
                                           

                                                         
                                                        




                                                                                                                    

                                            



















                                                                                        

                                 











































                                                                                                                                                      
                                                                                                                       



                                                                                                                                                 

                                                                                                                                                     
                                                        
                                                                                                                  

     
                                       

     

                                    
                                        

                                       




                                 
                                     




                                            
                                                                     
                                 
                                                      






                                                                      


                                                                       

     

                                                






                            
                              

     
                                     


                          
                                                                     






















                                                                                               
                                                                                     






















                                                                                                 
                                                                              


















                                                                                                



                                                  
                                                                                      


















                                                                                                   





                                                            
                                         


















                                                       







                                                      













                                                


                                
















                                                                                                                

                                  







                                        

                                                           


                   
                                                          





























                                                                     








                                                                         








                           
                                                          



































                                                                                                  









                                                                                                      
















                                                                                                       
                                                                        
























                                   







                                     






                                                                


                            

















                                                                                                                        


                                                                                                 


       
                                                                                                                  
 
                                                                                                                                         









                                                                           


                                                                                






















                                                                                       








                                                                                       










                                                                                                     
                                                                                                                                          




                                                    
                                      











                                                       




                                                         





                               


                                                                                              


       
                                                                                                            

               
                                                                                                                                         










                                                     



                                        
                                    
                                      






                                        


                                          


               
                                                                                                                                        
                                                     
                                              
                              

                                             











                                                           




                                                          




       

                                                                                                                                                                                                

                                                                                                                                                                                         
                                                                                                                                                                                         


                                                                                                                                       

                                                                                       


                                        
                                        



                                                                                                                    
                                        















                                                                                        

                               












































                                                                                                                                                      
                                                                                                                                                 

                                                                                                                          
                                                                                                            

     
                                 

     
                              
                       
                       


                                 
                                 




                                            
                                                         


                                         

                                         


       

                                          




                            
                            





                                  
                                                              


















                                                                                                 

                                  

     

                                                              


                  

                                  

     


                                                                                                 

     
                                                  
                   
                              












                                                            
                      
                            
                           
                
                                      










                                                

                              













                                                                                                                

                                







                                        

                                                     


                   
                                                    











                                                                     



                                                                     
                       
                                                   











                           
                                                    















                                                                                                  
                                                                                           


                                

                                                                                                  




















                                                                                                       
                                                                  









                                   

                                   

                          
                                  


























                                                                                                                        


                                                                                           


       
                                                                                                      
 
                                                                                                                                   
















                                                                                       
                                 
                                                                                

                                                      














                                                                                                     
                                                                                                                                    







                                                       


                                                       







                                


                                                                                        


       
                                                                                                

               
                                                                                                                                   




                                                     
                                      





                                              

                                              



               
                                                                                                                                  






                                                     

                                                





         

                                                                                                                                                                                                        
 

                                                                                                                                                                                         
                                                                                                                                                                                             


                                                                                                                                       

                                                                                         

     

                                                         
                                                        


                                                                                                                    
                                        

                                            













                                                                                        



                               

                                 










































                                                                                                                                                      



                                                                                                                                                 

                                                                                                                                                     
                                                        
                                                                                                              

     
                                   

     
                                
                                        

                                       

             

                                 
                                     




                                            
                                                             





                                                                      


                                                                       

     

                                            



                         

                            
                              





                                                   
                                                                                 






















                                                                                                 
                                                                          


















                                                                                                























                                                                                                   

                                                            















                                                       







                                                      




                                                





                              


                                










                                                                                                                



                                

                                  







                                        

                                                       


                   
                                                      


                       

















                                                                     








                                                                         








                           
                                                      





                                                                          
                                                                                           


                                

                                                                                                  



                                  
                                                                                         


                                

                                                                                                



                                  
                                                                                               


                                

                                                                                                      




















                                                                                                       
                                                                    

                           














                                   







                                     
























                                                                                                                        


                                                                                             


       
                                                                                                          
 
                                                                                                                                     








                                                                           

















                                                                                       








                                                                                       










                                                                                                     
                                                                                                                                      


                                            









                                                       




                                                         





                               


                                                                                          


       
                                                                                                    

               
                                                                                                                                     

                                                     
                                      

                           
                                     

                           
                                        


                                        





                                        


                                          


               
                                                                                                                                    


                                                     



                                                           
                              



                                                     




                                                          




       

                                                                                                                                                                                                                                        


                                                                                                                                                                                         
                                                                                                                                                                                         


                                                                                                                                       

                                                                                                 



                                        
                                                                  



                                                                                                                    

                                           

















                                                                                        

                                














































                                                                                                                                                      



                                                                                                                                                    
                                                        
                                                                                                                      

     
                                           

     
                                        
                       

                                                 



                                 
                                     




                                            
                                                                             





                                         














                                                                                                                              

     

                                                    





                            
                              





                                  
                                                                        






















                                                                                                 
                                                                        


















                                                                                                 


































                                                                                                    

















                                                            







                                                                










                                                


                                














                                                                                                                

                                  







                                        

                                                               


                   
                                                              




















                                                                     








                                                                         








                           
                                                              

























                                                                                                  









                                                                                                      
















                                                                                                       
                                                                            
















                                   







                                     
























                                                                                                                        


                                                                                                     


       
                                                                                                                          
 
                                                                                                                                             
























                                                                                       


                                                                             


                                                                                              
                   





                                                             







                                                                                       










                                                                                                     
                                                                                                                                              












                                                       



                                                                                                                                                                                  
                                                                                                
             

                                                   




                                





                               


                                                                                                  


       
                                                                                                                    

               
                                                                                                                                             







                                                     



                                        





                                              


                                                      
                                                                                                
             

                                                   


             


               
                                                                                                                                            
                                                     
                                              







                                                

                              


                                                                                                                                                                                             
             





                                                       



                                           




       

                                                                                                                                                                                                                                                
 

                                                                                                                                                                                         
                                                                                                                                                                                             


                                                                                                                                       

                                                                                                   

     

                                                         
                                                        


                                                                                                                    
                                        

                                            













                                                                                        



                               

                                 







































                                                                                                       


                                                                                                                                                      



                                                                                                                                                 

                                                                                                                                                     
                                                        
                                                                                                                        

     
                                             

     
                                          
                                        

                                       

             

                                 
                                     




                                            
                                                                                 





                                                                      


                                                                       

     

                                                      



                         

                            
                              





                                                   
                                                                                           






















                                                                                                 
                                                                                    


















                                                                                                























                                                                                                   

                                                            















                                                       







                                                      




                                                





                              


                                










                                                                                                                



                                

                                  







                                        

                                                                 


                   
                                                                


                       

















                                                                     








                                                                         








                           
                                                                





                                                                          
                                                                                           


                                

                                                                                                  



                                  
                                                                                         


                                

                                                                                                



                                  
                                                                                               


                                

                                                                                                      




















                                                                                                       
                                                                              

                           














                                   







                                     


















                                                                                                                        





                                                                                                                      


                                                                                                       


       
                                                                                                                              
 
                                                                                                                                               








                                                                           

















                                                                                       








                                                                                       










                                                                                                     
                                                                                                                                                


                                            









                                                       




                                                         





                               


                                                                                                    


       
                                                                                                                        

               
                                                                                                                                               

                                                     
                                      

                           
                                     

                           
                                        


                                        





                                        


                                          


               
                                                                                                                                              


                                                     



                                                           
                              



                                                     




                                                          




       

                                                                                                                                                                                                                                


                                                                                                                                                                                         


                                                                                                                                       

                                                                                               



                                        



                                                                                                                    
                                        

















                                                                                        














































                                                                                                                                                      
                                                        
                                                                                                                    

     
                                         

     
                                      
                       
                       



                                 




                                            
                                                                         





                                         

     

                                                  





                            





                                  
                                                                      






















                                                                                                 
                                                                      


















                                                                                                 

















                                                            










                                                














                                                                                                                







                                        

                                                             


                   
                                                            




















                                                                     








                           
                                                            

























                                                                                                  
















                                                                                                       
                                                                          
















                                   
























                                                                                                                        


                                                                                                   


       
                                                                                                                      
 
                                                                                                                                           
























                                                                                       










                                                                                                     
                                                                                                                                            












                                                       





                               


                                                                                                


       
                                                                                                                

               
                                                                                                                                           







                                                     
                                        





                                              


               
                                                                                                                                          
                                                     
                                              







                                                




       

                                                                                                                                                                                                                                        
 
                                                                                                                                                                                 

                                                                                                                                                                                         
                                                                                                                                                                                             


                                                                                                                                       

                                                                                                 

     
                                                              

                                                         
                                                        




                                                                                                                    

                                            



















                                                                                        

                                 







































                                                                                                       



                                                                                                                                                      


                                                                                                                                   



                                                                                                                                                 

                                                                                                                                                     
                                                        
                                                                                                                      

     
                                           

     

                                             
                                        

                                       


                             

                                 
                                     




                                            















                                                                                                                      





                                                                      


                                                                       

     

                                                    



                         
                          

                            




                                                              

     







                                                                  


                          
                                                                                            
                             



                                
                          



                                                                                               
                                  


                                                


                            





                                                   
                                                                                         






















                                                                                                 
                                                                                  


















                                                                                                























                                                                                                   





                                                            
                                                            


















                                                       







                                                      





                                                
                            






                              


                                
















                                                                                                                

                                  







                                        

                                                               


                   
                                                              


                       

                                                                 


                                                            
                                               




















                                                                     








                                                                         








                           
                                                              



































                                                                                                  









                                                                                                      
















                                                                                                       
                                                                            


                            




                                 
















                                   







                                     


















                                                                                                                        





                                                                                                                      


                                                                                                     


       
                                                                                                                          
 
                                                                                                                                             









                                                                           

                                                                             


                                                                                          
                   





                                                         


                                     






















                                                                                       








                                                                                       










                                                                                                     
                                                                                                                                              


                                            
                                     
                                                    

                                                                                                                                                                              
                                                                                            
             

                                                   


                                











                                                       




                                                         





                               


                                                                                                  


       
                                                                                                                    

               
                                                                                                                                             










                                                     



                                        
                                    

                                                  
                                                                                            
             

                                                   

             






                                        


                                          


               
                                                                                                                                            
                                                     
                                              
                              
           


                                                                                                                                                                                             
             





                                                   

             











                                                           




                                                          




       

                                                                                                                                                                                                        


                                                                                                                                                                                         
                                                                                                                                                                                            


                                                                                                                                       

                                                                                         



                                        
                                         



                                                                                                                    

                                           

















                                                                                        

                                 














































                                                                                                                                                      

                                                                                                                                                    
                                                        
                                                                                                              

     
                                   

     
                                
                       

                        



                                 
                                   




                                            
                                                             





                                         


                                           

     

                                            





                            
                             





                                  
                                                                






















                                                                                                 
                                                                


















                                                                                                 























                                                                                                  

















                                                            







                                       










                                                


                               














                                                                                                                

                                 







                                        

                                                       


                   
                                                      




















                                                                     








                                                                       








                           
                                                      

























                                                                                                  









                                                                                                    
















                                                                                                       
                                                                    
















                                   







                                    
























                                                                                                                        


                                                                                             


       
                                                                                                          
 
                                                                                                                                     
























                                                                                       







                                                                                       










                                                                                                     
                                                                                                                                      












                                                       




                                                         




                               



                                                                                          


       
                                                                                                    

               
                                                                                                                                     







                                                     



                                        





                                              


                                               


               
                                                                                                                                    
                                                     
                                              







                                                



                                                 




       

                                                                                                                                                                                                                
 

                                                                                                                                                                                         
                                                                                                                                                                                             


                                                                                                                                       

                                                                                           

     

                                                         
                                                        


                                                                                                                    
                                        

                                            













                                                                                        



                               

                                 










































                                                                                                                                                      



                                                                                                                                                 

                                                                                                                                                     
                                                        
                                                                                                                

     
                                     

     
                                  
                                        

                                       

             

                                 
                                     




                                            
                                                                 





                                                                      


                                                                       

     

                                              



                         

                            
                              





                                                   
                                                                                   






















                                                                                                 
                                                                            


















                                                                                                























                                                                                                   

                                                            















                                                       







                                                      




                                                





                              


                                










                                                                                                                



                                

                                  







                                        

                                                         


                   
                                                        


                       

















                                                                     








                                                                         








                           
                                                        





                                                                          
                                                                                           


                                

                                                                                                  



                                  
                                                                                         


                                

                                                                                                



                                  
                                                                                               


                                

                                                                                                      




















                                                                                                       
                                                                      

                           














                                   







                                     
























                                                                                                                        


                                                                                               


       
                                                                                                              
 
                                                                                                                                       








                                                                           

















                                                                                       








                                                                                       










                                                                                                     
                                                                                                                                        


                                            









                                                       




                                                         





                               


                                                                                            


       
                                                                                                        

               
                                                                                                                                       

                                                     
                                      

                           
                                     

                           
                                        


                                        





                                        


                                          


               
                                                                                                                                      


                                                     



                                                           
                              



                                                     




                                                          





       
/**
 * Autogenerated by Thrift Compiler (0.9.1)
 *
 * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
 *  @generated
 */
package org.openslx.bwlp.thrift.iface;

import org.apache.thrift.scheme.IScheme;
import org.apache.thrift.scheme.SchemeFactory;
import org.apache.thrift.scheme.StandardScheme;

import org.apache.thrift.scheme.TupleScheme;
import org.apache.thrift.protocol.TTupleProtocol;
import org.apache.thrift.protocol.TProtocolException;
import org.apache.thrift.EncodingUtils;
import org.apache.thrift.TException;
import org.apache.thrift.async.AsyncMethodCallback;
import org.apache.thrift.server.AbstractNonblockingServer.*;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.util.HashMap;
import java.util.EnumMap;
import java.util.Set;
import java.util.HashSet;
import java.util.EnumSet;
import java.util.Collections;
import java.util.BitSet;
import java.nio.ByteBuffer;
import java.util.Arrays;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class SatelliteServer {

  public interface Iface {

    public long getVersion() throws org.apache.thrift.TException;

    public SatelliteConfig getConfiguration() throws org.apache.thrift.TException;

    public TransferInformation requestImageVersionUpload(String userToken, String imageBaseId, long fileSize, List<ByteBuffer> blockHashes, ByteBuffer machineDescription) throws TTransferRejectedException, TAuthorizationException, TInternalServerError, TNotFoundException, org.apache.thrift.TException;

    public void cancelUpload(String uploadToken) throws TInvalidTokenException, org.apache.thrift.TException;

    public TransferStatus queryUploadStatus(String uploadToken) throws TInvalidTokenException, org.apache.thrift.TException;

    public TransferInformation requestDownload(String userToken, String imageVersionId) throws TTransferRejectedException, TAuthorizationException, TInternalServerError, TNotFoundException, org.apache.thrift.TException;

    public void cancelDownload(String downloadToken) throws TInvalidTokenException, org.apache.thrift.TException;

    public ByteBuffer getMachineDescription(String userToken, String imageVersionId) throws TAuthorizationException, TInternalServerError, TNotFoundException, org.apache.thrift.TException;

    public void isAuthenticated(String userToken) throws TAuthorizationException, TInternalServerError, org.apache.thrift.TException;

    public UserInfo whoami(String userToken) throws TAuthorizationException, TInternalServerError, org.apache.thrift.TException;

    public void invalidateSession(String userToken) throws org.apache.thrift.TException;

    public List<UserInfo> getUserList(String userToken, int page) throws TAuthorizationException, TInternalServerError, org.apache.thrift.TException;

    public List<OperatingSystem> getOperatingSystems() throws org.apache.thrift.TException;

    public List<Virtualizer> getVirtualizers() throws org.apache.thrift.TException;

    public List<Organization> getAllOrganizations() throws org.apache.thrift.TException;

    public List<ImageSummaryRead> getImageList(String userToken, List<String> tagSearch, int page) throws TAuthorizationException, TInternalServerError, org.apache.thrift.TException;

    public ImageDetailsRead getImageDetails(String userToken, String imageBaseId) throws TAuthorizationException, TNotFoundException, TInternalServerError, org.apache.thrift.TException;

    public String createImage(String userToken, String imageName) throws TAuthorizationException, TImageDataException, TInternalServerError, org.apache.thrift.TException;

    public void updateImageBase(String userToken, String imageBaseId, ImageBaseWrite image) throws TAuthorizationException, TNotFoundException, TImageDataException, TInternalServerError, org.apache.thrift.TException;

    public void updateImageVersion(String userToken, String imageVersionId, ImageVersionWrite image) throws TAuthorizationException, TNotFoundException, TImageDataException, TInternalServerError, org.apache.thrift.TException;

    public void deleteImageVersion(String userToken, String imageVersionId) throws TAuthorizationException, TNotFoundException, TInternalServerError, org.apache.thrift.TException;

    public void writeImagePermissions(String userToken, String imageBaseId, Map<String,ImagePermissions> permissions) throws TAuthorizationException, TNotFoundException, TInternalServerError, org.apache.thrift.TException;

    public Map<String,ImagePermissions> getImagePermissions(String userToken, String imageBaseId) throws TAuthorizationException, TNotFoundException, TInternalServerError, org.apache.thrift.TException;

    public void setImageOwner(String userToken, String imageBaseId, String newOwnerId) throws TAuthorizationException, TNotFoundException, TInternalServerError, org.apache.thrift.TException;

    public String createLecture(String userToken, LectureWrite lecture) throws TAuthorizationException, TInternalServerError, org.apache.thrift.TException;

    public void updateLecture(String userToken, String lectureId, LectureWrite lecture) throws TAuthorizationException, TNotFoundException, TInternalServerError, org.apache.thrift.TException;

    public List<LectureSummary> getLectureList(String userToken, int page) throws TAuthorizationException, TInternalServerError, org.apache.thrift.TException;

    public LectureRead getLectureDetails(String userToken, String lectureId) throws TAuthorizationException, TNotFoundException, TInternalServerError, org.apache.thrift.TException;

    public void deleteLecture(String userToken, String lectureId) throws TAuthorizationException, TNotFoundException, TInternalServerError, org.apache.thrift.TException;

    public void writeLecturePermissions(String userToken, String lectureId, Map<String,LecturePermissions> permissions) throws TAuthorizationException, TNotFoundException, TInternalServerError, org.apache.thrift.TException;

    public Map<String,LecturePermissions> getLecturePermissions(String userToken, String lectureId) throws TAuthorizationException, TNotFoundException, TInternalServerError, org.apache.thrift.TException;

    public void setLectureOwner(String userToken, String lectureId, String newOwnerId) throws TAuthorizationException, TNotFoundException, TInternalServerError, org.apache.thrift.TException;

  }

  public interface AsyncIface {

    public void getVersion(org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException;

    public void getConfiguration(org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException;

    public void requestImageVersionUpload(String userToken, String imageBaseId, long fileSize, List<ByteBuffer> blockHashes, ByteBuffer machineDescription, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException;

    public void cancelUpload(String uploadToken, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException;

    public void queryUploadStatus(String uploadToken, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException;

    public void requestDownload(String userToken, String imageVersionId, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException;

    public void cancelDownload(String downloadToken, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException;

    public void getMachineDescription(String userToken, String imageVersionId, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException;

    public void isAuthenticated(String userToken, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException;

    public void whoami(String userToken, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException;

    public void invalidateSession(String userToken, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException;

    public void getUserList(String userToken, int page, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException;

    public void getOperatingSystems(org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException;

    public void getVirtualizers(org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException;

    public void getAllOrganizations(org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException;

    public void getImageList(String userToken, List<String> tagSearch, int page, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException;

    public void getImageDetails(String userToken, String imageBaseId, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException;

    public void createImage(String userToken, String imageName, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException;

    public void updateImageBase(String userToken, String imageBaseId, ImageBaseWrite image, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException;

    public void updateImageVersion(String userToken, String imageVersionId, ImageVersionWrite image, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException;

    public void deleteImageVersion(String userToken, String imageVersionId, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException;

    public void writeImagePermissions(String userToken, String imageBaseId, Map<String,ImagePermissions> permissions, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException;

    public void getImagePermissions(String userToken, String imageBaseId, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException;

    public void setImageOwner(String userToken, String imageBaseId, String newOwnerId, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException;

    public void createLecture(String userToken, LectureWrite lecture, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException;

    public void updateLecture(String userToken, String lectureId, LectureWrite lecture, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException;

    public void getLectureList(String userToken, int page, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException;

    public void getLectureDetails(String userToken, String lectureId, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException;

    public void deleteLecture(String userToken, String lectureId, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException;

    public void writeLecturePermissions(String userToken, String lectureId, Map<String,LecturePermissions> permissions, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException;

    public void getLecturePermissions(String userToken, String lectureId, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException;

    public void setLectureOwner(String userToken, String lectureId, String newOwnerId, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException;

  }

  public static class Client extends org.apache.thrift.TServiceClient implements Iface {
    public static class Factory implements org.apache.thrift.TServiceClientFactory<Client> {
      public Factory() {}
      public Client getClient(org.apache.thrift.protocol.TProtocol prot) {
        return new Client(prot);
      }
      public Client getClient(org.apache.thrift.protocol.TProtocol iprot, org.apache.thrift.protocol.TProtocol oprot) {
        return new Client(iprot, oprot);
      }
    }

    public Client(org.apache.thrift.protocol.TProtocol prot)
    {
      super(prot, prot);
    }

    public Client(org.apache.thrift.protocol.TProtocol iprot, org.apache.thrift.protocol.TProtocol oprot) {
      super(iprot, oprot);
    }

    public long getVersion() throws org.apache.thrift.TException
    {
      send_getVersion();
      return recv_getVersion();
    }

    public void send_getVersion() throws org.apache.thrift.TException
    {
      getVersion_args args = new getVersion_args();
      sendBase("getVersion", args);
    }

    public long recv_getVersion() throws org.apache.thrift.TException
    {
      getVersion_result result = new getVersion_result();
      receiveBase(result, "getVersion");
      if (result.isSetSuccess()) {
        return result.success;
      }
      throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "getVersion failed: unknown result");
    }

    public SatelliteConfig getConfiguration() throws org.apache.thrift.TException
    {
      send_getConfiguration();
      return recv_getConfiguration();
    }

    public void send_getConfiguration() throws org.apache.thrift.TException
    {
      getConfiguration_args args = new getConfiguration_args();
      sendBase("getConfiguration", args);
    }

    public SatelliteConfig recv_getConfiguration() throws org.apache.thrift.TException
    {
      getConfiguration_result result = new getConfiguration_result();
      receiveBase(result, "getConfiguration");
      if (result.isSetSuccess()) {
        return result.success;
      }
      throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "getConfiguration failed: unknown result");
    }

    public TransferInformation requestImageVersionUpload(String userToken, String imageBaseId, long fileSize, List<ByteBuffer> blockHashes, ByteBuffer machineDescription) throws TTransferRejectedException, TAuthorizationException, TInternalServerError, TNotFoundException, org.apache.thrift.TException
    {
      send_requestImageVersionUpload(userToken, imageBaseId, fileSize, blockHashes, machineDescription);
      return recv_requestImageVersionUpload();
    }

    public void send_requestImageVersionUpload(String userToken, String imageBaseId, long fileSize, List<ByteBuffer> blockHashes, ByteBuffer machineDescription) throws org.apache.thrift.TException
    {
      requestImageVersionUpload_args args = new requestImageVersionUpload_args();
      args.setUserToken(userToken);
      args.setImageBaseId(imageBaseId);
      args.setFileSize(fileSize);
      args.setBlockHashes(blockHashes);
      args.setMachineDescription(machineDescription);
      sendBase("requestImageVersionUpload", args);
    }

    public TransferInformation recv_requestImageVersionUpload() throws TTransferRejectedException, TAuthorizationException, TInternalServerError, TNotFoundException, org.apache.thrift.TException
    {
      requestImageVersionUpload_result result = new requestImageVersionUpload_result();
      receiveBase(result, "requestImageVersionUpload");
      if (result.isSetSuccess()) {
        return result.success;
      }
      if (result.rejection != null) {
        throw result.rejection;
      }
      if (result.authError != null) {
        throw result.authError;
      }
      if (result.ffff != null) {
        throw result.ffff;
      }
      if (result.sdf != null) {
        throw result.sdf;
      }
      throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "requestImageVersionUpload failed: unknown result");
    }

    public void cancelUpload(String uploadToken) throws TInvalidTokenException, org.apache.thrift.TException
    {
      send_cancelUpload(uploadToken);
      recv_cancelUpload();
    }

    public void send_cancelUpload(String uploadToken) throws org.apache.thrift.TException
    {
      cancelUpload_args args = new cancelUpload_args();
      args.setUploadToken(uploadToken);
      sendBase("cancelUpload", args);
    }

    public void recv_cancelUpload() throws TInvalidTokenException, org.apache.thrift.TException
    {
      cancelUpload_result result = new cancelUpload_result();
      receiveBase(result, "cancelUpload");
      if (result.ex1 != null) {
        throw result.ex1;
      }
      return;
    }

    public TransferStatus queryUploadStatus(String uploadToken) throws TInvalidTokenException, org.apache.thrift.TException
    {
      send_queryUploadStatus(uploadToken);
      return recv_queryUploadStatus();
    }

    public void send_queryUploadStatus(String uploadToken) throws org.apache.thrift.TException
    {
      queryUploadStatus_args args = new queryUploadStatus_args();
      args.setUploadToken(uploadToken);
      sendBase("queryUploadStatus", args);
    }

    public TransferStatus recv_queryUploadStatus() throws TInvalidTokenException, org.apache.thrift.TException
    {
      queryUploadStatus_result result = new queryUploadStatus_result();
      receiveBase(result, "queryUploadStatus");
      if (result.isSetSuccess()) {
        return result.success;
      }
      if (result.ex1 != null) {
        throw result.ex1;
      }
      throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "queryUploadStatus failed: unknown result");
    }

    public TransferInformation requestDownload(String userToken, String imageVersionId) throws TTransferRejectedException, TAuthorizationException, TInternalServerError, TNotFoundException, org.apache.thrift.TException
    {
      send_requestDownload(userToken, imageVersionId);
      return recv_requestDownload();
    }

    public void send_requestDownload(String userToken, String imageVersionId) throws org.apache.thrift.TException
    {
      requestDownload_args args = new requestDownload_args();
      args.setUserToken(userToken);
      args.setImageVersionId(imageVersionId);
      sendBase("requestDownload", args);
    }

    public TransferInformation recv_requestDownload() throws TTransferRejectedException, TAuthorizationException, TInternalServerError, TNotFoundException, org.apache.thrift.TException
    {
      requestDownload_result result = new requestDownload_result();
      receiveBase(result, "requestDownload");
      if (result.isSetSuccess()) {
        return result.success;
      }
      if (result.rejection != null) {
        throw result.rejection;
      }
      if (result.authError != null) {
        throw result.authError;
      }
      if (result.ffff != null) {
        throw result.ffff;
      }
      if (result.sdf != null) {
        throw result.sdf;
      }
      throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "requestDownload failed: unknown result");
    }

    public void cancelDownload(String downloadToken) throws TInvalidTokenException, org.apache.thrift.TException
    {
      send_cancelDownload(downloadToken);
      recv_cancelDownload();
    }

    public void send_cancelDownload(String downloadToken) throws org.apache.thrift.TException
    {
      cancelDownload_args args = new cancelDownload_args();
      args.setDownloadToken(downloadToken);
      sendBase("cancelDownload", args);
    }

    public void recv_cancelDownload() throws TInvalidTokenException, org.apache.thrift.TException
    {
      cancelDownload_result result = new cancelDownload_result();
      receiveBase(result, "cancelDownload");
      if (result.ex1 != null) {
        throw result.ex1;
      }
      return;
    }

    public ByteBuffer getMachineDescription(String userToken, String imageVersionId) throws TAuthorizationException, TInternalServerError, TNotFoundException, org.apache.thrift.TException
    {
      send_getMachineDescription(userToken, imageVersionId);
      return recv_getMachineDescription();
    }

    public void send_getMachineDescription(String userToken, String imageVersionId) throws org.apache.thrift.TException
    {
      getMachineDescription_args args = new getMachineDescription_args();
      args.setUserToken(userToken);
      args.setImageVersionId(imageVersionId);
      sendBase("getMachineDescription", args);
    }

    public ByteBuffer recv_getMachineDescription() throws TAuthorizationException, TInternalServerError, TNotFoundException, org.apache.thrift.TException
    {
      getMachineDescription_result result = new getMachineDescription_result();
      receiveBase(result, "getMachineDescription");
      if (result.isSetSuccess()) {
        return result.success;
      }
      if (result.authError != null) {
        throw result.authError;
      }
      if (result.ffff != null) {
        throw result.ffff;
      }
      if (result.sdf != null) {
        throw result.sdf;
      }
      throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "getMachineDescription failed: unknown result");
    }

    public void isAuthenticated(String userToken) throws TAuthorizationException, TInternalServerError, org.apache.thrift.TException
    {
      send_isAuthenticated(userToken);
      recv_isAuthenticated();
    }

    public void send_isAuthenticated(String userToken) throws org.apache.thrift.TException
    {
      isAuthenticated_args args = new isAuthenticated_args();
      args.setUserToken(userToken);
      sendBase("isAuthenticated", args);
    }

    public void recv_isAuthenticated() throws TAuthorizationException, TInternalServerError, org.apache.thrift.TException
    {
      isAuthenticated_result result = new isAuthenticated_result();
      receiveBase(result, "isAuthenticated");
      if (result.authError != null) {
        throw result.authError;
      }
      if (result.serverError != null) {
        throw result.serverError;
      }
      return;
    }

    public UserInfo whoami(String userToken) throws TAuthorizationException, TInternalServerError, org.apache.thrift.TException
    {
      send_whoami(userToken);
      return recv_whoami();
    }

    public void send_whoami(String userToken) throws org.apache.thrift.TException
    {
      whoami_args args = new whoami_args();
      args.setUserToken(userToken);
      sendBase("whoami", args);
    }

    public UserInfo recv_whoami() throws TAuthorizationException, TInternalServerError, org.apache.thrift.TException
    {
      whoami_result result = new whoami_result();
      receiveBase(result, "whoami");
      if (result.isSetSuccess()) {
        return result.success;
      }
      if (result.authError != null) {
        throw result.authError;
      }
      if (result.serverError != null) {
        throw result.serverError;
      }
      throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "whoami failed: unknown result");
    }

    public void invalidateSession(String userToken) throws org.apache.thrift.TException
    {
      send_invalidateSession(userToken);
      recv_invalidateSession();
    }

    public void send_invalidateSession(String userToken) throws org.apache.thrift.TException
    {
      invalidateSession_args args = new invalidateSession_args();
      args.setUserToken(userToken);
      sendBase("invalidateSession", args);
    }

    public void recv_invalidateSession() throws org.apache.thrift.TException
    {
      invalidateSession_result result = new invalidateSession_result();
      receiveBase(result, "invalidateSession");
      return;
    }

    public List<UserInfo> getUserList(String userToken, int page) throws TAuthorizationException, TInternalServerError, org.apache.thrift.TException
    {
      send_getUserList(userToken, page);
      return recv_getUserList();
    }

    public void send_getUserList(String userToken, int page) throws org.apache.thrift.TException
    {
      getUserList_args args = new getUserList_args();
      args.setUserToken(userToken);
      args.setPage(page);
      sendBase("getUserList", args);
    }

    public List<UserInfo> recv_getUserList() throws TAuthorizationException, TInternalServerError, org.apache.thrift.TException
    {
      getUserList_result result = new getUserList_result();
      receiveBase(result, "getUserList");
      if (result.isSetSuccess()) {
        return result.success;
      }
      if (result.failure != null) {
        throw result.failure;
      }
      if (result.serverError != null) {
        throw result.serverError;
      }
      throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "getUserList failed: unknown result");
    }

    public List<OperatingSystem> getOperatingSystems() throws org.apache.thrift.TException
    {
      send_getOperatingSystems();
      return recv_getOperatingSystems();
    }

    public void send_getOperatingSystems() throws org.apache.thrift.TException
    {
      getOperatingSystems_args args = new getOperatingSystems_args();
      sendBase("getOperatingSystems", args);
    }

    public List<OperatingSystem> recv_getOperatingSystems() throws org.apache.thrift.TException
    {
      getOperatingSystems_result result = new getOperatingSystems_result();
      receiveBase(result, "getOperatingSystems");
      if (result.isSetSuccess()) {
        return result.success;
      }
      throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "getOperatingSystems failed: unknown result");
    }

    public List<Virtualizer> getVirtualizers() throws org.apache.thrift.TException
    {
      send_getVirtualizers();
      return recv_getVirtualizers();
    }

    public void send_getVirtualizers() throws org.apache.thrift.TException
    {
      getVirtualizers_args args = new getVirtualizers_args();
      sendBase("getVirtualizers", args);
    }

    public List<Virtualizer> recv_getVirtualizers() throws org.apache.thrift.TException
    {
      getVirtualizers_result result = new getVirtualizers_result();
      receiveBase(result, "getVirtualizers");
      if (result.isSetSuccess()) {
        return result.success;
      }
      throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "getVirtualizers failed: unknown result");
    }

    public List<Organization> getAllOrganizations() throws org.apache.thrift.TException
    {
      send_getAllOrganizations();
      return recv_getAllOrganizations();
    }

    public void send_getAllOrganizations() throws org.apache.thrift.TException
    {
      getAllOrganizations_args args = new getAllOrganizations_args();
      sendBase("getAllOrganizations", args);
    }

    public List<Organization> recv_getAllOrganizations() throws org.apache.thrift.TException
    {
      getAllOrganizations_result result = new getAllOrganizations_result();
      receiveBase(result, "getAllOrganizations");
      if (result.isSetSuccess()) {
        return result.success;
      }
      throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "getAllOrganizations failed: unknown result");
    }

    public List<ImageSummaryRead> getImageList(String userToken, List<String> tagSearch, int page) throws TAuthorizationException, TInternalServerError, org.apache.thrift.TException
    {
      send_getImageList(userToken, tagSearch, page);
      return recv_getImageList();
    }

    public void send_getImageList(String userToken, List<String> tagSearch, int page) throws org.apache.thrift.TException
    {
      getImageList_args args = new getImageList_args();
      args.setUserToken(userToken);
      args.setTagSearch(tagSearch);
      args.setPage(page);
      sendBase("getImageList", args);
    }

    public List<ImageSummaryRead> recv_getImageList() throws TAuthorizationException, TInternalServerError, org.apache.thrift.TException
    {
      getImageList_result result = new getImageList_result();
      receiveBase(result, "getImageList");
      if (result.isSetSuccess()) {
        return result.success;
      }
      if (result.authError != null) {
        throw result.authError;
      }
      if (result.serverError != null) {
        throw result.serverError;
      }
      throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "getImageList failed: unknown result");
    }

    public ImageDetailsRead getImageDetails(String userToken, String imageBaseId) throws TAuthorizationException, TNotFoundException, TInternalServerError, org.apache.thrift.TException
    {
      send_getImageDetails(userToken, imageBaseId);
      return recv_getImageDetails();
    }

    public void send_getImageDetails(String userToken, String imageBaseId) throws org.apache.thrift.TException
    {
      getImageDetails_args args = new getImageDetails_args();
      args.setUserToken(userToken);
      args.setImageBaseId(imageBaseId);
      sendBase("getImageDetails", args);
    }

    public ImageDetailsRead recv_getImageDetails() throws TAuthorizationException, TNotFoundException, TInternalServerError, org.apache.thrift.TException
    {
      getImageDetails_result result = new getImageDetails_result();
      receiveBase(result, "getImageDetails");
      if (result.isSetSuccess()) {
        return result.success;
      }
      if (result.authError != null) {
        throw result.authError;
      }
      if (result.notFound != null) {
        throw result.notFound;
      }
      if (result.serverError != null) {
        throw result.serverError;
      }
      throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "getImageDetails failed: unknown result");
    }

    public String createImage(String userToken, String imageName) throws TAuthorizationException, TImageDataException, TInternalServerError, org.apache.thrift.TException
    {
      send_createImage(userToken, imageName);
      return recv_createImage();
    }

    public void send_createImage(String userToken, String imageName) throws org.apache.thrift.TException
    {
      createImage_args args = new createImage_args();
      args.setUserToken(userToken);
      args.setImageName(imageName);
      sendBase("createImage", args);
    }

    public String recv_createImage() throws TAuthorizationException, TImageDataException, TInternalServerError, org.apache.thrift.TException
    {
      createImage_result result = new createImage_result();
      receiveBase(result, "createImage");
      if (result.isSetSuccess()) {
        return result.success;
      }
      if (result.authError != null) {
        throw result.authError;
      }
      if (result.imgError != null) {
        throw result.imgError;
      }
      if (result.serverError != null) {
        throw result.serverError;
      }
      throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "createImage failed: unknown result");
    }

    public void updateImageBase(String userToken, String imageBaseId, ImageBaseWrite image) throws TAuthorizationException, TNotFoundException, TImageDataException, TInternalServerError, org.apache.thrift.TException
    {
      send_updateImageBase(userToken, imageBaseId, image);
      recv_updateImageBase();
    }

    public void send_updateImageBase(String userToken, String imageBaseId, ImageBaseWrite image) throws org.apache.thrift.TException
    {
      updateImageBase_args args = new updateImageBase_args();
      args.setUserToken(userToken);
      args.setImageBaseId(imageBaseId);
      args.setImage(image);
      sendBase("updateImageBase", args);
    }

    public void recv_updateImageBase() throws TAuthorizationException, TNotFoundException, TImageDataException, TInternalServerError, org.apache.thrift.TException
    {
      updateImageBase_result result = new updateImageBase_result();
      receiveBase(result, "updateImageBase");
      if (result.authError != null) {
        throw result.authError;
      }
      if (result.notFound != null) {
        throw result.notFound;
      }
      if (result.imgError != null) {
        throw result.imgError;
      }
      if (result.serverError != null) {
        throw result.serverError;
      }
      return;
    }

    public void updateImageVersion(String userToken, String imageVersionId, ImageVersionWrite image) throws TAuthorizationException, TNotFoundException, TImageDataException, TInternalServerError, org.apache.thrift.TException
    {
      send_updateImageVersion(userToken, imageVersionId, image);
      recv_updateImageVersion();
    }

    public void send_updateImageVersion(String userToken, String imageVersionId, ImageVersionWrite image) throws org.apache.thrift.TException
    {
      updateImageVersion_args args = new updateImageVersion_args();
      args.setUserToken(userToken);
      args.setImageVersionId(imageVersionId);
      args.setImage(image);
      sendBase("updateImageVersion", args);
    }

    public void recv_updateImageVersion() throws TAuthorizationException, TNotFoundException, TImageDataException, TInternalServerError, org.apache.thrift.TException
    {
      updateImageVersion_result result = new updateImageVersion_result();
      receiveBase(result, "updateImageVersion");
      if (result.authError != null) {
        throw result.authError;
      }
      if (result.notFound != null) {
        throw result.notFound;
      }
      if (result.imgError != null) {
        throw result.imgError;
      }
      if (result.serverError != null) {
        throw result.serverError;
      }
      return;
    }

    public void deleteImageVersion(String userToken, String imageVersionId) throws TAuthorizationException, TNotFoundException, TInternalServerError, org.apache.thrift.TException
    {
      send_deleteImageVersion(userToken, imageVersionId);
      recv_deleteImageVersion();
    }

    public void send_deleteImageVersion(String userToken, String imageVersionId) throws org.apache.thrift.TException
    {
      deleteImageVersion_args args = new deleteImageVersion_args();
      args.setUserToken(userToken);
      args.setImageVersionId(imageVersionId);
      sendBase("deleteImageVersion", args);
    }

    public void recv_deleteImageVersion() throws TAuthorizationException, TNotFoundException, TInternalServerError, org.apache.thrift.TException
    {
      deleteImageVersion_result result = new deleteImageVersion_result();
      receiveBase(result, "deleteImageVersion");
      if (result.authError != null) {
        throw result.authError;
      }
      if (result.notFound != null) {
        throw result.notFound;
      }
      if (result.serverError != null) {
        throw result.serverError;
      }
      return;
    }

    public void writeImagePermissions(String userToken, String imageBaseId, Map<String,ImagePermissions> permissions) throws TAuthorizationException, TNotFoundException, TInternalServerError, org.apache.thrift.TException
    {
      send_writeImagePermissions(userToken, imageBaseId, permissions);
      recv_writeImagePermissions();
    }

    public void send_writeImagePermissions(String userToken, String imageBaseId, Map<String,ImagePermissions> permissions) throws org.apache.thrift.TException
    {
      writeImagePermissions_args args = new writeImagePermissions_args();
      args.setUserToken(userToken);
      args.setImageBaseId(imageBaseId);
      args.setPermissions(permissions);
      sendBase("writeImagePermissions", args);
    }

    public void recv_writeImagePermissions() throws TAuthorizationException, TNotFoundException, TInternalServerError, org.apache.thrift.TException
    {
      writeImagePermissions_result result = new writeImagePermissions_result();
      receiveBase(result, "writeImagePermissions");
      if (result.authError != null) {
        throw result.authError;
      }
      if (result.notFound != null) {
        throw result.notFound;
      }
      if (result.serverError != null) {
        throw result.serverError;
      }
      return;
    }

    public Map<String,ImagePermissions> getImagePermissions(String userToken, String imageBaseId) throws TAuthorizationException, TNotFoundException, TInternalServerError, org.apache.thrift.TException
    {
      send_getImagePermissions(userToken, imageBaseId);
      return recv_getImagePermissions();
    }

    public void send_getImagePermissions(String userToken, String imageBaseId) throws org.apache.thrift.TException
    {
      getImagePermissions_args args = new getImagePermissions_args();
      args.setUserToken(userToken);
      args.setImageBaseId(imageBaseId);
      sendBase("getImagePermissions", args);
    }

    public Map<String,ImagePermissions> recv_getImagePermissions() throws TAuthorizationException, TNotFoundException, TInternalServerError, org.apache.thrift.TException
    {
      getImagePermissions_result result = new getImagePermissions_result();
      receiveBase(result, "getImagePermissions");
      if (result.isSetSuccess()) {
        return result.success;
      }
      if (result.authError != null) {
        throw result.authError;
      }
      if (result.notFound != null) {
        throw result.notFound;
      }
      if (result.serverError != null) {
        throw result.serverError;
      }
      throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "getImagePermissions failed: unknown result");
    }

    public void setImageOwner(String userToken, String imageBaseId, String newOwnerId) throws TAuthorizationException, TNotFoundException, TInternalServerError, org.apache.thrift.TException
    {
      send_setImageOwner(userToken, imageBaseId, newOwnerId);
      recv_setImageOwner();
    }

    public void send_setImageOwner(String userToken, String imageBaseId, String newOwnerId) throws org.apache.thrift.TException
    {
      setImageOwner_args args = new setImageOwner_args();
      args.setUserToken(userToken);
      args.setImageBaseId(imageBaseId);
      args.setNewOwnerId(newOwnerId);
      sendBase("setImageOwner", args);
    }

    public void recv_setImageOwner() throws TAuthorizationException, TNotFoundException, TInternalServerError, org.apache.thrift.TException
    {
      setImageOwner_result result = new setImageOwner_result();
      receiveBase(result, "setImageOwner");
      if (result.authError != null) {
        throw result.authError;
      }
      if (result.notFound != null) {
        throw result.notFound;
      }
      if (result.serverError != null) {
        throw result.serverError;
      }
      return;
    }

    public String createLecture(String userToken, LectureWrite lecture) throws TAuthorizationException, TInternalServerError, org.apache.thrift.TException
    {
      send_createLecture(userToken, lecture);
      return recv_createLecture();
    }

    public void send_createLecture(String userToken, LectureWrite lecture) throws org.apache.thrift.TException
    {
      createLecture_args args = new createLecture_args();
      args.setUserToken(userToken);
      args.setLecture(lecture);
      sendBase("createLecture", args);
    }

    public String recv_createLecture() throws TAuthorizationException, TInternalServerError, org.apache.thrift.TException
    {
      createLecture_result result = new createLecture_result();
      receiveBase(result, "createLecture");
      if (result.isSetSuccess()) {
        return result.success;
      }
      if (result.authError != null) {
        throw result.authError;
      }
      if (result.serverError != null) {
        throw result.serverError;
      }
      throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "createLecture failed: unknown result");
    }

    public void updateLecture(String userToken, String lectureId, LectureWrite lecture) throws TAuthorizationException, TNotFoundException, TInternalServerError, org.apache.thrift.TException
    {
      send_updateLecture(userToken, lectureId, lecture);
      recv_updateLecture();
    }

    public void send_updateLecture(String userToken, String lectureId, LectureWrite lecture) throws org.apache.thrift.TException
    {
      updateLecture_args args = new updateLecture_args();
      args.setUserToken(userToken);
      args.setLectureId(lectureId);
      args.setLecture(lecture);
      sendBase("updateLecture", args);
    }

    public void recv_updateLecture() throws TAuthorizationException, TNotFoundException, TInternalServerError, org.apache.thrift.TException
    {
      updateLecture_result result = new updateLecture_result();
      receiveBase(result, "updateLecture");
      if (result.authError != null) {
        throw result.authError;
      }
      if (result.notFound != null) {
        throw result.notFound;
      }
      if (result.serverError != null) {
        throw result.serverError;
      }
      return;
    }

    public List<LectureSummary> getLectureList(String userToken, int page) throws TAuthorizationException, TInternalServerError, org.apache.thrift.TException
    {
      send_getLectureList(userToken, page);
      return recv_getLectureList();
    }

    public void send_getLectureList(String userToken, int page) throws org.apache.thrift.TException
    {
      getLectureList_args args = new getLectureList_args();
      args.setUserToken(userToken);
      args.setPage(page);
      sendBase("getLectureList", args);
    }

    public List<LectureSummary> recv_getLectureList() throws TAuthorizationException, TInternalServerError, org.apache.thrift.TException
    {
      getLectureList_result result = new getLectureList_result();
      receiveBase(result, "getLectureList");
      if (result.isSetSuccess()) {
        return result.success;
      }
      if (result.authError != null) {
        throw result.authError;
      }
      if (result.serverError != null) {
        throw result.serverError;
      }
      throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "getLectureList failed: unknown result");
    }

    public LectureRead getLectureDetails(String userToken, String lectureId) throws TAuthorizationException, TNotFoundException, TInternalServerError, org.apache.thrift.TException
    {
      send_getLectureDetails(userToken, lectureId);
      return recv_getLectureDetails();
    }

    public void send_getLectureDetails(String userToken, String lectureId) throws org.apache.thrift.TException
    {
      getLectureDetails_args args = new getLectureDetails_args();
      args.setUserToken(userToken);
      args.setLectureId(lectureId);
      sendBase("getLectureDetails", args);
    }

    public LectureRead recv_getLectureDetails() throws TAuthorizationException, TNotFoundException, TInternalServerError, org.apache.thrift.TException
    {
      getLectureDetails_result result = new getLectureDetails_result();
      receiveBase(result, "getLectureDetails");
      if (result.isSetSuccess()) {
        return result.success;
      }
      if (result.authError != null) {
        throw result.authError;
      }
      if (result.notFound != null) {
        throw result.notFound;
      }
      if (result.serverError != null) {
        throw result.serverError;
      }
      throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "getLectureDetails failed: unknown result");
    }

    public void deleteLecture(String userToken, String lectureId) throws TAuthorizationException, TNotFoundException, TInternalServerError, org.apache.thrift.TException
    {
      send_deleteLecture(userToken, lectureId);
      recv_deleteLecture();
    }

    public void send_deleteLecture(String userToken, String lectureId) throws org.apache.thrift.TException
    {
      deleteLecture_args args = new deleteLecture_args();
      args.setUserToken(userToken);
      args.setLectureId(lectureId);
      sendBase("deleteLecture", args);
    }

    public void recv_deleteLecture() throws TAuthorizationException, TNotFoundException, TInternalServerError, org.apache.thrift.TException
    {
      deleteLecture_result result = new deleteLecture_result();
      receiveBase(result, "deleteLecture");
      if (result.authError != null) {
        throw result.authError;
      }
      if (result.notFound != null) {
        throw result.notFound;
      }
      if (result.serverError != null) {
        throw result.serverError;
      }
      return;
    }

    public void writeLecturePermissions(String userToken, String lectureId, Map<String,LecturePermissions> permissions) throws TAuthorizationException, TNotFoundException, TInternalServerError, org.apache.thrift.TException
    {
      send_writeLecturePermissions(userToken, lectureId, permissions);
      recv_writeLecturePermissions();
    }

    public void send_writeLecturePermissions(String userToken, String lectureId, Map<String,LecturePermissions> permissions) throws org.apache.thrift.TException
    {
      writeLecturePermissions_args args = new writeLecturePermissions_args();
      args.setUserToken(userToken);
      args.setLectureId(lectureId);
      args.setPermissions(permissions);
      sendBase("writeLecturePermissions", args);
    }

    public void recv_writeLecturePermissions() throws TAuthorizationException, TNotFoundException, TInternalServerError, org.apache.thrift.TException
    {
      writeLecturePermissions_result result = new writeLecturePermissions_result();
      receiveBase(result, "writeLecturePermissions");
      if (result.authError != null) {
        throw result.authError;
      }
      if (result.notFound != null) {
        throw result.notFound;
      }
      if (result.serverError != null) {
        throw result.serverError;
      }
      return;
    }

    public Map<String,LecturePermissions> getLecturePermissions(String userToken, String lectureId) throws TAuthorizationException, TNotFoundException, TInternalServerError, org.apache.thrift.TException
    {
      send_getLecturePermissions(userToken, lectureId);
      return recv_getLecturePermissions();
    }

    public void send_getLecturePermissions(String userToken, String lectureId) throws org.apache.thrift.TException
    {
      getLecturePermissions_args args = new getLecturePermissions_args();
      args.setUserToken(userToken);
      args.setLectureId(lectureId);
      sendBase("getLecturePermissions", args);
    }

    public Map<String,LecturePermissions> recv_getLecturePermissions() throws TAuthorizationException, TNotFoundException, TInternalServerError, org.apache.thrift.TException
    {
      getLecturePermissions_result result = new getLecturePermissions_result();
      receiveBase(result, "getLecturePermissions");
      if (result.isSetSuccess()) {
        return result.success;
      }
      if (result.authError != null) {
        throw result.authError;
      }
      if (result.notFound != null) {
        throw result.notFound;
      }
      if (result.serverError != null) {
        throw result.serverError;
      }
      throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "getLecturePermissions failed: unknown result");
    }

    public void setLectureOwner(String userToken, String lectureId, String newOwnerId) throws TAuthorizationException, TNotFoundException, TInternalServerError, org.apache.thrift.TException
    {
      send_setLectureOwner(userToken, lectureId, newOwnerId);
      recv_setLectureOwner();
    }

    public void send_setLectureOwner(String userToken, String lectureId, String newOwnerId) throws org.apache.thrift.TException
    {
      setLectureOwner_args args = new setLectureOwner_args();
      args.setUserToken(userToken);
      args.setLectureId(lectureId);
      args.setNewOwnerId(newOwnerId);
      sendBase("setLectureOwner", args);
    }

    public void recv_setLectureOwner() throws TAuthorizationException, TNotFoundException, TInternalServerError, org.apache.thrift.TException
    {
      setLectureOwner_result result = new setLectureOwner_result();
      receiveBase(result, "setLectureOwner");
      if (result.authError != null) {
        throw result.authError;
      }
      if (result.notFound != null) {
        throw result.notFound;
      }
      if (result.serverError != null) {
        throw result.serverError;
      }
      return;
    }

  }
  public static class AsyncClient extends org.apache.thrift.async.TAsyncClient implements AsyncIface {
    public static class Factory implements org.apache.thrift.async.TAsyncClientFactory<AsyncClient> {
      private org.apache.thrift.async.TAsyncClientManager clientManager;
      private org.apache.thrift.protocol.TProtocolFactory protocolFactory;
      public Factory(org.apache.thrift.async.TAsyncClientManager clientManager, org.apache.thrift.protocol.TProtocolFactory protocolFactory) {
        this.clientManager = clientManager;
        this.protocolFactory = protocolFactory;
      }
      public AsyncClient getAsyncClient(org.apache.thrift.transport.TNonblockingTransport transport) {
        return new AsyncClient(protocolFactory, clientManager, transport);
      }
    }

    public AsyncClient(org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.async.TAsyncClientManager clientManager, org.apache.thrift.transport.TNonblockingTransport transport) {
      super(protocolFactory, clientManager, transport);
    }

    public void getVersion(org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException {
      checkReady();
      getVersion_call method_call = new getVersion_call(resultHandler, this, ___protocolFactory, ___transport);
      this.___currentMethod = method_call;
      ___manager.call(method_call);
    }

    public static class getVersion_call extends org.apache.thrift.async.TAsyncMethodCall {
      public getVersion_call(org.apache.thrift.async.AsyncMethodCallback resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
        super(client, protocolFactory, transport, resultHandler, false);
      }

      public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
        prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("getVersion", org.apache.thrift.protocol.TMessageType.CALL, 0));
        getVersion_args args = new getVersion_args();
        args.write(prot);
        prot.writeMessageEnd();
      }

      public long getResult() throws org.apache.thrift.TException {
        if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
          throw new IllegalStateException("Method call not finished!");
        }
        org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
        org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
        return (new Client(prot)).recv_getVersion();
      }
    }

    public void getConfiguration(org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException {
      checkReady();
      getConfiguration_call method_call = new getConfiguration_call(resultHandler, this, ___protocolFactory, ___transport);
      this.___currentMethod = method_call;
      ___manager.call(method_call);
    }

    public static class getConfiguration_call extends org.apache.thrift.async.TAsyncMethodCall {
      public getConfiguration_call(org.apache.thrift.async.AsyncMethodCallback resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
        super(client, protocolFactory, transport, resultHandler, false);
      }

      public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
        prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("getConfiguration", org.apache.thrift.protocol.TMessageType.CALL, 0));
        getConfiguration_args args = new getConfiguration_args();
        args.write(prot);
        prot.writeMessageEnd();
      }

      public SatelliteConfig getResult() throws org.apache.thrift.TException {
        if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
          throw new IllegalStateException("Method call not finished!");
        }
        org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
        org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
        return (new Client(prot)).recv_getConfiguration();
      }
    }

    public void requestImageVersionUpload(String userToken, String imageBaseId, long fileSize, List<ByteBuffer> blockHashes, ByteBuffer machineDescription, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException {
      checkReady();
      requestImageVersionUpload_call method_call = new requestImageVersionUpload_call(userToken, imageBaseId, fileSize, blockHashes, machineDescription, resultHandler, this, ___protocolFactory, ___transport);
      this.___currentMethod = method_call;
      ___manager.call(method_call);
    }

    public static class requestImageVersionUpload_call extends org.apache.thrift.async.TAsyncMethodCall {
      private String userToken;
      private String imageBaseId;
      private long fileSize;
      private List<ByteBuffer> blockHashes;
      private ByteBuffer machineDescription;
      public requestImageVersionUpload_call(String userToken, String imageBaseId, long fileSize, List<ByteBuffer> blockHashes, ByteBuffer machineDescription, org.apache.thrift.async.AsyncMethodCallback resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
        super(client, protocolFactory, transport, resultHandler, false);
        this.userToken = userToken;
        this.imageBaseId = imageBaseId;
        this.fileSize = fileSize;
        this.blockHashes = blockHashes;
        this.machineDescription = machineDescription;
      }

      public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
        prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("requestImageVersionUpload", org.apache.thrift.protocol.TMessageType.CALL, 0));
        requestImageVersionUpload_args args = new requestImageVersionUpload_args();
        args.setUserToken(userToken);
        args.setImageBaseId(imageBaseId);
        args.setFileSize(fileSize);
        args.setBlockHashes(blockHashes);
        args.setMachineDescription(machineDescription);
        args.write(prot);
        prot.writeMessageEnd();
      }

      public TransferInformation getResult() throws TTransferRejectedException, TAuthorizationException, TInternalServerError, TNotFoundException, org.apache.thrift.TException {
        if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
          throw new IllegalStateException("Method call not finished!");
        }
        org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
        org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
        return (new Client(prot)).recv_requestImageVersionUpload();
      }
    }

    public void cancelUpload(String uploadToken, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException {
      checkReady();
      cancelUpload_call method_call = new cancelUpload_call(uploadToken, resultHandler, this, ___protocolFactory, ___transport);
      this.___currentMethod = method_call;
      ___manager.call(method_call);
    }

    public static class cancelUpload_call extends org.apache.thrift.async.TAsyncMethodCall {
      private String uploadToken;
      public cancelUpload_call(String uploadToken, org.apache.thrift.async.AsyncMethodCallback resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
        super(client, protocolFactory, transport, resultHandler, false);
        this.uploadToken = uploadToken;
      }

      public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
        prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("cancelUpload", org.apache.thrift.protocol.TMessageType.CALL, 0));
        cancelUpload_args args = new cancelUpload_args();
        args.setUploadToken(uploadToken);
        args.write(prot);
        prot.writeMessageEnd();
      }

      public void getResult() throws TInvalidTokenException, org.apache.thrift.TException {
        if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
          throw new IllegalStateException("Method call not finished!");
        }
        org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
        org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
        (new Client(prot)).recv_cancelUpload();
      }
    }

    public void queryUploadStatus(String uploadToken, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException {
      checkReady();
      queryUploadStatus_call method_call = new queryUploadStatus_call(uploadToken, resultHandler, this, ___protocolFactory, ___transport);
      this.___currentMethod = method_call;
      ___manager.call(method_call);
    }

    public static class queryUploadStatus_call extends org.apache.thrift.async.TAsyncMethodCall {
      private String uploadToken;
      public queryUploadStatus_call(String uploadToken, org.apache.thrift.async.AsyncMethodCallback resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
        super(client, protocolFactory, transport, resultHandler, false);
        this.uploadToken = uploadToken;
      }

      public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
        prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("queryUploadStatus", org.apache.thrift.protocol.TMessageType.CALL, 0));
        queryUploadStatus_args args = new queryUploadStatus_args();
        args.setUploadToken(uploadToken);
        args.write(prot);
        prot.writeMessageEnd();
      }

      public TransferStatus getResult() throws TInvalidTokenException, org.apache.thrift.TException {
        if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
          throw new IllegalStateException("Method call not finished!");
        }
        org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
        org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
        return (new Client(prot)).recv_queryUploadStatus();
      }
    }

    public void requestDownload(String userToken, String imageVersionId, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException {
      checkReady();
      requestDownload_call method_call = new requestDownload_call(userToken, imageVersionId, resultHandler, this, ___protocolFactory, ___transport);
      this.___currentMethod = method_call;
      ___manager.call(method_call);
    }

    public static class requestDownload_call extends org.apache.thrift.async.TAsyncMethodCall {
      private String userToken;
      private String imageVersionId;
      public requestDownload_call(String userToken, String imageVersionId, org.apache.thrift.async.AsyncMethodCallback resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
        super(client, protocolFactory, transport, resultHandler, false);
        this.userToken = userToken;
        this.imageVersionId = imageVersionId;
      }

      public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
        prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("requestDownload", org.apache.thrift.protocol.TMessageType.CALL, 0));
        requestDownload_args args = new requestDownload_args();
        args.setUserToken(userToken);
        args.setImageVersionId(imageVersionId);
        args.write(prot);
        prot.writeMessageEnd();
      }

      public TransferInformation getResult() throws TTransferRejectedException, TAuthorizationException, TInternalServerError, TNotFoundException, org.apache.thrift.TException {
        if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
          throw new IllegalStateException("Method call not finished!");
        }
        org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
        org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
        return (new Client(prot)).recv_requestDownload();
      }
    }

    public void cancelDownload(String downloadToken, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException {
      checkReady();
      cancelDownload_call method_call = new cancelDownload_call(downloadToken, resultHandler, this, ___protocolFactory, ___transport);
      this.___currentMethod = method_call;
      ___manager.call(method_call);
    }

    public static class cancelDownload_call extends org.apache.thrift.async.TAsyncMethodCall {
      private String downloadToken;
      public cancelDownload_call(String downloadToken, org.apache.thrift.async.AsyncMethodCallback resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
        super(client, protocolFactory, transport, resultHandler, false);
        this.downloadToken = downloadToken;
      }

      public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
        prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("cancelDownload", org.apache.thrift.protocol.TMessageType.CALL, 0));
        cancelDownload_args args = new cancelDownload_args();
        args.setDownloadToken(downloadToken);
        args.write(prot);
        prot.writeMessageEnd();
      }

      public void getResult() throws TInvalidTokenException, org.apache.thrift.TException {
        if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
          throw new IllegalStateException("Method call not finished!");
        }
        org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
        org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
        (new Client(prot)).recv_cancelDownload();
      }
    }

    public void getMachineDescription(String userToken, String imageVersionId, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException {
      checkReady();
      getMachineDescription_call method_call = new getMachineDescription_call(userToken, imageVersionId, resultHandler, this, ___protocolFactory, ___transport);
      this.___currentMethod = method_call;
      ___manager.call(method_call);
    }

    public static class getMachineDescription_call extends org.apache.thrift.async.TAsyncMethodCall {
      private String userToken;
      private String imageVersionId;
      public getMachineDescription_call(String userToken, String imageVersionId, org.apache.thrift.async.AsyncMethodCallback resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
        super(client, protocolFactory, transport, resultHandler, false);
        this.userToken = userToken;
        this.imageVersionId = imageVersionId;
      }

      public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
        prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("getMachineDescription", org.apache.thrift.protocol.TMessageType.CALL, 0));
        getMachineDescription_args args = new getMachineDescription_args();
        args.setUserToken(userToken);
        args.setImageVersionId(imageVersionId);
        args.write(prot);
        prot.writeMessageEnd();
      }

      public ByteBuffer getResult() throws TAuthorizationException, TInternalServerError, TNotFoundException, org.apache.thrift.TException {
        if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
          throw new IllegalStateException("Method call not finished!");
        }
        org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
        org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
        return (new Client(prot)).recv_getMachineDescription();
      }
    }

    public void isAuthenticated(String userToken, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException {
      checkReady();
      isAuthenticated_call method_call = new isAuthenticated_call(userToken, resultHandler, this, ___protocolFactory, ___transport);
      this.___currentMethod = method_call;
      ___manager.call(method_call);
    }

    public static class isAuthenticated_call extends org.apache.thrift.async.TAsyncMethodCall {
      private String userToken;
      public isAuthenticated_call(String userToken, org.apache.thrift.async.AsyncMethodCallback resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
        super(client, protocolFactory, transport, resultHandler, false);
        this.userToken = userToken;
      }

      public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
        prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("isAuthenticated", org.apache.thrift.protocol.TMessageType.CALL, 0));
        isAuthenticated_args args = new isAuthenticated_args();
        args.setUserToken(userToken);
        args.write(prot);
        prot.writeMessageEnd();
      }

      public void getResult() throws TAuthorizationException, TInternalServerError, org.apache.thrift.TException {
        if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
          throw new IllegalStateException("Method call not finished!");
        }
        org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
        org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
        (new Client(prot)).recv_isAuthenticated();
      }
    }

    public void whoami(String userToken, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException {
      checkReady();
      whoami_call method_call = new whoami_call(userToken, resultHandler, this, ___protocolFactory, ___transport);
      this.___currentMethod = method_call;
      ___manager.call(method_call);
    }

    public static class whoami_call extends org.apache.thrift.async.TAsyncMethodCall {
      private String userToken;
      public whoami_call(String userToken, org.apache.thrift.async.AsyncMethodCallback resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
        super(client, protocolFactory, transport, resultHandler, false);
        this.userToken = userToken;
      }

      public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
        prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("whoami", org.apache.thrift.protocol.TMessageType.CALL, 0));
        whoami_args args = new whoami_args();
        args.setUserToken(userToken);
        args.write(prot);
        prot.writeMessageEnd();
      }

      public UserInfo getResult() throws TAuthorizationException, TInternalServerError, org.apache.thrift.TException {
        if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
          throw new IllegalStateException("Method call not finished!");
        }
        org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
        org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
        return (new Client(prot)).recv_whoami();
      }
    }

    public void invalidateSession(String userToken, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException {
      checkReady();
      invalidateSession_call method_call = new invalidateSession_call(userToken, resultHandler, this, ___protocolFactory, ___transport);
      this.___currentMethod = method_call;
      ___manager.call(method_call);
    }

    public static class invalidateSession_call extends org.apache.thrift.async.TAsyncMethodCall {
      private String userToken;
      public invalidateSession_call(String userToken, org.apache.thrift.async.AsyncMethodCallback resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
        super(client, protocolFactory, transport, resultHandler, false);
        this.userToken = userToken;
      }

      public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
        prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("invalidateSession", org.apache.thrift.protocol.TMessageType.CALL, 0));
        invalidateSession_args args = new invalidateSession_args();
        args.setUserToken(userToken);
        args.write(prot);
        prot.writeMessageEnd();
      }

      public void getResult() throws org.apache.thrift.TException {
        if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
          throw new IllegalStateException("Method call not finished!");
        }
        org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
        org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
        (new Client(prot)).recv_invalidateSession();
      }
    }

    public void getUserList(String userToken, int page, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException {
      checkReady();
      getUserList_call method_call = new getUserList_call(userToken, page, resultHandler, this, ___protocolFactory, ___transport);
      this.___currentMethod = method_call;
      ___manager.call(method_call);
    }

    public static class getUserList_call extends org.apache.thrift.async.TAsyncMethodCall {
      private String userToken;
      private int page;
      public getUserList_call(String userToken, int page, org.apache.thrift.async.AsyncMethodCallback resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
        super(client, protocolFactory, transport, resultHandler, false);
        this.userToken = userToken;
        this.page = page;
      }

      public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
        prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("getUserList", org.apache.thrift.protocol.TMessageType.CALL, 0));
        getUserList_args args = new getUserList_args();
        args.setUserToken(userToken);
        args.setPage(page);
        args.write(prot);
        prot.writeMessageEnd();
      }

      public List<UserInfo> getResult() throws TAuthorizationException, TInternalServerError, org.apache.thrift.TException {
        if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
          throw new IllegalStateException("Method call not finished!");
        }
        org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
        org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
        return (new Client(prot)).recv_getUserList();
      }
    }

    public void getOperatingSystems(org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException {
      checkReady();
      getOperatingSystems_call method_call = new getOperatingSystems_call(resultHandler, this, ___protocolFactory, ___transport);
      this.___currentMethod = method_call;
      ___manager.call(method_call);
    }

    public static class getOperatingSystems_call extends org.apache.thrift.async.TAsyncMethodCall {
      public getOperatingSystems_call(org.apache.thrift.async.AsyncMethodCallback resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
        super(client, protocolFactory, transport, resultHandler, false);
      }

      public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
        prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("getOperatingSystems", org.apache.thrift.protocol.TMessageType.CALL, 0));
        getOperatingSystems_args args = new getOperatingSystems_args();
        args.write(prot);
        prot.writeMessageEnd();
      }

      public List<OperatingSystem> getResult() throws org.apache.thrift.TException {
        if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
          throw new IllegalStateException("Method call not finished!");
        }
        org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
        org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
        return (new Client(prot)).recv_getOperatingSystems();
      }
    }

    public void getVirtualizers(org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException {
      checkReady();
      getVirtualizers_call method_call = new getVirtualizers_call(resultHandler, this, ___protocolFactory, ___transport);
      this.___currentMethod = method_call;
      ___manager.call(method_call);
    }

    public static class getVirtualizers_call extends org.apache.thrift.async.TAsyncMethodCall {
      public getVirtualizers_call(org.apache.thrift.async.AsyncMethodCallback resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
        super(client, protocolFactory, transport, resultHandler, false);
      }

      public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
        prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("getVirtualizers", org.apache.thrift.protocol.TMessageType.CALL, 0));
        getVirtualizers_args args = new getVirtualizers_args();
        args.write(prot);
        prot.writeMessageEnd();
      }

      public List<Virtualizer> getResult() throws org.apache.thrift.TException {
        if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
          throw new IllegalStateException("Method call not finished!");
        }
        org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
        org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
        return (new Client(prot)).recv_getVirtualizers();
      }
    }

    public void getAllOrganizations(org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException {
      checkReady();
      getAllOrganizations_call method_call = new getAllOrganizations_call(resultHandler, this, ___protocolFactory, ___transport);
      this.___currentMethod = method_call;
      ___manager.call(method_call);
    }

    public static class getAllOrganizations_call extends org.apache.thrift.async.TAsyncMethodCall {
      public getAllOrganizations_call(org.apache.thrift.async.AsyncMethodCallback resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
        super(client, protocolFactory, transport, resultHandler, false);
      }

      public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
        prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("getAllOrganizations", org.apache.thrift.protocol.TMessageType.CALL, 0));
        getAllOrganizations_args args = new getAllOrganizations_args();
        args.write(prot);
        prot.writeMessageEnd();
      }

      public List<Organization> getResult() throws org.apache.thrift.TException {
        if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
          throw new IllegalStateException("Method call not finished!");
        }
        org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
        org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
        return (new Client(prot)).recv_getAllOrganizations();
      }
    }

    public void getImageList(String userToken, List<String> tagSearch, int page, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException {
      checkReady();
      getImageList_call method_call = new getImageList_call(userToken, tagSearch, page, resultHandler, this, ___protocolFactory, ___transport);
      this.___currentMethod = method_call;
      ___manager.call(method_call);
    }

    public static class getImageList_call extends org.apache.thrift.async.TAsyncMethodCall {
      private String userToken;
      private List<String> tagSearch;
      private int page;
      public getImageList_call(String userToken, List<String> tagSearch, int page, org.apache.thrift.async.AsyncMethodCallback resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
        super(client, protocolFactory, transport, resultHandler, false);
        this.userToken = userToken;
        this.tagSearch = tagSearch;
        this.page = page;
      }

      public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
        prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("getImageList", org.apache.thrift.protocol.TMessageType.CALL, 0));
        getImageList_args args = new getImageList_args();
        args.setUserToken(userToken);
        args.setTagSearch(tagSearch);
        args.setPage(page);
        args.write(prot);
        prot.writeMessageEnd();
      }

      public List<ImageSummaryRead> getResult() throws TAuthorizationException, TInternalServerError, org.apache.thrift.TException {
        if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
          throw new IllegalStateException("Method call not finished!");
        }
        org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
        org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
        return (new Client(prot)).recv_getImageList();
      }
    }

    public void getImageDetails(String userToken, String imageBaseId, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException {
      checkReady();
      getImageDetails_call method_call = new getImageDetails_call(userToken, imageBaseId, resultHandler, this, ___protocolFactory, ___transport);
      this.___currentMethod = method_call;
      ___manager.call(method_call);
    }

    public static class getImageDetails_call extends org.apache.thrift.async.TAsyncMethodCall {
      private String userToken;
      private String imageBaseId;
      public getImageDetails_call(String userToken, String imageBaseId, org.apache.thrift.async.AsyncMethodCallback resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
        super(client, protocolFactory, transport, resultHandler, false);
        this.userToken = userToken;
        this.imageBaseId = imageBaseId;
      }

      public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
        prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("getImageDetails", org.apache.thrift.protocol.TMessageType.CALL, 0));
        getImageDetails_args args = new getImageDetails_args();
        args.setUserToken(userToken);
        args.setImageBaseId(imageBaseId);
        args.write(prot);
        prot.writeMessageEnd();
      }

      public ImageDetailsRead getResult() throws TAuthorizationException, TNotFoundException, TInternalServerError, org.apache.thrift.TException {
        if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
          throw new IllegalStateException("Method call not finished!");
        }
        org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
        org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
        return (new Client(prot)).recv_getImageDetails();
      }
    }

    public void createImage(String userToken, String imageName, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException {
      checkReady();
      createImage_call method_call = new createImage_call(userToken, imageName, resultHandler, this, ___protocolFactory, ___transport);
      this.___currentMethod = method_call;
      ___manager.call(method_call);
    }

    public static class createImage_call extends org.apache.thrift.async.TAsyncMethodCall {
      private String userToken;
      private String imageName;
      public createImage_call(String userToken, String imageName, org.apache.thrift.async.AsyncMethodCallback resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
        super(client, protocolFactory, transport, resultHandler, false);
        this.userToken = userToken;
        this.imageName = imageName;
      }

      public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
        prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("createImage", org.apache.thrift.protocol.TMessageType.CALL, 0));
        createImage_args args = new createImage_args();
        args.setUserToken(userToken);
        args.setImageName(imageName);
        args.write(prot);
        prot.writeMessageEnd();
      }

      public String getResult() throws TAuthorizationException, TImageDataException, TInternalServerError, org.apache.thrift.TException {
        if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
          throw new IllegalStateException("Method call not finished!");
        }
        org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
        org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
        return (new Client(prot)).recv_createImage();
      }
    }

    public void updateImageBase(String userToken, String imageBaseId, ImageBaseWrite image, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException {
      checkReady();
      updateImageBase_call method_call = new updateImageBase_call(userToken, imageBaseId, image, resultHandler, this, ___protocolFactory, ___transport);
      this.___currentMethod = method_call;
      ___manager.call(method_call);
    }

    public static class updateImageBase_call extends org.apache.thrift.async.TAsyncMethodCall {
      private String userToken;
      private String imageBaseId;
      private ImageBaseWrite image;
      public updateImageBase_call(String userToken, String imageBaseId, ImageBaseWrite image, org.apache.thrift.async.AsyncMethodCallback resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
        super(client, protocolFactory, transport, resultHandler, false);
        this.userToken = userToken;
        this.imageBaseId = imageBaseId;
        this.image = image;
      }

      public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
        prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("updateImageBase", org.apache.thrift.protocol.TMessageType.CALL, 0));
        updateImageBase_args args = new updateImageBase_args();
        args.setUserToken(userToken);
        args.setImageBaseId(imageBaseId);
        args.setImage(image);
        args.write(prot);
        prot.writeMessageEnd();
      }

      public void getResult() throws TAuthorizationException, TNotFoundException, TImageDataException, TInternalServerError, org.apache.thrift.TException {
        if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
          throw new IllegalStateException("Method call not finished!");
        }
        org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
        org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
        (new Client(prot)).recv_updateImageBase();
      }
    }

    public void updateImageVersion(String userToken, String imageVersionId, ImageVersionWrite image, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException {
      checkReady();
      updateImageVersion_call method_call = new updateImageVersion_call(userToken, imageVersionId, image, resultHandler, this, ___protocolFactory, ___transport);
      this.___currentMethod = method_call;
      ___manager.call(method_call);
    }

    public static class updateImageVersion_call extends org.apache.thrift.async.TAsyncMethodCall {
      private String userToken;
      private String imageVersionId;
      private ImageVersionWrite image;
      public updateImageVersion_call(String userToken, String imageVersionId, ImageVersionWrite image, org.apache.thrift.async.AsyncMethodCallback resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
        super(client, protocolFactory, transport, resultHandler, false);
        this.userToken = userToken;
        this.imageVersionId = imageVersionId;
        this.image = image;
      }

      public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
        prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("updateImageVersion", org.apache.thrift.protocol.TMessageType.CALL, 0));
        updateImageVersion_args args = new updateImageVersion_args();
        args.setUserToken(userToken);
        args.setImageVersionId(imageVersionId);
        args.setImage(image);
        args.write(prot);
        prot.writeMessageEnd();
      }

      public void getResult() throws TAuthorizationException, TNotFoundException, TImageDataException, TInternalServerError, org.apache.thrift.TException {
        if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
          throw new IllegalStateException("Method call not finished!");
        }
        org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
        org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
        (new Client(prot)).recv_updateImageVersion();
      }
    }

    public void deleteImageVersion(String userToken, String imageVersionId, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException {
      checkReady();
      deleteImageVersion_call method_call = new deleteImageVersion_call(userToken, imageVersionId, resultHandler, this, ___protocolFactory, ___transport);
      this.___currentMethod = method_call;
      ___manager.call(method_call);
    }

    public static class deleteImageVersion_call extends org.apache.thrift.async.TAsyncMethodCall {
      private String userToken;
      private String imageVersionId;
      public deleteImageVersion_call(String userToken, String imageVersionId, org.apache.thrift.async.AsyncMethodCallback resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
        super(client, protocolFactory, transport, resultHandler, false);
        this.userToken = userToken;
        this.imageVersionId = imageVersionId;
      }

      public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
        prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("deleteImageVersion", org.apache.thrift.protocol.TMessageType.CALL, 0));
        deleteImageVersion_args args = new deleteImageVersion_args();
        args.setUserToken(userToken);
        args.setImageVersionId(imageVersionId);
        args.write(prot);
        prot.writeMessageEnd();
      }

      public void getResult() throws TAuthorizationException, TNotFoundException, TInternalServerError, org.apache.thrift.TException {
        if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
          throw new IllegalStateException("Method call not finished!");
        }
        org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
        org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
        (new Client(prot)).recv_deleteImageVersion();
      }
    }

    public void writeImagePermissions(String userToken, String imageBaseId, Map<String,ImagePermissions> permissions, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException {
      checkReady();
      writeImagePermissions_call method_call = new writeImagePermissions_call(userToken, imageBaseId, permissions, resultHandler, this, ___protocolFactory, ___transport);
      this.___currentMethod = method_call;
      ___manager.call(method_call);
    }

    public static class writeImagePermissions_call extends org.apache.thrift.async.TAsyncMethodCall {
      private String userToken;
      private String imageBaseId;
      private Map<String,ImagePermissions> permissions;
      public writeImagePermissions_call(String userToken, String imageBaseId, Map<String,ImagePermissions> permissions, org.apache.thrift.async.AsyncMethodCallback resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
        super(client, protocolFactory, transport, resultHandler, false);
        this.userToken = userToken;
        this.imageBaseId = imageBaseId;
        this.permissions = permissions;
      }

      public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
        prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("writeImagePermissions", org.apache.thrift.protocol.TMessageType.CALL, 0));
        writeImagePermissions_args args = new writeImagePermissions_args();
        args.setUserToken(userToken);
        args.setImageBaseId(imageBaseId);
        args.setPermissions(permissions);
        args.write(prot);
        prot.writeMessageEnd();
      }

      public void getResult() throws TAuthorizationException, TNotFoundException, TInternalServerError, org.apache.thrift.TException {
        if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
          throw new IllegalStateException("Method call not finished!");
        }
        org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
        org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
        (new Client(prot)).recv_writeImagePermissions();
      }
    }

    public void getImagePermissions(String userToken, String imageBaseId, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException {
      checkReady();
      getImagePermissions_call method_call = new getImagePermissions_call(userToken, imageBaseId, resultHandler, this, ___protocolFactory, ___transport);
      this.___currentMethod = method_call;
      ___manager.call(method_call);
    }

    public static class getImagePermissions_call extends org.apache.thrift.async.TAsyncMethodCall {
      private String userToken;
      private String imageBaseId;
      public getImagePermissions_call(String userToken, String imageBaseId, org.apache.thrift.async.AsyncMethodCallback resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
        super(client, protocolFactory, transport, resultHandler, false);
        this.userToken = userToken;
        this.imageBaseId = imageBaseId;
      }

      public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
        prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("getImagePermissions", org.apache.thrift.protocol.TMessageType.CALL, 0));
        getImagePermissions_args args = new getImagePermissions_args();
        args.setUserToken(userToken);
        args.setImageBaseId(imageBaseId);
        args.write(prot);
        prot.writeMessageEnd();
      }

      public Map<String,ImagePermissions> getResult() throws TAuthorizationException, TNotFoundException, TInternalServerError, org.apache.thrift.TException {
        if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
          throw new IllegalStateException("Method call not finished!");
        }
        org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
        org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
        return (new Client(prot)).recv_getImagePermissions();
      }
    }

    public void setImageOwner(String userToken, String imageBaseId, String newOwnerId, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException {
      checkReady();
      setImageOwner_call method_call = new setImageOwner_call(userToken, imageBaseId, newOwnerId, resultHandler, this, ___protocolFactory, ___transport);
      this.___currentMethod = method_call;
      ___manager.call(method_call);
    }

    public static class setImageOwner_call extends org.apache.thrift.async.TAsyncMethodCall {
      private String userToken;
      private String imageBaseId;
      private String newOwnerId;
      public setImageOwner_call(String userToken, String imageBaseId, String newOwnerId, org.apache.thrift.async.AsyncMethodCallback resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
        super(client, protocolFactory, transport, resultHandler, false);
        this.userToken = userToken;
        this.imageBaseId = imageBaseId;
        this.newOwnerId = newOwnerId;
      }

      public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
        prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("setImageOwner", org.apache.thrift.protocol.TMessageType.CALL, 0));
        setImageOwner_args args = new setImageOwner_args();
        args.setUserToken(userToken);
        args.setImageBaseId(imageBaseId);
        args.setNewOwnerId(newOwnerId);
        args.write(prot);
        prot.writeMessageEnd();
      }

      public void getResult() throws TAuthorizationException, TNotFoundException, TInternalServerError, org.apache.thrift.TException {
        if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
          throw new IllegalStateException("Method call not finished!");
        }
        org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
        org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
        (new Client(prot)).recv_setImageOwner();
      }
    }

    public void createLecture(String userToken, LectureWrite lecture, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException {
      checkReady();
      createLecture_call method_call = new createLecture_call(userToken, lecture, resultHandler, this, ___protocolFactory, ___transport);
      this.___currentMethod = method_call;
      ___manager.call(method_call);
    }

    public static class createLecture_call extends org.apache.thrift.async.TAsyncMethodCall {
      private String userToken;
      private LectureWrite lecture;
      public createLecture_call(String userToken, LectureWrite lecture, org.apache.thrift.async.AsyncMethodCallback resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
        super(client, protocolFactory, transport, resultHandler, false);
        this.userToken = userToken;
        this.lecture = lecture;
      }

      public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
        prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("createLecture", org.apache.thrift.protocol.TMessageType.CALL, 0));
        createLecture_args args = new createLecture_args();
        args.setUserToken(userToken);
        args.setLecture(lecture);
        args.write(prot);
        prot.writeMessageEnd();
      }

      public String getResult() throws TAuthorizationException, TInternalServerError, org.apache.thrift.TException {
        if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
          throw new IllegalStateException("Method call not finished!");
        }
        org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
        org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
        return (new Client(prot)).recv_createLecture();
      }
    }

    public void updateLecture(String userToken, String lectureId, LectureWrite lecture, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException {
      checkReady();
      updateLecture_call method_call = new updateLecture_call(userToken, lectureId, lecture, resultHandler, this, ___protocolFactory, ___transport);
      this.___currentMethod = method_call;
      ___manager.call(method_call);
    }

    public static class updateLecture_call extends org.apache.thrift.async.TAsyncMethodCall {
      private String userToken;
      private String lectureId;
      private LectureWrite lecture;
      public updateLecture_call(String userToken, String lectureId, LectureWrite lecture, org.apache.thrift.async.AsyncMethodCallback resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
        super(client, protocolFactory, transport, resultHandler, false);
        this.userToken = userToken;
        this.lectureId = lectureId;
        this.lecture = lecture;
      }

      public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
        prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("updateLecture", org.apache.thrift.protocol.TMessageType.CALL, 0));
        updateLecture_args args = new updateLecture_args();
        args.setUserToken(userToken);
        args.setLectureId(lectureId);
        args.setLecture(lecture);
        args.write(prot);
        prot.writeMessageEnd();
      }

      public void getResult() throws TAuthorizationException, TNotFoundException, TInternalServerError, org.apache.thrift.TException {
        if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
          throw new IllegalStateException("Method call not finished!");
        }
        org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
        org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
        (new Client(prot)).recv_updateLecture();
      }
    }

    public void getLectureList(String userToken, int page, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException {
      checkReady();
      getLectureList_call method_call = new getLectureList_call(userToken, page, resultHandler, this, ___protocolFactory, ___transport);
      this.___currentMethod = method_call;
      ___manager.call(method_call);
    }

    public static class getLectureList_call extends org.apache.thrift.async.TAsyncMethodCall {
      private String userToken;
      private int page;
      public getLectureList_call(String userToken, int page, org.apache.thrift.async.AsyncMethodCallback resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
        super(client, protocolFactory, transport, resultHandler, false);
        this.userToken = userToken;
        this.page = page;
      }

      public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
        prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("getLectureList", org.apache.thrift.protocol.TMessageType.CALL, 0));
        getLectureList_args args = new getLectureList_args();
        args.setUserToken(userToken);
        args.setPage(page);
        args.write(prot);
        prot.writeMessageEnd();
      }

      public List<LectureSummary> getResult() throws TAuthorizationException, TInternalServerError, org.apache.thrift.TException {
        if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
          throw new IllegalStateException("Method call not finished!");
        }
        org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
        org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
        return (new Client(prot)).recv_getLectureList();
      }
    }

    public void getLectureDetails(String userToken, String lectureId, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException {
      checkReady();
      getLectureDetails_call method_call = new getLectureDetails_call(userToken, lectureId, resultHandler, this, ___protocolFactory, ___transport);
      this.___currentMethod = method_call;
      ___manager.call(method_call);
    }

    public static class getLectureDetails_call extends org.apache.thrift.async.TAsyncMethodCall {
      private String userToken;
      private String lectureId;
      public getLectureDetails_call(String userToken, String lectureId, org.apache.thrift.async.AsyncMethodCallback resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
        super(client, protocolFactory, transport, resultHandler, false);
        this.userToken = userToken;
        this.lectureId = lectureId;
      }

      public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
        prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("getLectureDetails", org.apache.thrift.protocol.TMessageType.CALL, 0));
        getLectureDetails_args args = new getLectureDetails_args();
        args.setUserToken(userToken);
        args.setLectureId(lectureId);
        args.write(prot);
        prot.writeMessageEnd();
      }

      public LectureRead getResult() throws TAuthorizationException, TNotFoundException, TInternalServerError, org.apache.thrift.TException {
        if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
          throw new IllegalStateException("Method call not finished!");
        }
        org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
        org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
        return (new Client(prot)).recv_getLectureDetails();
      }
    }

    public void deleteLecture(String userToken, String lectureId, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException {
      checkReady();
      deleteLecture_call method_call = new deleteLecture_call(userToken, lectureId, resultHandler, this, ___protocolFactory, ___transport);
      this.___currentMethod = method_call;
      ___manager.call(method_call);
    }

    public static class deleteLecture_call extends org.apache.thrift.async.TAsyncMethodCall {
      private String userToken;
      private String lectureId;
      public deleteLecture_call(String userToken, String lectureId, org.apache.thrift.async.AsyncMethodCallback resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
        super(client, protocolFactory, transport, resultHandler, false);
        this.userToken = userToken;
        this.lectureId = lectureId;
      }

      public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
        prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("deleteLecture", org.apache.thrift.protocol.TMessageType.CALL, 0));
        deleteLecture_args args = new deleteLecture_args();
        args.setUserToken(userToken);
        args.setLectureId(lectureId);
        args.write(prot);
        prot.writeMessageEnd();
      }

      public void getResult() throws TAuthorizationException, TNotFoundException, TInternalServerError, org.apache.thrift.TException {
        if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
          throw new IllegalStateException("Method call not finished!");
        }
        org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
        org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
        (new Client(prot)).recv_deleteLecture();
      }
    }

    public void writeLecturePermissions(String userToken, String lectureId, Map<String,LecturePermissions> permissions, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException {
      checkReady();
      writeLecturePermissions_call method_call = new writeLecturePermissions_call(userToken, lectureId, permissions, resultHandler, this, ___protocolFactory, ___transport);
      this.___currentMethod = method_call;
      ___manager.call(method_call);
    }

    public static class writeLecturePermissions_call extends org.apache.thrift.async.TAsyncMethodCall {
      private String userToken;
      private String lectureId;
      private Map<String,LecturePermissions> permissions;
      public writeLecturePermissions_call(String userToken, String lectureId, Map<String,LecturePermissions> permissions, org.apache.thrift.async.AsyncMethodCallback resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
        super(client, protocolFactory, transport, resultHandler, false);
        this.userToken = userToken;
        this.lectureId = lectureId;
        this.permissions = permissions;
      }

      public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
        prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("writeLecturePermissions", org.apache.thrift.protocol.TMessageType.CALL, 0));
        writeLecturePermissions_args args = new writeLecturePermissions_args();
        args.setUserToken(userToken);
        args.setLectureId(lectureId);
        args.setPermissions(permissions);
        args.write(prot);
        prot.writeMessageEnd();
      }

      public void getResult() throws TAuthorizationException, TNotFoundException, TInternalServerError, org.apache.thrift.TException {
        if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
          throw new IllegalStateException("Method call not finished!");
        }
        org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
        org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
        (new Client(prot)).recv_writeLecturePermissions();
      }
    }

    public void getLecturePermissions(String userToken, String lectureId, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException {
      checkReady();
      getLecturePermissions_call method_call = new getLecturePermissions_call(userToken, lectureId, resultHandler, this, ___protocolFactory, ___transport);
      this.___currentMethod = method_call;
      ___manager.call(method_call);
    }

    public static class getLecturePermissions_call extends org.apache.thrift.async.TAsyncMethodCall {
      private String userToken;
      private String lectureId;
      public getLecturePermissions_call(String userToken, String lectureId, org.apache.thrift.async.AsyncMethodCallback resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
        super(client, protocolFactory, transport, resultHandler, false);
        this.userToken = userToken;
        this.lectureId = lectureId;
      }

      public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
        prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("getLecturePermissions", org.apache.thrift.protocol.TMessageType.CALL, 0));
        getLecturePermissions_args args = new getLecturePermissions_args();
        args.setUserToken(userToken);
        args.setLectureId(lectureId);
        args.write(prot);
        prot.writeMessageEnd();
      }

      public Map<String,LecturePermissions> getResult() throws TAuthorizationException, TNotFoundException, TInternalServerError, org.apache.thrift.TException {
        if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
          throw new IllegalStateException("Method call not finished!");
        }
        org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
        org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
        return (new Client(prot)).recv_getLecturePermissions();
      }
    }

    public void setLectureOwner(String userToken, String lectureId, String newOwnerId, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException {
      checkReady();
      setLectureOwner_call method_call = new setLectureOwner_call(userToken, lectureId, newOwnerId, resultHandler, this, ___protocolFactory, ___transport);
      this.___currentMethod = method_call;
      ___manager.call(method_call);
    }

    public static class setLectureOwner_call extends org.apache.thrift.async.TAsyncMethodCall {
      private String userToken;
      private String lectureId;
      private String newOwnerId;
      public setLectureOwner_call(String userToken, String lectureId, String newOwnerId, org.apache.thrift.async.AsyncMethodCallback resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
        super(client, protocolFactory, transport, resultHandler, false);
        this.userToken = userToken;
        this.lectureId = lectureId;
        this.newOwnerId = newOwnerId;
      }

      public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
        prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("setLectureOwner", org.apache.thrift.protocol.TMessageType.CALL, 0));
        setLectureOwner_args args = new setLectureOwner_args();
        args.setUserToken(userToken);
        args.setLectureId(lectureId);
        args.setNewOwnerId(newOwnerId);
        args.write(prot);
        prot.writeMessageEnd();
      }

      public void getResult() throws TAuthorizationException, TNotFoundException, TInternalServerError, org.apache.thrift.TException {
        if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
          throw new IllegalStateException("Method call not finished!");
        }
        org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
        org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
        (new Client(prot)).recv_setLectureOwner();
      }
    }

  }

  public static class Processor<I extends Iface> extends org.apache.thrift.TBaseProcessor<I> implements org.apache.thrift.TProcessor {
    private static final Logger LOGGER = LoggerFactory.getLogger(Processor.class.getName());
    public Processor(I iface) {
      super(iface, getProcessMap(new HashMap<String, org.apache.thrift.ProcessFunction<I, ? extends org.apache.thrift.TBase>>()));
    }

    protected Processor(I iface, Map<String,  org.apache.thrift.ProcessFunction<I, ? extends  org.apache.thrift.TBase>> processMap) {
      super(iface, getProcessMap(processMap));
    }

    private static <I extends Iface> Map<String,  org.apache.thrift.ProcessFunction<I, ? extends  org.apache.thrift.TBase>> getProcessMap(Map<String,  org.apache.thrift.ProcessFunction<I, ? extends  org.apache.thrift.TBase>> processMap) {
      processMap.put("getVersion", new getVersion());
      processMap.put("getConfiguration", new getConfiguration());
      processMap.put("requestImageVersionUpload", new requestImageVersionUpload());
      processMap.put("cancelUpload", new cancelUpload());
      processMap.put("queryUploadStatus", new queryUploadStatus());
      processMap.put("requestDownload", new requestDownload());
      processMap.put("cancelDownload", new cancelDownload());
      processMap.put("getMachineDescription", new getMachineDescription());
      processMap.put("isAuthenticated", new isAuthenticated());
      processMap.put("whoami", new whoami());
      processMap.put("invalidateSession", new invalidateSession());
      processMap.put("getUserList", new getUserList());
      processMap.put("getOperatingSystems", new getOperatingSystems());
      processMap.put("getVirtualizers", new getVirtualizers());
      processMap.put("getAllOrganizations", new getAllOrganizations());
      processMap.put("getImageList", new getImageList());
      processMap.put("getImageDetails", new getImageDetails());
      processMap.put("createImage", new createImage());
      processMap.put("updateImageBase", new updateImageBase());
      processMap.put("updateImageVersion", new updateImageVersion());
      processMap.put("deleteImageVersion", new deleteImageVersion());
      processMap.put("writeImagePermissions", new writeImagePermissions());
      processMap.put("getImagePermissions", new getImagePermissions());
      processMap.put("setImageOwner", new setImageOwner());
      processMap.put("createLecture", new createLecture());
      processMap.put("updateLecture", new updateLecture());
      processMap.put("getLectureList", new getLectureList());
      processMap.put("getLectureDetails", new getLectureDetails());
      processMap.put("deleteLecture", new deleteLecture());
      processMap.put("writeLecturePermissions", new writeLecturePermissions());
      processMap.put("getLecturePermissions", new getLecturePermissions());
      processMap.put("setLectureOwner", new setLectureOwner());
      return processMap;
    }

    public static class getVersion<I extends Iface> extends org.apache.thrift.ProcessFunction<I, getVersion_args> {
      public getVersion() {
        super("getVersion");
      }

      public getVersion_args getEmptyArgsInstance() {
        return new getVersion_args();
      }

      protected boolean isOneway() {
        return false;
      }

      public getVersion_result getResult(I iface, getVersion_args args) throws org.apache.thrift.TException {
        getVersion_result result = new getVersion_result();
        result.success = iface.getVersion();
        result.setSuccessIsSet(true);
        return result;
      }
    }

    public static class getConfiguration<I extends Iface> extends org.apache.thrift.ProcessFunction<I, getConfiguration_args> {
      public getConfiguration() {
        super("getConfiguration");
      }

      public getConfiguration_args getEmptyArgsInstance() {
        return new getConfiguration_args();
      }

      protected boolean isOneway() {
        return false;
      }

      public getConfiguration_result getResult(I iface, getConfiguration_args args) throws org.apache.thrift.TException {
        getConfiguration_result result = new getConfiguration_result();
        result.success = iface.getConfiguration();
        return result;
      }
    }

    public static class requestImageVersionUpload<I extends Iface> extends org.apache.thrift.ProcessFunction<I, requestImageVersionUpload_args> {
      public requestImageVersionUpload() {
        super("requestImageVersionUpload");
      }

      public requestImageVersionUpload_args getEmptyArgsInstance() {
        return new requestImageVersionUpload_args();
      }

      protected boolean isOneway() {
        return false;
      }

      public requestImageVersionUpload_result getResult(I iface, requestImageVersionUpload_args args) throws org.apache.thrift.TException {
        requestImageVersionUpload_result result = new requestImageVersionUpload_result();
        try {
          result.success = iface.requestImageVersionUpload(args.userToken, args.imageBaseId, args.fileSize, args.blockHashes, args.machineDescription);
        } catch (TTransferRejectedException rejection) {
          result.rejection = rejection;
        } catch (TAuthorizationException authError) {
          result.authError = authError;
        } catch (TInternalServerError ffff) {
          result.ffff = ffff;
        } catch (TNotFoundException sdf) {
          result.sdf = sdf;
        }
        return result;
      }
    }

    public static class cancelUpload<I extends Iface> extends org.apache.thrift.ProcessFunction<I, cancelUpload_args> {
      public cancelUpload() {
        super("cancelUpload");
      }

      public cancelUpload_args getEmptyArgsInstance() {
        return new cancelUpload_args();
      }

      protected boolean isOneway() {
        return false;
      }

      public cancelUpload_result getResult(I iface, cancelUpload_args args) throws org.apache.thrift.TException {
        cancelUpload_result result = new cancelUpload_result();
        try {
          iface.cancelUpload(args.uploadToken);
        } catch (TInvalidTokenException ex1) {
          result.ex1 = ex1;
        }
        return result;
      }
    }

    public static class queryUploadStatus<I extends Iface> extends org.apache.thrift.ProcessFunction<I, queryUploadStatus_args> {
      public queryUploadStatus() {
        super("queryUploadStatus");
      }

      public queryUploadStatus_args getEmptyArgsInstance() {
        return new queryUploadStatus_args();
      }

      protected boolean isOneway() {
        return false;
      }

      public queryUploadStatus_result getResult(I iface, queryUploadStatus_args args) throws org.apache.thrift.TException {
        queryUploadStatus_result result = new queryUploadStatus_result();
        try {
          result.success = iface.queryUploadStatus(args.uploadToken);
        } catch (TInvalidTokenException ex1) {
          result.ex1 = ex1;
        }
        return result;
      }
    }

    public static class requestDownload<I extends Iface> extends org.apache.thrift.ProcessFunction<I, requestDownload_args> {
      public requestDownload() {
        super("requestDownload");
      }

      public requestDownload_args getEmptyArgsInstance() {
        return new requestDownload_args();
      }

      protected boolean isOneway() {
        return false;
      }

      public requestDownload_result getResult(I iface, requestDownload_args args) throws org.apache.thrift.TException {
        requestDownload_result result = new requestDownload_result();
        try {
          result.success = iface.requestDownload(args.userToken, args.imageVersionId);
        } catch (TTransferRejectedException rejection) {
          result.rejection = rejection;
        } catch (TAuthorizationException authError) {
          result.authError = authError;
        } catch (TInternalServerError ffff) {
          result.ffff = ffff;
        } catch (TNotFoundException sdf) {
          result.sdf = sdf;
        }
        return result;
      }
    }

    public static class cancelDownload<I extends Iface> extends org.apache.thrift.ProcessFunction<I, cancelDownload_args> {
      public cancelDownload() {
        super("cancelDownload");
      }

      public cancelDownload_args getEmptyArgsInstance() {
        return new cancelDownload_args();
      }

      protected boolean isOneway() {
        return false;
      }

      public cancelDownload_result getResult(I iface, cancelDownload_args args) throws org.apache.thrift.TException {
        cancelDownload_result result = new cancelDownload_result();
        try {
          iface.cancelDownload(args.downloadToken);
        } catch (TInvalidTokenException ex1) {
          result.ex1 = ex1;
        }
        return result;
      }
    }

    public static class getMachineDescription<I extends Iface> extends org.apache.thrift.ProcessFunction<I, getMachineDescription_args> {
      public getMachineDescription() {
        super("getMachineDescription");
      }

      public getMachineDescription_args getEmptyArgsInstance() {
        return new getMachineDescription_args();
      }

      protected boolean isOneway() {
        return false;
      }

      public getMachineDescription_result getResult(I iface, getMachineDescription_args args) throws org.apache.thrift.TException {
        getMachineDescription_result result = new getMachineDescription_result();
        try {
          result.success = iface.getMachineDescription(args.userToken, args.imageVersionId);
        } catch (TAuthorizationException authError) {
          result.authError = authError;
        } catch (TInternalServerError ffff) {
          result.ffff = ffff;
        } catch (TNotFoundException sdf) {
          result.sdf = sdf;
        }
        return result;
      }
    }

    public static class isAuthenticated<I extends Iface> extends org.apache.thrift.ProcessFunction<I, isAuthenticated_args> {
      public isAuthenticated() {
        super("isAuthenticated");
      }

      public isAuthenticated_args getEmptyArgsInstance() {
        return new isAuthenticated_args();
      }

      protected boolean isOneway() {
        return false;
      }

      public isAuthenticated_result getResult(I iface, isAuthenticated_args args) throws org.apache.thrift.TException {
        isAuthenticated_result result = new isAuthenticated_result();
        try {
          iface.isAuthenticated(args.userToken);
        } catch (TAuthorizationException authError) {
          result.authError = authError;
        } catch (TInternalServerError serverError) {
          result.serverError = serverError;
        }
        return result;
      }
    }

    public static class whoami<I extends Iface> extends org.apache.thrift.ProcessFunction<I, whoami_args> {
      public whoami() {
        super("whoami");
      }

      public whoami_args getEmptyArgsInstance() {
        return new whoami_args();
      }

      protected boolean isOneway() {
        return false;
      }

      public whoami_result getResult(I iface, whoami_args args) throws org.apache.thrift.TException {
        whoami_result result = new whoami_result();
        try {
          result.success = iface.whoami(args.userToken);
        } catch (TAuthorizationException authError) {
          result.authError = authError;
        } catch (TInternalServerError serverError) {
          result.serverError = serverError;
        }
        return result;
      }
    }

    public static class invalidateSession<I extends Iface> extends org.apache.thrift.ProcessFunction<I, invalidateSession_args> {
      public invalidateSession() {
        super("invalidateSession");
      }

      public invalidateSession_args getEmptyArgsInstance() {
        return new invalidateSession_args();
      }

      protected boolean isOneway() {
        return false;
      }

      public invalidateSession_result getResult(I iface, invalidateSession_args args) throws org.apache.thrift.TException {
        invalidateSession_result result = new invalidateSession_result();
        iface.invalidateSession(args.userToken);
        return result;
      }
    }

    public static class getUserList<I extends Iface> extends org.apache.thrift.ProcessFunction<I, getUserList_args> {
      public getUserList() {
        super("getUserList");
      }

      public getUserList_args getEmptyArgsInstance() {
        return new getUserList_args();
      }

      protected boolean isOneway() {
        return false;
      }

      public getUserList_result getResult(I iface, getUserList_args args) throws org.apache.thrift.TException {
        getUserList_result result = new getUserList_result();
        try {
          result.success = iface.getUserList(args.userToken, args.page);
        } catch (TAuthorizationException failure) {
          result.failure = failure;
        } catch (TInternalServerError serverError) {
          result.serverError = serverError;
        }
        return result;
      }
    }

    public static class getOperatingSystems<I extends Iface> extends org.apache.thrift.ProcessFunction<I, getOperatingSystems_args> {
      public getOperatingSystems() {
        super("getOperatingSystems");
      }

      public getOperatingSystems_args getEmptyArgsInstance() {
        return new getOperatingSystems_args();
      }

      protected boolean isOneway() {
        return false;
      }

      public getOperatingSystems_result getResult(I iface, getOperatingSystems_args args) throws org.apache.thrift.TException {
        getOperatingSystems_result result = new getOperatingSystems_result();
        result.success = iface.getOperatingSystems();
        return result;
      }
    }

    public static class getVirtualizers<I extends Iface> extends org.apache.thrift.ProcessFunction<I, getVirtualizers_args> {
      public getVirtualizers() {
        super("getVirtualizers");
      }

      public getVirtualizers_args getEmptyArgsInstance() {
        return new getVirtualizers_args();
      }

      protected boolean isOneway() {
        return false;
      }

      public getVirtualizers_result getResult(I iface, getVirtualizers_args args) throws org.apache.thrift.TException {
        getVirtualizers_result result = new getVirtualizers_result();
        result.success = iface.getVirtualizers();
        return result;
      }
    }

    public static class getAllOrganizations<I extends Iface> extends org.apache.thrift.ProcessFunction<I, getAllOrganizations_args> {
      public getAllOrganizations() {
        super("getAllOrganizations");
      }

      public getAllOrganizations_args getEmptyArgsInstance() {
        return new getAllOrganizations_args();
      }

      protected boolean isOneway() {
        return false;
      }

      public getAllOrganizations_result getResult(I iface, getAllOrganizations_args args) throws org.apache.thrift.TException {
        getAllOrganizations_result result = new getAllOrganizations_result();
        result.success = iface.getAllOrganizations();
        return result;
      }
    }

    public static class getImageList<I extends Iface> extends org.apache.thrift.ProcessFunction<I, getImageList_args> {
      public getImageList() {
        super("getImageList");
      }

      public getImageList_args getEmptyArgsInstance() {
        return new getImageList_args();
      }

      protected boolean isOneway() {
        return false;
      }

      public getImageList_result getResult(I iface, getImageList_args args) throws org.apache.thrift.TException {
        getImageList_result result = new getImageList_result();
        try {
          result.success = iface.getImageList(args.userToken, args.tagSearch, args.page);
        } catch (TAuthorizationException authError) {
          result.authError = authError;
        } catch (TInternalServerError serverError) {
          result.serverError = serverError;
        }
        return result;
      }
    }

    public static class getImageDetails<I extends Iface> extends org.apache.thrift.ProcessFunction<I, getImageDetails_args> {
      public getImageDetails() {
        super("getImageDetails");
      }

      public getImageDetails_args getEmptyArgsInstance() {
        return new getImageDetails_args();
      }

      protected boolean isOneway() {
        return false;
      }

      public getImageDetails_result getResult(I iface, getImageDetails_args args) throws org.apache.thrift.TException {
        getImageDetails_result result = new getImageDetails_result();
        try {
          result.success = iface.getImageDetails(args.userToken, args.imageBaseId);
        } catch (TAuthorizationException authError) {
          result.authError = authError;
        } catch (TNotFoundException notFound) {
          result.notFound = notFound;
        } catch (TInternalServerError serverError) {
          result.serverError = serverError;
        }
        return result;
      }
    }

    public static class createImage<I extends Iface> extends org.apache.thrift.ProcessFunction<I, createImage_args> {
      public createImage() {
        super("createImage");
      }

      public createImage_args getEmptyArgsInstance() {
        return new createImage_args();
      }

      protected boolean isOneway() {
        return false;
      }

      public createImage_result getResult(I iface, createImage_args args) throws org.apache.thrift.TException {
        createImage_result result = new createImage_result();
        try {
          result.success = iface.createImage(args.userToken, args.imageName);
        } catch (TAuthorizationException authError) {
          result.authError = authError;
        } catch (TImageDataException imgError) {
          result.imgError = imgError;
        } catch (TInternalServerError serverError) {
          result.serverError = serverError;
        }
        return result;
      }
    }

    public static class updateImageBase<I extends Iface> extends org.apache.thrift.ProcessFunction<I, updateImageBase_args> {
      public updateImageBase() {
        super("updateImageBase");
      }

      public updateImageBase_args getEmptyArgsInstance() {
        return new updateImageBase_args();
      }

      protected boolean isOneway() {
        return false;
      }

      public updateImageBase_result getResult(I iface, updateImageBase_args args) throws org.apache.thrift.TException {
        updateImageBase_result result = new updateImageBase_result();
        try {
          iface.updateImageBase(args.userToken, args.imageBaseId, args.image);
        } catch (TAuthorizationException authError) {
          result.authError = authError;
        } catch (TNotFoundException notFound) {
          result.notFound = notFound;
        } catch (TImageDataException imgError) {
          result.imgError = imgError;
        } catch (TInternalServerError serverError) {
          result.serverError = serverError;
        }
        return result;
      }
    }

    public static class updateImageVersion<I extends Iface> extends org.apache.thrift.ProcessFunction<I, updateImageVersion_args> {
      public updateImageVersion() {
        super("updateImageVersion");
      }

      public updateImageVersion_args getEmptyArgsInstance() {
        return new updateImageVersion_args();
      }

      protected boolean isOneway() {
        return false;
      }

      public updateImageVersion_result getResult(I iface, updateImageVersion_args args) throws org.apache.thrift.TException {
        updateImageVersion_result result = new updateImageVersion_result();
        try {
          iface.updateImageVersion(args.userToken, args.imageVersionId, args.image);
        } catch (TAuthorizationException authError) {
          result.authError = authError;
        } catch (TNotFoundException notFound) {
          result.notFound = notFound;
        } catch (TImageDataException imgError) {
          result.imgError = imgError;
        } catch (TInternalServerError serverError) {
          result.serverError = serverError;
        }
        return result;
      }
    }

    public static class deleteImageVersion<I extends Iface> extends org.apache.thrift.ProcessFunction<I, deleteImageVersion_args> {
      public deleteImageVersion() {
        super("deleteImageVersion");
      }

      public deleteImageVersion_args getEmptyArgsInstance() {
        return new deleteImageVersion_args();
      }

      protected boolean isOneway() {
        return false;
      }

      public deleteImageVersion_result getResult(I iface, deleteImageVersion_args args) throws org.apache.thrift.TException {
        deleteImageVersion_result result = new deleteImageVersion_result();
        try {
          iface.deleteImageVersion(args.userToken, args.imageVersionId);
        } catch (TAuthorizationException authError) {
          result.authError = authError;
        } catch (TNotFoundException notFound) {
          result.notFound = notFound;
        } catch (TInternalServerError serverError) {
          result.serverError = serverError;
        }
        return result;
      }
    }

    public static class writeImagePermissions<I extends Iface> extends org.apache.thrift.ProcessFunction<I, writeImagePermissions_args> {
      public writeImagePermissions() {
        super("writeImagePermissions");
      }

      public writeImagePermissions_args getEmptyArgsInstance() {
        return new writeImagePermissions_args();
      }

      protected boolean isOneway() {
        return false;
      }

      public writeImagePermissions_result getResult(I iface, writeImagePermissions_args args) throws org.apache.thrift.TException {
        writeImagePermissions_result result = new writeImagePermissions_result();
        try {
          iface.writeImagePermissions(args.userToken, args.imageBaseId, args.permissions);
        } catch (TAuthorizationException authError) {
          result.authError = authError;
        } catch (TNotFoundException notFound) {
          result.notFound = notFound;
        } catch (TInternalServerError serverError) {
          result.serverError = serverError;
        }
        return result;
      }
    }

    public static class getImagePermissions<I extends Iface> extends org.apache.thrift.ProcessFunction<I, getImagePermissions_args> {
      public getImagePermissions() {
        super("getImagePermissions");
      }

      public getImagePermissions_args getEmptyArgsInstance() {
        return new getImagePermissions_args();
      }

      protected boolean isOneway() {
        return false;
      }

      public getImagePermissions_result getResult(I iface, getImagePermissions_args args) throws org.apache.thrift.TException {
        getImagePermissions_result result = new getImagePermissions_result();
        try {
          result.success = iface.getImagePermissions(args.userToken, args.imageBaseId);
        } catch (TAuthorizationException authError) {
          result.authError = authError;
        } catch (TNotFoundException notFound) {
          result.notFound = notFound;
        } catch (TInternalServerError serverError) {
          result.serverError = serverError;
        }
        return result;
      }
    }

    public static class setImageOwner<I extends Iface> extends org.apache.thrift.ProcessFunction<I, setImageOwner_args> {
      public setImageOwner() {
        super("setImageOwner");
      }

      public setImageOwner_args getEmptyArgsInstance() {
        return new setImageOwner_args();
      }

      protected boolean isOneway() {
        return false;
      }

      public setImageOwner_result getResult(I iface, setImageOwner_args args) throws org.apache.thrift.TException {
        setImageOwner_result result = new setImageOwner_result();
        try {
          iface.setImageOwner(args.userToken, args.imageBaseId, args.newOwnerId);
        } catch (TAuthorizationException authError) {
          result.authError = authError;
        } catch (TNotFoundException notFound) {
          result.notFound = notFound;
        } catch (TInternalServerError serverError) {
          result.serverError = serverError;
        }
        return result;
      }
    }

    public static class createLecture<I extends Iface> extends org.apache.thrift.ProcessFunction<I, createLecture_args> {
      public createLecture() {
        super("createLecture");
      }

      public createLecture_args getEmptyArgsInstance() {
        return new createLecture_args();
      }

      protected boolean isOneway() {
        return false;
      }

      public createLecture_result getResult(I iface, createLecture_args args) throws org.apache.thrift.TException {
        createLecture_result result = new createLecture_result();
        try {
          result.success = iface.createLecture(args.userToken, args.lecture);
        } catch (TAuthorizationException authError) {
          result.authError = authError;
        } catch (TInternalServerError serverError) {
          result.serverError = serverError;
        }
        return result;
      }
    }

    public static class updateLecture<I extends Iface> extends org.apache.thrift.ProcessFunction<I, updateLecture_args> {
      public updateLecture() {
        super("updateLecture");
      }

      public updateLecture_args getEmptyArgsInstance() {
        return new updateLecture_args();
      }

      protected boolean isOneway() {
        return false;
      }

      public updateLecture_result getResult(I iface, updateLecture_args args) throws org.apache.thrift.TException {
        updateLecture_result result = new updateLecture_result();
        try {
          iface.updateLecture(args.userToken, args.lectureId, args.lecture);
        } catch (TAuthorizationException authError) {
          result.authError = authError;
        } catch (TNotFoundException notFound) {
          result.notFound = notFound;
        } catch (TInternalServerError serverError) {
          result.serverError = serverError;
        }
        return result;
      }
    }

    public static class getLectureList<I extends Iface> extends org.apache.thrift.ProcessFunction<I, getLectureList_args> {
      public getLectureList() {
        super("getLectureList");
      }

      public getLectureList_args getEmptyArgsInstance() {
        return new getLectureList_args();
      }

      protected boolean isOneway() {
        return false;
      }

      public getLectureList_result getResult(I iface, getLectureList_args args) throws org.apache.thrift.TException {
        getLectureList_result result = new getLectureList_result();
        try {
          result.success = iface.getLectureList(args.userToken, args.page);
        } catch (TAuthorizationException authError) {
          result.authError = authError;
        } catch (TInternalServerError serverError) {
          result.serverError = serverError;
        }
        return result;
      }
    }

    public static class getLectureDetails<I extends Iface> extends org.apache.thrift.ProcessFunction<I, getLectureDetails_args> {
      public getLectureDetails() {
        super("getLectureDetails");
      }

      public getLectureDetails_args getEmptyArgsInstance() {
        return new getLectureDetails_args();
      }

      protected boolean isOneway() {
        return false;
      }

      public getLectureDetails_result getResult(I iface, getLectureDetails_args args) throws org.apache.thrift.TException {
        getLectureDetails_result result = new getLectureDetails_result();
        try {
          result.success = iface.getLectureDetails(args.userToken, args.lectureId);
        } catch (TAuthorizationException authError) {
          result.authError = authError;
        } catch (TNotFoundException notFound) {
          result.notFound = notFound;
        } catch (TInternalServerError serverError) {
          result.serverError = serverError;
        }
        return result;
      }
    }

    public static class deleteLecture<I extends Iface> extends org.apache.thrift.ProcessFunction<I, deleteLecture_args> {
      public deleteLecture() {
        super("deleteLecture");
      }

      public deleteLecture_args getEmptyArgsInstance() {
        return new deleteLecture_args();
      }

      protected boolean isOneway() {
        return false;
      }

      public deleteLecture_result getResult(I iface, deleteLecture_args args) throws org.apache.thrift.TException {
        deleteLecture_result result = new deleteLecture_result();
        try {
          iface.deleteLecture(args.userToken, args.lectureId);
        } catch (TAuthorizationException authError) {
          result.authError = authError;
        } catch (TNotFoundException notFound) {
          result.notFound = notFound;
        } catch (TInternalServerError serverError) {
          result.serverError = serverError;
        }
        return result;
      }
    }

    public static class writeLecturePermissions<I extends Iface> extends org.apache.thrift.ProcessFunction<I, writeLecturePermissions_args> {
      public writeLecturePermissions() {
        super("writeLecturePermissions");
      }

      public writeLecturePermissions_args getEmptyArgsInstance() {
        return new writeLecturePermissions_args();
      }

      protected boolean isOneway() {
        return false;
      }

      public writeLecturePermissions_result getResult(I iface, writeLecturePermissions_args args) throws org.apache.thrift.TException {
        writeLecturePermissions_result result = new writeLecturePermissions_result();
        try {
          iface.writeLecturePermissions(args.userToken, args.lectureId, args.permissions);
        } catch (TAuthorizationException authError) {
          result.authError = authError;
        } catch (TNotFoundException notFound) {
          result.notFound = notFound;
        } catch (TInternalServerError serverError) {
          result.serverError = serverError;
        }
        return result;
      }
    }

    public static class getLecturePermissions<I extends Iface> extends org.apache.thrift.ProcessFunction<I, getLecturePermissions_args> {
      public getLecturePermissions() {
        super("getLecturePermissions");
      }

      public getLecturePermissions_args getEmptyArgsInstance() {
        return new getLecturePermissions_args();
      }

      protected boolean isOneway() {
        return false;
      }

      public getLecturePermissions_result getResult(I iface, getLecturePermissions_args args) throws org.apache.thrift.TException {
        getLecturePermissions_result result = new getLecturePermissions_result();
        try {
          result.success = iface.getLecturePermissions(args.userToken, args.lectureId);
        } catch (TAuthorizationException authError) {
          result.authError = authError;
        } catch (TNotFoundException notFound) {
          result.notFound = notFound;
        } catch (TInternalServerError serverError) {
          result.serverError = serverError;
        }
        return result;
      }
    }

    public static class setLectureOwner<I extends Iface> extends org.apache.thrift.ProcessFunction<I, setLectureOwner_args> {
      public setLectureOwner() {
        super("setLectureOwner");
      }

      public setLectureOwner_args getEmptyArgsInstance() {
        return new setLectureOwner_args();
      }

      protected boolean isOneway() {
        return false;
      }

      public setLectureOwner_result getResult(I iface, setLectureOwner_args args) throws org.apache.thrift.TException {
        setLectureOwner_result result = new setLectureOwner_result();
        try {
          iface.setLectureOwner(args.userToken, args.lectureId, args.newOwnerId);
        } catch (TAuthorizationException authError) {
          result.authError = authError;
        } catch (TNotFoundException notFound) {
          result.notFound = notFound;
        } catch (TInternalServerError serverError) {
          result.serverError = serverError;
        }
        return result;
      }
    }

  }

  public static class AsyncProcessor<I extends AsyncIface> extends org.apache.thrift.TBaseAsyncProcessor<I> {
    private static final Logger LOGGER = LoggerFactory.getLogger(AsyncProcessor.class.getName());
    public AsyncProcessor(I iface) {
      super(iface, getProcessMap(new HashMap<String, org.apache.thrift.AsyncProcessFunction<I, ? extends org.apache.thrift.TBase, ?>>()));
    }

    protected AsyncProcessor(I iface, Map<String,  org.apache.thrift.AsyncProcessFunction<I, ? extends  org.apache.thrift.TBase, ?>> processMap) {
      super(iface, getProcessMap(processMap));
    }

    private static <I extends AsyncIface> Map<String,  org.apache.thrift.AsyncProcessFunction<I, ? extends  org.apache.thrift.TBase,?>> getProcessMap(Map<String,  org.apache.thrift.AsyncProcessFunction<I, ? extends  org.apache.thrift.TBase, ?>> processMap) {
      processMap.put("getVersion", new getVersion());
      processMap.put("getConfiguration", new getConfiguration());
      processMap.put("requestImageVersionUpload", new requestImageVersionUpload());
      processMap.put("cancelUpload", new cancelUpload());
      processMap.put("queryUploadStatus", new queryUploadStatus());
      processMap.put("requestDownload", new requestDownload());
      processMap.put("cancelDownload", new cancelDownload());
      processMap.put("getMachineDescription", new getMachineDescription());
      processMap.put("isAuthenticated", new isAuthenticated());
      processMap.put("whoami", new whoami());
      processMap.put("invalidateSession", new invalidateSession());
      processMap.put("getUserList", new getUserList());
      processMap.put("getOperatingSystems", new getOperatingSystems());
      processMap.put("getVirtualizers", new getVirtualizers());
      processMap.put("getAllOrganizations", new getAllOrganizations());
      processMap.put("getImageList", new getImageList());
      processMap.put("getImageDetails", new getImageDetails());
      processMap.put("createImage", new createImage());
      processMap.put("updateImageBase", new updateImageBase());
      processMap.put("updateImageVersion", new updateImageVersion());
      processMap.put("deleteImageVersion", new deleteImageVersion());
      processMap.put("writeImagePermissions", new writeImagePermissions());
      processMap.put("getImagePermissions", new getImagePermissions());
      processMap.put("setImageOwner", new setImageOwner());
      processMap.put("createLecture", new createLecture());
      processMap.put("updateLecture", new updateLecture());
      processMap.put("getLectureList", new getLectureList());
      processMap.put("getLectureDetails", new getLectureDetails());
      processMap.put("deleteLecture", new deleteLecture());
      processMap.put("writeLecturePermissions", new writeLecturePermissions());
      processMap.put("getLecturePermissions", new getLecturePermissions());
      processMap.put("setLectureOwner", new setLectureOwner());
      return processMap;
    }

    public static class getVersion<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, getVersion_args, Long> {
      public getVersion() {
        super("getVersion");
      }

      public getVersion_args getEmptyArgsInstance() {
        return new getVersion_args();
      }

      public AsyncMethodCallback<Long> getResultHandler(final AsyncFrameBuffer fb, final int seqid) {
        final org.apache.thrift.AsyncProcessFunction fcall = this;
        return new AsyncMethodCallback<Long>() { 
          public void onComplete(Long o) {
            getVersion_result result = new getVersion_result();
            result.success = o;
            result.setSuccessIsSet(true);
            try {
              fcall.sendResponse(fb,result, org.apache.thrift.protocol.TMessageType.REPLY,seqid);
              return;
            } catch (Exception e) {
              LOGGER.error("Exception writing to internal frame buffer", e);
            }
            fb.close();
          }
          public void onError(Exception e) {
            byte msgType = org.apache.thrift.protocol.TMessageType.REPLY;
            org.apache.thrift.TBase msg;
            getVersion_result result = new getVersion_result();
            {
              msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
              msg = (org.apache.thrift.TBase)new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage());
            }
            try {
              fcall.sendResponse(fb,msg,msgType,seqid);
              return;
            } catch (Exception ex) {
              LOGGER.error("Exception writing to internal frame buffer", ex);
            }
            fb.close();
          }
        };
      }

      protected boolean isOneway() {
        return false;
      }

      public void start(I iface, getVersion_args args, org.apache.thrift.async.AsyncMethodCallback<Long> resultHandler) throws TException {
        iface.getVersion(resultHandler);
      }
    }

    public static class getConfiguration<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, getConfiguration_args, SatelliteConfig> {
      public getConfiguration() {
        super("getConfiguration");
      }

      public getConfiguration_args getEmptyArgsInstance() {
        return new getConfiguration_args();
      }

      public AsyncMethodCallback<SatelliteConfig> getResultHandler(final AsyncFrameBuffer fb, final int seqid) {
        final org.apache.thrift.AsyncProcessFunction fcall = this;
        return new AsyncMethodCallback<SatelliteConfig>() { 
          public void onComplete(SatelliteConfig o) {
            getConfiguration_result result = new getConfiguration_result();
            result.success = o;
            try {
              fcall.sendResponse(fb,result, org.apache.thrift.protocol.TMessageType.REPLY,seqid);
              return;
            } catch (Exception e) {
              LOGGER.error("Exception writing to internal frame buffer", e);
            }
            fb.close();
          }
          public void onError(Exception e) {
            byte msgType = org.apache.thrift.protocol.TMessageType.REPLY;
            org.apache.thrift.TBase msg;
            getConfiguration_result result = new getConfiguration_result();
            {
              msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
              msg = (org.apache.thrift.TBase)new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage());
            }
            try {
              fcall.sendResponse(fb,msg,msgType,seqid);
              return;
            } catch (Exception ex) {
              LOGGER.error("Exception writing to internal frame buffer", ex);
            }
            fb.close();
          }
        };
      }

      protected boolean isOneway() {
        return false;
      }

      public void start(I iface, getConfiguration_args args, org.apache.thrift.async.AsyncMethodCallback<SatelliteConfig> resultHandler) throws TException {
        iface.getConfiguration(resultHandler);
      }
    }

    public static class requestImageVersionUpload<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, requestImageVersionUpload_args, TransferInformation> {
      public requestImageVersionUpload() {
        super("requestImageVersionUpload");
      }

      public requestImageVersionUpload_args getEmptyArgsInstance() {
        return new requestImageVersionUpload_args();
      }

      public AsyncMethodCallback<TransferInformation> getResultHandler(final AsyncFrameBuffer fb, final int seqid) {
        final org.apache.thrift.AsyncProcessFunction fcall = this;
        return new AsyncMethodCallback<TransferInformation>() { 
          public void onComplete(TransferInformation o) {
            requestImageVersionUpload_result result = new requestImageVersionUpload_result();
            result.success = o;
            try {
              fcall.sendResponse(fb,result, org.apache.thrift.protocol.TMessageType.REPLY,seqid);
              return;
            } catch (Exception e) {
              LOGGER.error("Exception writing to internal frame buffer", e);
            }
            fb.close();
          }
          public void onError(Exception e) {
            byte msgType = org.apache.thrift.protocol.TMessageType.REPLY;
            org.apache.thrift.TBase msg;
            requestImageVersionUpload_result result = new requestImageVersionUpload_result();
            if (e instanceof TTransferRejectedException) {
                        result.rejection = (TTransferRejectedException) e;
                        result.setRejectionIsSet(true);
                        msg = result;
            }
            else             if (e instanceof TAuthorizationException) {
                        result.authError = (TAuthorizationException) e;
                        result.setAuthErrorIsSet(true);
                        msg = result;
            }
            else             if (e instanceof TInternalServerError) {
                        result.ffff = (TInternalServerError) e;
                        result.setFfffIsSet(true);
                        msg = result;
            }
            else             if (e instanceof TNotFoundException) {
                        result.sdf = (TNotFoundException) e;
                        result.setSdfIsSet(true);
                        msg = result;
            }
             else 
            {
              msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
              msg = (org.apache.thrift.TBase)new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage());
            }
            try {
              fcall.sendResponse(fb,msg,msgType,seqid);
              return;
            } catch (Exception ex) {
              LOGGER.error("Exception writing to internal frame buffer", ex);
            }
            fb.close();
          }
        };
      }

      protected boolean isOneway() {
        return false;
      }

      public void start(I iface, requestImageVersionUpload_args args, org.apache.thrift.async.AsyncMethodCallback<TransferInformation> resultHandler) throws TException {
        iface.requestImageVersionUpload(args.userToken, args.imageBaseId, args.fileSize, args.blockHashes, args.machineDescription,resultHandler);
      }
    }

    public static class cancelUpload<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, cancelUpload_args, Void> {
      public cancelUpload() {
        super("cancelUpload");
      }

      public cancelUpload_args getEmptyArgsInstance() {
        return new cancelUpload_args();
      }

      public AsyncMethodCallback<Void> getResultHandler(final AsyncFrameBuffer fb, final int seqid) {
        final org.apache.thrift.AsyncProcessFunction fcall = this;
        return new AsyncMethodCallback<Void>() { 
          public void onComplete(Void o) {
            cancelUpload_result result = new cancelUpload_result();
            try {
              fcall.sendResponse(fb,result, org.apache.thrift.protocol.TMessageType.REPLY,seqid);
              return;
            } catch (Exception e) {
              LOGGER.error("Exception writing to internal frame buffer", e);
            }
            fb.close();
          }
          public void onError(Exception e) {
            byte msgType = org.apache.thrift.protocol.TMessageType.REPLY;
            org.apache.thrift.TBase msg;
            cancelUpload_result result = new cancelUpload_result();
            if (e instanceof TInvalidTokenException) {
                        result.ex1 = (TInvalidTokenException) e;
                        result.setEx1IsSet(true);
                        msg = result;
            }
             else 
            {
              msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
              msg = (org.apache.thrift.TBase)new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage());
            }
            try {
              fcall.sendResponse(fb,msg,msgType,seqid);
              return;
            } catch (Exception ex) {
              LOGGER.error("Exception writing to internal frame buffer", ex);
            }
            fb.close();
          }
        };
      }

      protected boolean isOneway() {
        return false;
      }

      public void start(I iface, cancelUpload_args args, org.apache.thrift.async.AsyncMethodCallback<Void> resultHandler) throws TException {
        iface.cancelUpload(args.uploadToken,resultHandler);
      }
    }

    public static class queryUploadStatus<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, queryUploadStatus_args, TransferStatus> {
      public queryUploadStatus() {
        super("queryUploadStatus");
      }

      public queryUploadStatus_args getEmptyArgsInstance() {
        return new queryUploadStatus_args();
      }

      public AsyncMethodCallback<TransferStatus> getResultHandler(final AsyncFrameBuffer fb, final int seqid) {
        final org.apache.thrift.AsyncProcessFunction fcall = this;
        return new AsyncMethodCallback<TransferStatus>() { 
          public void onComplete(TransferStatus o) {
            queryUploadStatus_result result = new queryUploadStatus_result();
            result.success = o;
            try {
              fcall.sendResponse(fb,result, org.apache.thrift.protocol.TMessageType.REPLY,seqid);
              return;
            } catch (Exception e) {
              LOGGER.error("Exception writing to internal frame buffer", e);
            }
            fb.close();
          }
          public void onError(Exception e) {
            byte msgType = org.apache.thrift.protocol.TMessageType.REPLY;
            org.apache.thrift.TBase msg;
            queryUploadStatus_result result = new queryUploadStatus_result();
            if (e instanceof TInvalidTokenException) {
                        result.ex1 = (TInvalidTokenException) e;
                        result.setEx1IsSet(true);
                        msg = result;
            }
             else 
            {
              msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
              msg = (org.apache.thrift.TBase)new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage());
            }
            try {
              fcall.sendResponse(fb,msg,msgType,seqid);
              return;
            } catch (Exception ex) {
              LOGGER.error("Exception writing to internal frame buffer", ex);
            }
            fb.close();
          }
        };
      }

      protected boolean isOneway() {
        return false;
      }

      public void start(I iface, queryUploadStatus_args args, org.apache.thrift.async.AsyncMethodCallback<TransferStatus> resultHandler) throws TException {
        iface.queryUploadStatus(args.uploadToken,resultHandler);
      }
    }

    public static class requestDownload<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, requestDownload_args, TransferInformation> {
      public requestDownload() {
        super("requestDownload");
      }

      public requestDownload_args getEmptyArgsInstance() {
        return new requestDownload_args();
      }

      public AsyncMethodCallback<TransferInformation> getResultHandler(final AsyncFrameBuffer fb, final int seqid) {
        final org.apache.thrift.AsyncProcessFunction fcall = this;
        return new AsyncMethodCallback<TransferInformation>() { 
          public void onComplete(TransferInformation o) {
            requestDownload_result result = new requestDownload_result();
            result.success = o;
            try {
              fcall.sendResponse(fb,result, org.apache.thrift.protocol.TMessageType.REPLY,seqid);
              return;
            } catch (Exception e) {
              LOGGER.error("Exception writing to internal frame buffer", e);
            }
            fb.close();
          }
          public void onError(Exception e) {
            byte msgType = org.apache.thrift.protocol.TMessageType.REPLY;
            org.apache.thrift.TBase msg;
            requestDownload_result result = new requestDownload_result();
            if (e instanceof TTransferRejectedException) {
                        result.rejection = (TTransferRejectedException) e;
                        result.setRejectionIsSet(true);
                        msg = result;
            }
            else             if (e instanceof TAuthorizationException) {
                        result.authError = (TAuthorizationException) e;
                        result.setAuthErrorIsSet(true);
                        msg = result;
            }
            else             if (e instanceof TInternalServerError) {
                        result.ffff = (TInternalServerError) e;
                        result.setFfffIsSet(true);
                        msg = result;
            }
            else             if (e instanceof TNotFoundException) {
                        result.sdf = (TNotFoundException) e;
                        result.setSdfIsSet(true);
                        msg = result;
            }
             else 
            {
              msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
              msg = (org.apache.thrift.TBase)new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage());
            }
            try {
              fcall.sendResponse(fb,msg,msgType,seqid);
              return;
            } catch (Exception ex) {
              LOGGER.error("Exception writing to internal frame buffer", ex);
            }
            fb.close();
          }
        };
      }

      protected boolean isOneway() {
        return false;
      }

      public void start(I iface, requestDownload_args args, org.apache.thrift.async.AsyncMethodCallback<TransferInformation> resultHandler) throws TException {
        iface.requestDownload(args.userToken, args.imageVersionId,resultHandler);
      }
    }

    public static class cancelDownload<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, cancelDownload_args, Void> {
      public cancelDownload() {
        super("cancelDownload");
      }

      public cancelDownload_args getEmptyArgsInstance() {
        return new cancelDownload_args();
      }

      public AsyncMethodCallback<Void> getResultHandler(final AsyncFrameBuffer fb, final int seqid) {
        final org.apache.thrift.AsyncProcessFunction fcall = this;
        return new AsyncMethodCallback<Void>() { 
          public void onComplete(Void o) {
            cancelDownload_result result = new cancelDownload_result();
            try {
              fcall.sendResponse(fb,result, org.apache.thrift.protocol.TMessageType.REPLY,seqid);
              return;
            } catch (Exception e) {
              LOGGER.error("Exception writing to internal frame buffer", e);
            }
            fb.close();
          }
          public void onError(Exception e) {
            byte msgType = org.apache.thrift.protocol.TMessageType.REPLY;
            org.apache.thrift.TBase msg;
            cancelDownload_result result = new cancelDownload_result();
            if (e instanceof TInvalidTokenException) {
                        result.ex1 = (TInvalidTokenException) e;
                        result.setEx1IsSet(true);
                        msg = result;
            }
             else 
            {
              msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
              msg = (org.apache.thrift.TBase)new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage());
            }
            try {
              fcall.sendResponse(fb,msg,msgType,seqid);
              return;
            } catch (Exception ex) {
              LOGGER.error("Exception writing to internal frame buffer", ex);
            }
            fb.close();
          }
        };
      }

      protected boolean isOneway() {
        return false;
      }

      public void start(I iface, cancelDownload_args args, org.apache.thrift.async.AsyncMethodCallback<Void> resultHandler) throws TException {
        iface.cancelDownload(args.downloadToken,resultHandler);
      }
    }

    public static class getMachineDescription<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, getMachineDescription_args, ByteBuffer> {
      public getMachineDescription() {
        super("getMachineDescription");
      }

      public getMachineDescription_args getEmptyArgsInstance() {
        return new getMachineDescription_args();
      }

      public AsyncMethodCallback<ByteBuffer> getResultHandler(final AsyncFrameBuffer fb, final int seqid) {
        final org.apache.thrift.AsyncProcessFunction fcall = this;
        return new AsyncMethodCallback<ByteBuffer>() { 
          public void onComplete(ByteBuffer o) {
            getMachineDescription_result result = new getMachineDescription_result();
            result.success = o;
            try {
              fcall.sendResponse(fb,result, org.apache.thrift.protocol.TMessageType.REPLY,seqid);
              return;
            } catch (Exception e) {
              LOGGER.error("Exception writing to internal frame buffer", e);
            }
            fb.close();
          }
          public void onError(Exception e) {
            byte msgType = org.apache.thrift.protocol.TMessageType.REPLY;
            org.apache.thrift.TBase msg;
            getMachineDescription_result result = new getMachineDescription_result();
            if (e instanceof TAuthorizationException) {
                        result.authError = (TAuthorizationException) e;
                        result.setAuthErrorIsSet(true);
                        msg = result;
            }
            else             if (e instanceof TInternalServerError) {
                        result.ffff = (TInternalServerError) e;
                        result.setFfffIsSet(true);
                        msg = result;
            }
            else             if (e instanceof TNotFoundException) {
                        result.sdf = (TNotFoundException) e;
                        result.setSdfIsSet(true);
                        msg = result;
            }
             else 
            {
              msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
              msg = (org.apache.thrift.TBase)new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage());
            }
            try {
              fcall.sendResponse(fb,msg,msgType,seqid);
              return;
            } catch (Exception ex) {
              LOGGER.error("Exception writing to internal frame buffer", ex);
            }
            fb.close();
          }
        };
      }

      protected boolean isOneway() {
        return false;
      }

      public void start(I iface, getMachineDescription_args args, org.apache.thrift.async.AsyncMethodCallback<ByteBuffer> resultHandler) throws TException {
        iface.getMachineDescription(args.userToken, args.imageVersionId,resultHandler);
      }
    }

    public static class isAuthenticated<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, isAuthenticated_args, Void> {
      public isAuthenticated() {
        super("isAuthenticated");
      }

      public isAuthenticated_args getEmptyArgsInstance() {
        return new isAuthenticated_args();
      }

      public AsyncMethodCallback<Void> getResultHandler(final AsyncFrameBuffer fb, final int seqid) {
        final org.apache.thrift.AsyncProcessFunction fcall = this;
        return new AsyncMethodCallback<Void>() { 
          public void onComplete(Void o) {
            isAuthenticated_result result = new isAuthenticated_result();
            try {
              fcall.sendResponse(fb,result, org.apache.thrift.protocol.TMessageType.REPLY,seqid);
              return;
            } catch (Exception e) {
              LOGGER.error("Exception writing to internal frame buffer", e);
            }
            fb.close();
          }
          public void onError(Exception e) {
            byte msgType = org.apache.thrift.protocol.TMessageType.REPLY;
            org.apache.thrift.TBase msg;
            isAuthenticated_result result = new isAuthenticated_result();
            if (e instanceof TAuthorizationException) {
                        result.authError = (TAuthorizationException) e;
                        result.setAuthErrorIsSet(true);
                        msg = result;
            }
            else             if (e instanceof TInternalServerError) {
                        result.serverError = (TInternalServerError) e;
                        result.setServerErrorIsSet(true);
                        msg = result;
            }
             else 
            {
              msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
              msg = (org.apache.thrift.TBase)new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage());
            }
            try {
              fcall.sendResponse(fb,msg,msgType,seqid);
              return;
            } catch (Exception ex) {
              LOGGER.error("Exception writing to internal frame buffer", ex);
            }
            fb.close();
          }
        };
      }

      protected boolean isOneway() {
        return false;
      }

      public void start(I iface, isAuthenticated_args args, org.apache.thrift.async.AsyncMethodCallback<Void> resultHandler) throws TException {
        iface.isAuthenticated(args.userToken,resultHandler);
      }
    }

    public static class whoami<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, whoami_args, UserInfo> {
      public whoami() {
        super("whoami");
      }

      public whoami_args getEmptyArgsInstance() {
        return new whoami_args();
      }

      public AsyncMethodCallback<UserInfo> getResultHandler(final AsyncFrameBuffer fb, final int seqid) {
        final org.apache.thrift.AsyncProcessFunction fcall = this;
        return new AsyncMethodCallback<UserInfo>() { 
          public void onComplete(UserInfo o) {
            whoami_result result = new whoami_result();
            result.success = o;
            try {
              fcall.sendResponse(fb,result, org.apache.thrift.protocol.TMessageType.REPLY,seqid);
              return;
            } catch (Exception e) {
              LOGGER.error("Exception writing to internal frame buffer", e);
            }
            fb.close();
          }
          public void onError(Exception e) {
            byte msgType = org.apache.thrift.protocol.TMessageType.REPLY;
            org.apache.thrift.TBase msg;
            whoami_result result = new whoami_result();
            if (e instanceof TAuthorizationException) {
                        result.authError = (TAuthorizationException) e;
                        result.setAuthErrorIsSet(true);
                        msg = result;
            }
            else             if (e instanceof TInternalServerError) {
                        result.serverError = (TInternalServerError) e;
                        result.setServerErrorIsSet(true);
                        msg = result;
            }
             else 
            {
              msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
              msg = (org.apache.thrift.TBase)new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage());
            }
            try {
              fcall.sendResponse(fb,msg,msgType,seqid);
              return;
            } catch (Exception ex) {
              LOGGER.error("Exception writing to internal frame buffer", ex);
            }
            fb.close();
          }
        };
      }

      protected boolean isOneway() {
        return false;
      }

      public void start(I iface, whoami_args args, org.apache.thrift.async.AsyncMethodCallback<UserInfo> resultHandler) throws TException {
        iface.whoami(args.userToken,resultHandler);
      }
    }

    public static class invalidateSession<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, invalidateSession_args, Void> {
      public invalidateSession() {
        super("invalidateSession");
      }

      public invalidateSession_args getEmptyArgsInstance() {
        return new invalidateSession_args();
      }

      public AsyncMethodCallback<Void> getResultHandler(final AsyncFrameBuffer fb, final int seqid) {
        final org.apache.thrift.AsyncProcessFunction fcall = this;
        return new AsyncMethodCallback<Void>() { 
          public void onComplete(Void o) {
            invalidateSession_result result = new invalidateSession_result();
            try {
              fcall.sendResponse(fb,result, org.apache.thrift.protocol.TMessageType.REPLY,seqid);
              return;
            } catch (Exception e) {
              LOGGER.error("Exception writing to internal frame buffer", e);
            }
            fb.close();
          }
          public void onError(Exception e) {
            byte msgType = org.apache.thrift.protocol.TMessageType.REPLY;
            org.apache.thrift.TBase msg;
            invalidateSession_result result = new invalidateSession_result();
            {
              msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
              msg = (org.apache.thrift.TBase)new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage());
            }
            try {
              fcall.sendResponse(fb,msg,msgType,seqid);
              return;
            } catch (Exception ex) {
              LOGGER.error("Exception writing to internal frame buffer", ex);
            }
            fb.close();
          }
        };
      }

      protected boolean isOneway() {
        return false;
      }

      public void start(I iface, invalidateSession_args args, org.apache.thrift.async.AsyncMethodCallback<Void> resultHandler) throws TException {
        iface.invalidateSession(args.userToken,resultHandler);
      }
    }

    public static class getUserList<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, getUserList_args, List<UserInfo>> {
      public getUserList() {
        super("getUserList");
      }

      public getUserList_args getEmptyArgsInstance() {
        return new getUserList_args();
      }

      public AsyncMethodCallback<List<UserInfo>> getResultHandler(final AsyncFrameBuffer fb, final int seqid) {
        final org.apache.thrift.AsyncProcessFunction fcall = this;
        return new AsyncMethodCallback<List<UserInfo>>() { 
          public void onComplete(List<UserInfo> o) {
            getUserList_result result = new getUserList_result();
            result.success = o;
            try {
              fcall.sendResponse(fb,result, org.apache.thrift.protocol.TMessageType.REPLY,seqid);
              return;
            } catch (Exception e) {
              LOGGER.error("Exception writing to internal frame buffer", e);
            }
            fb.close();
          }
          public void onError(Exception e) {
            byte msgType = org.apache.thrift.protocol.TMessageType.REPLY;
            org.apache.thrift.TBase msg;
            getUserList_result result = new getUserList_result();
            if (e instanceof TAuthorizationException) {
                        result.failure = (TAuthorizationException) e;
                        result.setFailureIsSet(true);
                        msg = result;
            }
            else             if (e instanceof TInternalServerError) {
                        result.serverError = (TInternalServerError) e;
                        result.setServerErrorIsSet(true);
                        msg = result;
            }
             else 
            {
              msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
              msg = (org.apache.thrift.TBase)new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage());
            }
            try {
              fcall.sendResponse(fb,msg,msgType,seqid);
              return;
            } catch (Exception ex) {
              LOGGER.error("Exception writing to internal frame buffer", ex);
            }
            fb.close();
          }
        };
      }

      protected boolean isOneway() {
        return false;
      }

      public void start(I iface, getUserList_args args, org.apache.thrift.async.AsyncMethodCallback<List<UserInfo>> resultHandler) throws TException {
        iface.getUserList(args.userToken, args.page,resultHandler);
      }
    }

    public static class getOperatingSystems<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, getOperatingSystems_args, List<OperatingSystem>> {
      public getOperatingSystems() {
        super("getOperatingSystems");
      }

      public getOperatingSystems_args getEmptyArgsInstance() {
        return new getOperatingSystems_args();
      }

      public AsyncMethodCallback<List<OperatingSystem>> getResultHandler(final AsyncFrameBuffer fb, final int seqid) {
        final org.apache.thrift.AsyncProcessFunction fcall = this;
        return new AsyncMethodCallback<List<OperatingSystem>>() { 
          public void onComplete(List<OperatingSystem> o) {
            getOperatingSystems_result result = new getOperatingSystems_result();
            result.success = o;
            try {
              fcall.sendResponse(fb,result, org.apache.thrift.protocol.TMessageType.REPLY,seqid);
              return;
            } catch (Exception e) {
              LOGGER.error("Exception writing to internal frame buffer", e);
            }
            fb.close();
          }
          public void onError(Exception e) {
            byte msgType = org.apache.thrift.protocol.TMessageType.REPLY;
            org.apache.thrift.TBase msg;
            getOperatingSystems_result result = new getOperatingSystems_result();
            {
              msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
              msg = (org.apache.thrift.TBase)new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage());
            }
            try {
              fcall.sendResponse(fb,msg,msgType,seqid);
              return;
            } catch (Exception ex) {
              LOGGER.error("Exception writing to internal frame buffer", ex);
            }
            fb.close();
          }
        };
      }

      protected boolean isOneway() {
        return false;
      }

      public void start(I iface, getOperatingSystems_args args, org.apache.thrift.async.AsyncMethodCallback<List<OperatingSystem>> resultHandler) throws TException {
        iface.getOperatingSystems(resultHandler);
      }
    }

    public static class getVirtualizers<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, getVirtualizers_args, List<Virtualizer>> {
      public getVirtualizers() {
        super("getVirtualizers");
      }

      public getVirtualizers_args getEmptyArgsInstance() {
        return new getVirtualizers_args();
      }

      public AsyncMethodCallback<List<Virtualizer>> getResultHandler(final AsyncFrameBuffer fb, final int seqid) {
        final org.apache.thrift.AsyncProcessFunction fcall = this;
        return new AsyncMethodCallback<List<Virtualizer>>() { 
          public void onComplete(List<Virtualizer> o) {
            getVirtualizers_result result = new getVirtualizers_result();
            result.success = o;
            try {
              fcall.sendResponse(fb,result, org.apache.thrift.protocol.TMessageType.REPLY,seqid);
              return;
            } catch (Exception e) {
              LOGGER.error("Exception writing to internal frame buffer", e);
            }
            fb.close();
          }
          public void onError(Exception e) {
            byte msgType = org.apache.thrift.protocol.TMessageType.REPLY;
            org.apache.thrift.TBase msg;
            getVirtualizers_result result = new getVirtualizers_result();
            {
              msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
              msg = (org.apache.thrift.TBase)new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage());
            }
            try {
              fcall.sendResponse(fb,msg,msgType,seqid);
              return;
            } catch (Exception ex) {
              LOGGER.error("Exception writing to internal frame buffer", ex);
            }
            fb.close();
          }
        };
      }

      protected boolean isOneway() {
        return false;
      }

      public void start(I iface, getVirtualizers_args args, org.apache.thrift.async.AsyncMethodCallback<List<Virtualizer>> resultHandler) throws TException {
        iface.getVirtualizers(resultHandler);
      }
    }

    public static class getAllOrganizations<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, getAllOrganizations_args, List<Organization>> {
      public getAllOrganizations() {
        super("getAllOrganizations");
      }

      public getAllOrganizations_args getEmptyArgsInstance() {
        return new getAllOrganizations_args();
      }

      public AsyncMethodCallback<List<Organization>> getResultHandler(final AsyncFrameBuffer fb, final int seqid) {
        final org.apache.thrift.AsyncProcessFunction fcall = this;
        return new AsyncMethodCallback<List<Organization>>() { 
          public void onComplete(List<Organization> o) {
            getAllOrganizations_result result = new getAllOrganizations_result();
            result.success = o;
            try {
              fcall.sendResponse(fb,result, org.apache.thrift.protocol.TMessageType.REPLY,seqid);
              return;
            } catch (Exception e) {
              LOGGER.error("Exception writing to internal frame buffer", e);
            }
            fb.close();
          }
          public void onError(Exception e) {
            byte msgType = org.apache.thrift.protocol.TMessageType.REPLY;
            org.apache.thrift.TBase msg;
            getAllOrganizations_result result = new getAllOrganizations_result();
            {
              msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
              msg = (org.apache.thrift.TBase)new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage());
            }
            try {
              fcall.sendResponse(fb,msg,msgType,seqid);
              return;
            } catch (Exception ex) {
              LOGGER.error("Exception writing to internal frame buffer", ex);
            }
            fb.close();
          }
        };
      }

      protected boolean isOneway() {
        return false;
      }

      public void start(I iface, getAllOrganizations_args args, org.apache.thrift.async.AsyncMethodCallback<List<Organization>> resultHandler) throws TException {
        iface.getAllOrganizations(resultHandler);
      }
    }

    public static class getImageList<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, getImageList_args, List<ImageSummaryRead>> {
      public getImageList() {
        super("getImageList");
      }

      public getImageList_args getEmptyArgsInstance() {
        return new getImageList_args();
      }

      public AsyncMethodCallback<List<ImageSummaryRead>> getResultHandler(final AsyncFrameBuffer fb, final int seqid) {
        final org.apache.thrift.AsyncProcessFunction fcall = this;
        return new AsyncMethodCallback<List<ImageSummaryRead>>() { 
          public void onComplete(List<ImageSummaryRead> o) {
            getImageList_result result = new getImageList_result();
            result.success = o;
            try {
              fcall.sendResponse(fb,result, org.apache.thrift.protocol.TMessageType.REPLY,seqid);
              return;
            } catch (Exception e) {
              LOGGER.error("Exception writing to internal frame buffer", e);
            }
            fb.close();
          }
          public void onError(Exception e) {
            byte msgType = org.apache.thrift.protocol.TMessageType.REPLY;
            org.apache.thrift.TBase msg;
            getImageList_result result = new getImageList_result();
            if (e instanceof TAuthorizationException) {
                        result.authError = (TAuthorizationException) e;
                        result.setAuthErrorIsSet(true);
                        msg = result;
            }
            else             if (e instanceof TInternalServerError) {
                        result.serverError = (TInternalServerError) e;
                        result.setServerErrorIsSet(true);
                        msg = result;
            }
             else 
            {
              msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
              msg = (org.apache.thrift.TBase)new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage());
            }
            try {
              fcall.sendResponse(fb,msg,msgType,seqid);
              return;
            } catch (Exception ex) {
              LOGGER.error("Exception writing to internal frame buffer", ex);
            }
            fb.close();
          }
        };
      }

      protected boolean isOneway() {
        return false;
      }

      public void start(I iface, getImageList_args args, org.apache.thrift.async.AsyncMethodCallback<List<ImageSummaryRead>> resultHandler) throws TException {
        iface.getImageList(args.userToken, args.tagSearch, args.page,resultHandler);
      }
    }

    public static class getImageDetails<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, getImageDetails_args, ImageDetailsRead> {
      public getImageDetails() {
        super("getImageDetails");
      }

      public getImageDetails_args getEmptyArgsInstance() {
        return new getImageDetails_args();
      }

      public AsyncMethodCallback<ImageDetailsRead> getResultHandler(final AsyncFrameBuffer fb, final int seqid) {
        final org.apache.thrift.AsyncProcessFunction fcall = this;
        return new AsyncMethodCallback<ImageDetailsRead>() { 
          public void onComplete(ImageDetailsRead o) {
            getImageDetails_result result = new getImageDetails_result();
            result.success = o;
            try {
              fcall.sendResponse(fb,result, org.apache.thrift.protocol.TMessageType.REPLY,seqid);
              return;
            } catch (Exception e) {
              LOGGER.error("Exception writing to internal frame buffer", e);
            }
            fb.close();
          }
          public void onError(Exception e) {
            byte msgType = org.apache.thrift.protocol.TMessageType.REPLY;
            org.apache.thrift.TBase msg;
            getImageDetails_result result = new getImageDetails_result();
            if (e instanceof TAuthorizationException) {
                        result.authError = (TAuthorizationException) e;
                        result.setAuthErrorIsSet(true);
                        msg = result;
            }
            else             if (e instanceof TNotFoundException) {
                        result.notFound = (TNotFoundException) e;
                        result.setNotFoundIsSet(true);
                        msg = result;
            }
            else             if (e instanceof TInternalServerError) {
                        result.serverError = (TInternalServerError) e;
                        result.setServerErrorIsSet(true);
                        msg = result;
            }
             else 
            {
              msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
              msg = (org.apache.thrift.TBase)new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage());
            }
            try {
              fcall.sendResponse(fb,msg,msgType,seqid);
              return;
            } catch (Exception ex) {
              LOGGER.error("Exception writing to internal frame buffer", ex);
            }
            fb.close();
          }
        };
      }

      protected boolean isOneway() {
        return false;
      }

      public void start(I iface, getImageDetails_args args, org.apache.thrift.async.AsyncMethodCallback<ImageDetailsRead> resultHandler) throws TException {
        iface.getImageDetails(args.userToken, args.imageBaseId,resultHandler);
      }
    }

    public static class createImage<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, createImage_args, String> {
      public createImage() {
        super("createImage");
      }

      public createImage_args getEmptyArgsInstance() {
        return new createImage_args();
      }

      public AsyncMethodCallback<String> getResultHandler(final AsyncFrameBuffer fb, final int seqid) {
        final org.apache.thrift.AsyncProcessFunction fcall = this;
        return new AsyncMethodCallback<String>() { 
          public void onComplete(String o) {
            createImage_result result = new createImage_result();
            result.success = o;
            try {
              fcall.sendResponse(fb,result, org.apache.thrift.protocol.TMessageType.REPLY,seqid);
              return;
            } catch (Exception e) {
              LOGGER.error("Exception writing to internal frame buffer", e);
            }
            fb.close();
          }
          public void onError(Exception e) {
            byte msgType = org.apache.thrift.protocol.TMessageType.REPLY;
            org.apache.thrift.TBase msg;
            createImage_result result = new createImage_result();
            if (e instanceof TAuthorizationException) {
                        result.authError = (TAuthorizationException) e;
                        result.setAuthErrorIsSet(true);
                        msg = result;
            }
            else             if (e instanceof TImageDataException) {
                        result.imgError = (TImageDataException) e;
                        result.setImgErrorIsSet(true);
                        msg = result;
            }
            else             if (e instanceof TInternalServerError) {
                        result.serverError = (TInternalServerError) e;
                        result.setServerErrorIsSet(true);
                        msg = result;
            }
             else 
            {
              msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
              msg = (org.apache.thrift.TBase)new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage());
            }
            try {
              fcall.sendResponse(fb,msg,msgType,seqid);
              return;
            } catch (Exception ex) {
              LOGGER.error("Exception writing to internal frame buffer", ex);
            }
            fb.close();
          }
        };
      }

      protected boolean isOneway() {
        return false;
      }

      public void start(I iface, createImage_args args, org.apache.thrift.async.AsyncMethodCallback<String> resultHandler) throws TException {
        iface.createImage(args.userToken, args.imageName,resultHandler);
      }
    }

    public static class updateImageBase<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, updateImageBase_args, Void> {
      public updateImageBase() {
        super("updateImageBase");
      }

      public updateImageBase_args getEmptyArgsInstance() {
        return new updateImageBase_args();
      }

      public AsyncMethodCallback<Void> getResultHandler(final AsyncFrameBuffer fb, final int seqid) {
        final org.apache.thrift.AsyncProcessFunction fcall = this;
        return new AsyncMethodCallback<Void>() { 
          public void onComplete(Void o) {
            updateImageBase_result result = new updateImageBase_result();
            try {
              fcall.sendResponse(fb,result, org.apache.thrift.protocol.TMessageType.REPLY,seqid);
              return;
            } catch (Exception e) {
              LOGGER.error("Exception writing to internal frame buffer", e);
            }
            fb.close();
          }
          public void onError(Exception e) {
            byte msgType = org.apache.thrift.protocol.TMessageType.REPLY;
            org.apache.thrift.TBase msg;
            updateImageBase_result result = new updateImageBase_result();
            if (e instanceof TAuthorizationException) {
                        result.authError = (TAuthorizationException) e;
                        result.setAuthErrorIsSet(true);
                        msg = result;
            }
            else             if (e instanceof TNotFoundException) {
                        result.notFound = (TNotFoundException) e;
                        result.setNotFoundIsSet(true);
                        msg = result;
            }
            else             if (e instanceof TImageDataException) {
                        result.imgError = (TImageDataException) e;
                        result.setImgErrorIsSet(true);
                        msg = result;
            }
            else             if (e instanceof TInternalServerError) {
                        result.serverError = (TInternalServerError) e;
                        result.setServerErrorIsSet(true);
                        msg = result;
            }
             else 
            {
              msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
              msg = (org.apache.thrift.TBase)new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage());
            }
            try {
              fcall.sendResponse(fb,msg,msgType,seqid);
              return;
            } catch (Exception ex) {
              LOGGER.error("Exception writing to internal frame buffer", ex);
            }
            fb.close();
          }
        };
      }

      protected boolean isOneway() {
        return false;
      }

      public void start(I iface, updateImageBase_args args, org.apache.thrift.async.AsyncMethodCallback<Void> resultHandler) throws TException {
        iface.updateImageBase(args.userToken, args.imageBaseId, args.image,resultHandler);
      }
    }

    public static class updateImageVersion<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, updateImageVersion_args, Void> {
      public updateImageVersion() {
        super("updateImageVersion");
      }

      public updateImageVersion_args getEmptyArgsInstance() {
        return new updateImageVersion_args();
      }

      public AsyncMethodCallback<Void> getResultHandler(final AsyncFrameBuffer fb, final int seqid) {
        final org.apache.thrift.AsyncProcessFunction fcall = this;
        return new AsyncMethodCallback<Void>() { 
          public void onComplete(Void o) {
            updateImageVersion_result result = new updateImageVersion_result();
            try {
              fcall.sendResponse(fb,result, org.apache.thrift.protocol.TMessageType.REPLY,seqid);
              return;
            } catch (Exception e) {
              LOGGER.error("Exception writing to internal frame buffer", e);
            }
            fb.close();
          }
          public void onError(Exception e) {
            byte msgType = org.apache.thrift.protocol.TMessageType.REPLY;
            org.apache.thrift.TBase msg;
            updateImageVersion_result result = new updateImageVersion_result();
            if (e instanceof TAuthorizationException) {
                        result.authError = (TAuthorizationException) e;
                        result.setAuthErrorIsSet(true);
                        msg = result;
            }
            else             if (e instanceof TNotFoundException) {
                        result.notFound = (TNotFoundException) e;
                        result.setNotFoundIsSet(true);
                        msg = result;
            }
            else             if (e instanceof TImageDataException) {
                        result.imgError = (TImageDataException) e;
                        result.setImgErrorIsSet(true);
                        msg = result;
            }
            else             if (e instanceof TInternalServerError) {
                        result.serverError = (TInternalServerError) e;
                        result.setServerErrorIsSet(true);
                        msg = result;
            }
             else 
            {
              msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
              msg = (org.apache.thrift.TBase)new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage());
            }
            try {
              fcall.sendResponse(fb,msg,msgType,seqid);
              return;
            } catch (Exception ex) {
              LOGGER.error("Exception writing to internal frame buffer", ex);
            }
            fb.close();
          }
        };
      }

      protected boolean isOneway() {
        return false;
      }

      public void start(I iface, updateImageVersion_args args, org.apache.thrift.async.AsyncMethodCallback<Void> resultHandler) throws TException {
        iface.updateImageVersion(args.userToken, args.imageVersionId, args.image,resultHandler);
      }
    }

    public static class deleteImageVersion<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, deleteImageVersion_args, Void> {
      public deleteImageVersion() {
        super("deleteImageVersion");
      }

      public deleteImageVersion_args getEmptyArgsInstance() {
        return new deleteImageVersion_args();
      }

      public AsyncMethodCallback<Void> getResultHandler(final AsyncFrameBuffer fb, final int seqid) {
        final org.apache.thrift.AsyncProcessFunction fcall = this;
        return new AsyncMethodCallback<Void>() { 
          public void onComplete(Void o) {
            deleteImageVersion_result result = new deleteImageVersion_result();
            try {
              fcall.sendResponse(fb,result, org.apache.thrift.protocol.TMessageType.REPLY,seqid);
              return;
            } catch (Exception e) {
              LOGGER.error("Exception writing to internal frame buffer", e);
            }
            fb.close();
          }
          public void onError(Exception e) {
            byte msgType = org.apache.thrift.protocol.TMessageType.REPLY;
            org.apache.thrift.TBase msg;
            deleteImageVersion_result result = new deleteImageVersion_result();
            if (e instanceof TAuthorizationException) {
                        result.authError = (TAuthorizationException) e;
                        result.setAuthErrorIsSet(true);
                        msg = result;
            }
            else             if (e instanceof TNotFoundException) {
                        result.notFound = (TNotFoundException) e;
                        result.setNotFoundIsSet(true);
                        msg = result;
            }
            else             if (e instanceof TInternalServerError) {
                        result.serverError = (TInternalServerError) e;
                        result.setServerErrorIsSet(true);
                        msg = result;
            }
             else 
            {
              msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
              msg = (org.apache.thrift.TBase)new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage());
            }
            try {
              fcall.sendResponse(fb,msg,msgType,seqid);
              return;
            } catch (Exception ex) {
              LOGGER.error("Exception writing to internal frame buffer", ex);
            }
            fb.close();
          }
        };
      }

      protected boolean isOneway() {
        return false;
      }

      public void start(I iface, deleteImageVersion_args args, org.apache.thrift.async.AsyncMethodCallback<Void> resultHandler) throws TException {
        iface.deleteImageVersion(args.userToken, args.imageVersionId,resultHandler);
      }
    }

    public static class writeImagePermissions<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, writeImagePermissions_args, Void> {
      public writeImagePermissions() {
        super("writeImagePermissions");
      }

      public writeImagePermissions_args getEmptyArgsInstance() {
        return new writeImagePermissions_args();
      }

      public AsyncMethodCallback<Void> getResultHandler(final AsyncFrameBuffer fb, final int seqid) {
        final org.apache.thrift.AsyncProcessFunction fcall = this;
        return new AsyncMethodCallback<Void>() { 
          public void onComplete(Void o) {
            writeImagePermissions_result result = new writeImagePermissions_result();
            try {
              fcall.sendResponse(fb,result, org.apache.thrift.protocol.TMessageType.REPLY,seqid);
              return;
            } catch (Exception e) {
              LOGGER.error("Exception writing to internal frame buffer", e);
            }
            fb.close();
          }
          public void onError(Exception e) {
            byte msgType = org.apache.thrift.protocol.TMessageType.REPLY;
            org.apache.thrift.TBase msg;
            writeImagePermissions_result result = new writeImagePermissions_result();
            if (e instanceof TAuthorizationException) {
                        result.authError = (TAuthorizationException) e;
                        result.setAuthErrorIsSet(true);
                        msg = result;
            }
            else             if (e instanceof TNotFoundException) {
                        result.notFound = (TNotFoundException) e;
                        result.setNotFoundIsSet(true);
                        msg = result;
            }
            else             if (e instanceof TInternalServerError) {
                        result.serverError = (TInternalServerError) e;
                        result.setServerErrorIsSet(true);
                        msg = result;
            }
             else 
            {
              msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
              msg = (org.apache.thrift.TBase)new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage());
            }
            try {
              fcall.sendResponse(fb,msg,msgType,seqid);
              return;
            } catch (Exception ex) {
              LOGGER.error("Exception writing to internal frame buffer", ex);
            }
            fb.close();
          }
        };
      }

      protected boolean isOneway() {
        return false;
      }

      public void start(I iface, writeImagePermissions_args args, org.apache.thrift.async.AsyncMethodCallback<Void> resultHandler) throws TException {
        iface.writeImagePermissions(args.userToken, args.imageBaseId, args.permissions,resultHandler);
      }
    }

    public static class getImagePermissions<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, getImagePermissions_args, Map<String,ImagePermissions>> {
      public getImagePermissions() {
        super("getImagePermissions");
      }

      public getImagePermissions_args getEmptyArgsInstance() {
        return new getImagePermissions_args();
      }

      public AsyncMethodCallback<Map<String,ImagePermissions>> getResultHandler(final AsyncFrameBuffer fb, final int seqid) {
        final org.apache.thrift.AsyncProcessFunction fcall = this;
        return new AsyncMethodCallback<Map<String,ImagePermissions>>() { 
          public void onComplete(Map<String,ImagePermissions> o) {
            getImagePermissions_result result = new getImagePermissions_result();
            result.success = o;
            try {
              fcall.sendResponse(fb,result, org.apache.thrift.protocol.TMessageType.REPLY,seqid);
              return;
            } catch (Exception e) {
              LOGGER.error("Exception writing to internal frame buffer", e);
            }
            fb.close();
          }
          public void onError(Exception e) {
            byte msgType = org.apache.thrift.protocol.TMessageType.REPLY;
            org.apache.thrift.TBase msg;
            getImagePermissions_result result = new getImagePermissions_result();
            if (e instanceof TAuthorizationException) {
                        result.authError = (TAuthorizationException) e;
                        result.setAuthErrorIsSet(true);
                        msg = result;
            }
            else             if (e instanceof TNotFoundException) {
                        result.notFound = (TNotFoundException) e;
                        result.setNotFoundIsSet(true);
                        msg = result;
            }
            else             if (e instanceof TInternalServerError) {
                        result.serverError = (TInternalServerError) e;
                        result.setServerErrorIsSet(true);
                        msg = result;
            }
             else 
            {
              msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
              msg = (org.apache.thrift.TBase)new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage());
            }
            try {
              fcall.sendResponse(fb,msg,msgType,seqid);
              return;
            } catch (Exception ex) {
              LOGGER.error("Exception writing to internal frame buffer", ex);
            }
            fb.close();
          }
        };
      }

      protected boolean isOneway() {
        return false;
      }

      public void start(I iface, getImagePermissions_args args, org.apache.thrift.async.AsyncMethodCallback<Map<String,ImagePermissions>> resultHandler) throws TException {
        iface.getImagePermissions(args.userToken, args.imageBaseId,resultHandler);
      }
    }

    public static class setImageOwner<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, setImageOwner_args, Void> {
      public setImageOwner() {
        super("setImageOwner");
      }

      public setImageOwner_args getEmptyArgsInstance() {
        return new setImageOwner_args();
      }

      public AsyncMethodCallback<Void> getResultHandler(final AsyncFrameBuffer fb, final int seqid) {
        final org.apache.thrift.AsyncProcessFunction fcall = this;
        return new AsyncMethodCallback<Void>() { 
          public void onComplete(Void o) {
            setImageOwner_result result = new setImageOwner_result();
            try {
              fcall.sendResponse(fb,result, org.apache.thrift.protocol.TMessageType.REPLY,seqid);
              return;
            } catch (Exception e) {
              LOGGER.error("Exception writing to internal frame buffer", e);
            }
            fb.close();
          }
          public void onError(Exception e) {
            byte msgType = org.apache.thrift.protocol.TMessageType.REPLY;
            org.apache.thrift.TBase msg;
            setImageOwner_result result = new setImageOwner_result();
            if (e instanceof TAuthorizationException) {
                        result.authError = (TAuthorizationException) e;
                        result.setAuthErrorIsSet(true);
                        msg = result;
            }
            else             if (e instanceof TNotFoundException) {
                        result.notFound = (TNotFoundException) e;
                        result.setNotFoundIsSet(true);
                        msg = result;
            }
            else             if (e instanceof TInternalServerError) {
                        result.serverError = (TInternalServerError) e;
                        result.setServerErrorIsSet(true);
                        msg = result;
            }
             else 
            {
              msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
              msg = (org.apache.thrift.TBase)new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage());
            }
            try {
              fcall.sendResponse(fb,msg,msgType,seqid);
              return;
            } catch (Exception ex) {
              LOGGER.error("Exception writing to internal frame buffer", ex);
            }
            fb.close();
          }
        };
      }

      protected boolean isOneway() {
        return false;
      }

      public void start(I iface, setImageOwner_args args, org.apache.thrift.async.AsyncMethodCallback<Void> resultHandler) throws TException {
        iface.setImageOwner(args.userToken, args.imageBaseId, args.newOwnerId,resultHandler);
      }
    }

    public static class createLecture<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, createLecture_args, String> {
      public createLecture() {
        super("createLecture");
      }

      public createLecture_args getEmptyArgsInstance() {
        return new createLecture_args();
      }

      public AsyncMethodCallback<String> getResultHandler(final AsyncFrameBuffer fb, final int seqid) {
        final org.apache.thrift.AsyncProcessFunction fcall = this;
        return new AsyncMethodCallback<String>() { 
          public void onComplete(String o) {
            createLecture_result result = new createLecture_result();
            result.success = o;
            try {
              fcall.sendResponse(fb,result, org.apache.thrift.protocol.TMessageType.REPLY,seqid);
              return;
            } catch (Exception e) {
              LOGGER.error("Exception writing to internal frame buffer", e);
            }
            fb.close();
          }
          public void onError(Exception e) {
            byte msgType = org.apache.thrift.protocol.TMessageType.REPLY;
            org.apache.thrift.TBase msg;
            createLecture_result result = new createLecture_result();
            if (e instanceof TAuthorizationException) {
                        result.authError = (TAuthorizationException) e;
                        result.setAuthErrorIsSet(true);
                        msg = result;
            }
            else             if (e instanceof TInternalServerError) {
                        result.serverError = (TInternalServerError) e;
                        result.setServerErrorIsSet(true);
                        msg = result;
            }
             else 
            {
              msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
              msg = (org.apache.thrift.TBase)new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage());
            }
            try {
              fcall.sendResponse(fb,msg,msgType,seqid);
              return;
            } catch (Exception ex) {
              LOGGER.error("Exception writing to internal frame buffer", ex);
            }
            fb.close();
          }
        };
      }

      protected boolean isOneway() {
        return false;
      }

      public void start(I iface, createLecture_args args, org.apache.thrift.async.AsyncMethodCallback<String> resultHandler) throws TException {
        iface.createLecture(args.userToken, args.lecture,resultHandler);
      }
    }

    public static class updateLecture<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, updateLecture_args, Void> {
      public updateLecture() {
        super("updateLecture");
      }

      public updateLecture_args getEmptyArgsInstance() {
        return new updateLecture_args();
      }

      public AsyncMethodCallback<Void> getResultHandler(final AsyncFrameBuffer fb, final int seqid) {
        final org.apache.thrift.AsyncProcessFunction fcall = this;
        return new AsyncMethodCallback<Void>() { 
          public void onComplete(Void o) {
            updateLecture_result result = new updateLecture_result();
            try {
              fcall.sendResponse(fb,result, org.apache.thrift.protocol.TMessageType.REPLY,seqid);
              return;
            } catch (Exception e) {
              LOGGER.error("Exception writing to internal frame buffer", e);
            }
            fb.close();
          }
          public void onError(Exception e) {
            byte msgType = org.apache.thrift.protocol.TMessageType.REPLY;
            org.apache.thrift.TBase msg;
            updateLecture_result result = new updateLecture_result();
            if (e instanceof TAuthorizationException) {
                        result.authError = (TAuthorizationException) e;
                        result.setAuthErrorIsSet(true);
                        msg = result;
            }
            else             if (e instanceof TNotFoundException) {
                        result.notFound = (TNotFoundException) e;
                        result.setNotFoundIsSet(true);
                        msg = result;
            }
            else             if (e instanceof TInternalServerError) {
                        result.serverError = (TInternalServerError) e;
                        result.setServerErrorIsSet(true);
                        msg = result;
            }
             else 
            {
              msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
              msg = (org.apache.thrift.TBase)new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage());
            }
            try {
              fcall.sendResponse(fb,msg,msgType,seqid);
              return;
            } catch (Exception ex) {
              LOGGER.error("Exception writing to internal frame buffer", ex);
            }
            fb.close();
          }
        };
      }

      protected boolean isOneway() {
        return false;
      }

      public void start(I iface, updateLecture_args args, org.apache.thrift.async.AsyncMethodCallback<Void> resultHandler) throws TException {
        iface.updateLecture(args.userToken, args.lectureId, args.lecture,resultHandler);
      }
    }

    public static class getLectureList<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, getLectureList_args, List<LectureSummary>> {
      public getLectureList() {
        super("getLectureList");
      }

      public getLectureList_args getEmptyArgsInstance() {
        return new getLectureList_args();
      }

      public AsyncMethodCallback<List<LectureSummary>> getResultHandler(final AsyncFrameBuffer fb, final int seqid) {
        final org.apache.thrift.AsyncProcessFunction fcall = this;
        return new AsyncMethodCallback<List<LectureSummary>>() { 
          public void onComplete(List<LectureSummary> o) {
            getLectureList_result result = new getLectureList_result();
            result.success = o;
            try {
              fcall.sendResponse(fb,result, org.apache.thrift.protocol.TMessageType.REPLY,seqid);
              return;
            } catch (Exception e) {
              LOGGER.error("Exception writing to internal frame buffer", e);
            }
            fb.close();
          }
          public void onError(Exception e) {
            byte msgType = org.apache.thrift.protocol.TMessageType.REPLY;
            org.apache.thrift.TBase msg;
            getLectureList_result result = new getLectureList_result();
            if (e instanceof TAuthorizationException) {
                        result.authError = (TAuthorizationException) e;
                        result.setAuthErrorIsSet(true);
                        msg = result;
            }
            else             if (e instanceof TInternalServerError) {
                        result.serverError = (TInternalServerError) e;
                        result.setServerErrorIsSet(true);
                        msg = result;
            }
             else 
            {
              msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
              msg = (org.apache.thrift.TBase)new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage());
            }
            try {
              fcall.sendResponse(fb,msg,msgType,seqid);
              return;
            } catch (Exception ex) {
              LOGGER.error("Exception writing to internal frame buffer", ex);
            }
            fb.close();
          }
        };
      }

      protected boolean isOneway() {
        return false;
      }

      public void start(I iface, getLectureList_args args, org.apache.thrift.async.AsyncMethodCallback<List<LectureSummary>> resultHandler) throws TException {
        iface.getLectureList(args.userToken, args.page,resultHandler);
      }
    }

    public static class getLectureDetails<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, getLectureDetails_args, LectureRead> {
      public getLectureDetails() {
        super("getLectureDetails");
      }

      public getLectureDetails_args getEmptyArgsInstance() {
        return new getLectureDetails_args();
      }

      public AsyncMethodCallback<LectureRead> getResultHandler(final AsyncFrameBuffer fb, final int seqid) {
        final org.apache.thrift.AsyncProcessFunction fcall = this;
        return new AsyncMethodCallback<LectureRead>() { 
          public void onComplete(LectureRead o) {
            getLectureDetails_result result = new getLectureDetails_result();
            result.success = o;
            try {
              fcall.sendResponse(fb,result, org.apache.thrift.protocol.TMessageType.REPLY,seqid);
              return;
            } catch (Exception e) {
              LOGGER.error("Exception writing to internal frame buffer", e);
            }
            fb.close();
          }
          public void onError(Exception e) {
            byte msgType = org.apache.thrift.protocol.TMessageType.REPLY;
            org.apache.thrift.TBase msg;
            getLectureDetails_result result = new getLectureDetails_result();
            if (e instanceof TAuthorizationException) {
                        result.authError = (TAuthorizationException) e;
                        result.setAuthErrorIsSet(true);
                        msg = result;
            }
            else             if (e instanceof TNotFoundException) {
                        result.notFound = (TNotFoundException) e;
                        result.setNotFoundIsSet(true);
                        msg = result;
            }
            else             if (e instanceof TInternalServerError) {
                        result.serverError = (TInternalServerError) e;
                        result.setServerErrorIsSet(true);
                        msg = result;
            }
             else 
            {
              msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
              msg = (org.apache.thrift.TBase)new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage());
            }
            try {
              fcall.sendResponse(fb,msg,msgType,seqid);
              return;
            } catch (Exception ex) {
              LOGGER.error("Exception writing to internal frame buffer", ex);
            }
            fb.close();
          }
        };
      }

      protected boolean isOneway() {
        return false;
      }

      public void start(I iface, getLectureDetails_args args, org.apache.thrift.async.AsyncMethodCallback<LectureRead> resultHandler) throws TException {
        iface.getLectureDetails(args.userToken, args.lectureId,resultHandler);
      }
    }

    public static class deleteLecture<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, deleteLecture_args, Void> {
      public deleteLecture() {
        super("deleteLecture");
      }

      public deleteLecture_args getEmptyArgsInstance() {
        return new deleteLecture_args();
      }

      public AsyncMethodCallback<Void> getResultHandler(final AsyncFrameBuffer fb, final int seqid) {
        final org.apache.thrift.AsyncProcessFunction fcall = this;
        return new AsyncMethodCallback<Void>() { 
          public void onComplete(Void o) {
            deleteLecture_result result = new deleteLecture_result();
            try {
              fcall.sendResponse(fb,result, org.apache.thrift.protocol.TMessageType.REPLY,seqid);
              return;
            } catch (Exception e) {
              LOGGER.error("Exception writing to internal frame buffer", e);
            }
            fb.close();
          }
          public void onError(Exception e) {
            byte msgType = org.apache.thrift.protocol.TMessageType.REPLY;
            org.apache.thrift.TBase msg;
            deleteLecture_result result = new deleteLecture_result();
            if (e instanceof TAuthorizationException) {
                        result.authError = (TAuthorizationException) e;
                        result.setAuthErrorIsSet(true);
                        msg = result;
            }
            else             if (e instanceof TNotFoundException) {
                        result.notFound = (TNotFoundException) e;
                        result.setNotFoundIsSet(true);
                        msg = result;
            }
            else             if (e instanceof TInternalServerError) {
                        result.serverError = (TInternalServerError) e;
                        result.setServerErrorIsSet(true);
                        msg = result;
            }
             else 
            {
              msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
              msg = (org.apache.thrift.TBase)new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage());
            }
            try {
              fcall.sendResponse(fb,msg,msgType,seqid);
              return;
            } catch (Exception ex) {
              LOGGER.error("Exception writing to internal frame buffer", ex);
            }
            fb.close();
          }
        };
      }

      protected boolean isOneway() {
        return false;
      }

      public void start(I iface, deleteLecture_args args, org.apache.thrift.async.AsyncMethodCallback<Void> resultHandler) throws TException {
        iface.deleteLecture(args.userToken, args.lectureId,resultHandler);
      }
    }

    public static class writeLecturePermissions<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, writeLecturePermissions_args, Void> {
      public writeLecturePermissions() {
        super("writeLecturePermissions");
      }

      public writeLecturePermissions_args getEmptyArgsInstance() {
        return new writeLecturePermissions_args();
      }

      public AsyncMethodCallback<Void> getResultHandler(final AsyncFrameBuffer fb, final int seqid) {
        final org.apache.thrift.AsyncProcessFunction fcall = this;
        return new AsyncMethodCallback<Void>() { 
          public void onComplete(Void o) {
            writeLecturePermissions_result result = new writeLecturePermissions_result();
            try {
              fcall.sendResponse(fb,result, org.apache.thrift.protocol.TMessageType.REPLY,seqid);
              return;
            } catch (Exception e) {
              LOGGER.error("Exception writing to internal frame buffer", e);
            }
            fb.close();
          }
          public void onError(Exception e) {
            byte msgType = org.apache.thrift.protocol.TMessageType.REPLY;
            org.apache.thrift.TBase msg;
            writeLecturePermissions_result result = new writeLecturePermissions_result();
            if (e instanceof TAuthorizationException) {
                        result.authError = (TAuthorizationException) e;
                        result.setAuthErrorIsSet(true);
                        msg = result;
            }
            else             if (e instanceof TNotFoundException) {
                        result.notFound = (TNotFoundException) e;
                        result.setNotFoundIsSet(true);
                        msg = result;
            }
            else             if (e instanceof TInternalServerError) {
                        result.serverError = (TInternalServerError) e;
                        result.setServerErrorIsSet(true);
                        msg = result;
            }
             else 
            {
              msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
              msg = (org.apache.thrift.TBase)new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage());
            }
            try {
              fcall.sendResponse(fb,msg,msgType,seqid);
              return;
            } catch (Exception ex) {
              LOGGER.error("Exception writing to internal frame buffer", ex);
            }
            fb.close();
          }
        };
      }

      protected boolean isOneway() {
        return false;
      }

      public void start(I iface, writeLecturePermissions_args args, org.apache.thrift.async.AsyncMethodCallback<Void> resultHandler) throws TException {
        iface.writeLecturePermissions(args.userToken, args.lectureId, args.permissions,resultHandler);
      }
    }

    public static class getLecturePermissions<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, getLecturePermissions_args, Map<String,LecturePermissions>> {
      public getLecturePermissions() {
        super("getLecturePermissions");
      }

      public getLecturePermissions_args getEmptyArgsInstance() {
        return new getLecturePermissions_args();
      }

      public AsyncMethodCallback<Map<String,LecturePermissions>> getResultHandler(final AsyncFrameBuffer fb, final int seqid) {
        final org.apache.thrift.AsyncProcessFunction fcall = this;
        return new AsyncMethodCallback<Map<String,LecturePermissions>>() { 
          public void onComplete(Map<String,LecturePermissions> o) {
            getLecturePermissions_result result = new getLecturePermissions_result();
            result.success = o;
            try {
              fcall.sendResponse(fb,result, org.apache.thrift.protocol.TMessageType.REPLY,seqid);
              return;
            } catch (Exception e) {
              LOGGER.error("Exception writing to internal frame buffer", e);
            }
            fb.close();
          }
          public void onError(Exception e) {
            byte msgType = org.apache.thrift.protocol.TMessageType.REPLY;
            org.apache.thrift.TBase msg;
            getLecturePermissions_result result = new getLecturePermissions_result();
            if (e instanceof TAuthorizationException) {
                        result.authError = (TAuthorizationException) e;
                        result.setAuthErrorIsSet(true);
                        msg = result;
            }
            else             if (e instanceof TNotFoundException) {
                        result.notFound = (TNotFoundException) e;
                        result.setNotFoundIsSet(true);
                        msg = result;
            }
            else             if (e instanceof TInternalServerError) {
                        result.serverError = (TInternalServerError) e;
                        result.setServerErrorIsSet(true);
                        msg = result;
            }
             else 
            {
              msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
              msg = (org.apache.thrift.TBase)new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage());
            }
            try {
              fcall.sendResponse(fb,msg,msgType,seqid);
              return;
            } catch (Exception ex) {
              LOGGER.error("Exception writing to internal frame buffer", ex);
            }
            fb.close();
          }
        };
      }

      protected boolean isOneway() {
        return false;
      }

      public void start(I iface, getLecturePermissions_args args, org.apache.thrift.async.AsyncMethodCallback<Map<String,LecturePermissions>> resultHandler) throws TException {
        iface.getLecturePermissions(args.userToken, args.lectureId,resultHandler);
      }
    }

    public static class setLectureOwner<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, setLectureOwner_args, Void> {
      public setLectureOwner() {
        super("setLectureOwner");
      }

      public setLectureOwner_args getEmptyArgsInstance() {
        return new setLectureOwner_args();
      }

      public AsyncMethodCallback<Void> getResultHandler(final AsyncFrameBuffer fb, final int seqid) {
        final org.apache.thrift.AsyncProcessFunction fcall = this;
        return new AsyncMethodCallback<Void>() { 
          public void onComplete(Void o) {
            setLectureOwner_result result = new setLectureOwner_result();
            try {
              fcall.sendResponse(fb,result, org.apache.thrift.protocol.TMessageType.REPLY,seqid);
              return;
            } catch (Exception e) {
              LOGGER.error("Exception writing to internal frame buffer", e);
            }
            fb.close();
          }
          public void onError(Exception e) {
            byte msgType = org.apache.thrift.protocol.TMessageType.REPLY;
            org.apache.thrift.TBase msg;
            setLectureOwner_result result = new setLectureOwner_result();
            if (e instanceof TAuthorizationException) {
                        result.authError = (TAuthorizationException) e;
                        result.setAuthErrorIsSet(true);
                        msg = result;
            }
            else             if (e instanceof TNotFoundException) {
                        result.notFound = (TNotFoundException) e;
                        result.setNotFoundIsSet(true);
                        msg = result;
            }
            else             if (e instanceof TInternalServerError) {
                        result.serverError = (TInternalServerError) e;
                        result.setServerErrorIsSet(true);
                        msg = result;
            }
             else 
            {
              msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION;
              msg = (org.apache.thrift.TBase)new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage());
            }
            try {
              fcall.sendResponse(fb,msg,msgType,seqid);
              return;
            } catch (Exception ex) {
              LOGGER.error("Exception writing to internal frame buffer", ex);
            }
            fb.close();
          }
        };
      }

      protected boolean isOneway() {
        return false;
      }

      public void start(I iface, setLectureOwner_args args, org.apache.thrift.async.AsyncMethodCallback<Void> resultHandler) throws TException {
        iface.setLectureOwner(args.userToken, args.lectureId, args.newOwnerId,resultHandler);
      }
    }

  }

  public static class getVersion_args implements org.apache.thrift.TBase<getVersion_args, getVersion_args._Fields>, java.io.Serializable, Cloneable, Comparable<getVersion_args>   {
    private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getVersion_args");


    private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
    static {
      schemes.put(StandardScheme.class, new getVersion_argsStandardSchemeFactory());
      schemes.put(TupleScheme.class, new getVersion_argsTupleSchemeFactory());
    }


    /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
    public enum _Fields implements org.apache.thrift.TFieldIdEnum {
;

      private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();

      static {
        for (_Fields field : EnumSet.allOf(_Fields.class)) {
          byName.put(field.getFieldName(), field);
        }
      }

      /**
       * Find the _Fields constant that matches fieldId, or null if its not found.
       */
      public static _Fields findByThriftId(int fieldId) {
        switch(fieldId) {
          default:
            return null;
        }
      }

      /**
       * Find the _Fields constant that matches fieldId, throwing an exception
       * if it is not found.
       */
      public static _Fields findByThriftIdOrThrow(int fieldId) {
        _Fields fields = findByThriftId(fieldId);
        if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
        return fields;
      }

      /**
       * Find the _Fields constant that matches name, or null if its not found.
       */
      public static _Fields findByName(String name) {
        return byName.get(name);
      }

      private final short _thriftId;
      private final String _fieldName;

      _Fields(short thriftId, String fieldName) {
        _thriftId = thriftId;
        _fieldName = fieldName;
      }

      public short getThriftFieldId() {
        return _thriftId;
      }

      public String getFieldName() {
        return _fieldName;
      }
    }
    public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
    static {
      Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
      metaDataMap = Collections.unmodifiableMap(tmpMap);
      org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getVersion_args.class, metaDataMap);
    }

    public getVersion_args() {
    }

    /**
     * Performs a deep copy on <i>other</i>.
     */
    public getVersion_args(getVersion_args other) {
    }

    public getVersion_args deepCopy() {
      return new getVersion_args(this);
    }

    @Override
    public void clear() {
    }

    public void setFieldValue(_Fields field, Object value) {
      switch (field) {
      }
    }

    public Object getFieldValue(_Fields field) {
      switch (field) {
      }
      throw new IllegalStateException();
    }

    /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
    public boolean isSet(_Fields field) {
      if (field == null) {
        throw new IllegalArgumentException();
      }

      switch (field) {
      }
      throw new IllegalStateException();
    }

    @Override
    public boolean equals(Object that) {
      if (that == null)
        return false;
      if (that instanceof getVersion_args)
        return this.equals((getVersion_args)that);
      return false;
    }

    public boolean equals(getVersion_args that) {
      if (that == null)
        return false;

      return true;
    }

    @Override
    public int hashCode() {
      return 0;
    }

    @Override
    public int compareTo(getVersion_args other) {
      if (!getClass().equals(other.getClass())) {
        return getClass().getName().compareTo(other.getClass().getName());
      }

      int lastComparison = 0;

      return 0;
    }

    public _Fields fieldForId(int fieldId) {
      return _Fields.findByThriftId(fieldId);
    }

    public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
      schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
    }

    public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
      schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
    }

    @Override
    public String toString() {
      StringBuilder sb = new StringBuilder("getVersion_args(");
      boolean first = true;

      sb.append(")");
      return sb.toString();
    }

    public void validate() throws org.apache.thrift.TException {
      // check for required fields
      // check for sub-struct validity
    }

    private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
      try {
        write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
      } catch (org.apache.thrift.TException te) {
        throw new java.io.IOException(te);
      }
    }

    private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
      try {
        read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
      } catch (org.apache.thrift.TException te) {
        throw new java.io.IOException(te);
      }
    }

    private static class getVersion_argsStandardSchemeFactory implements SchemeFactory {
      public getVersion_argsStandardScheme getScheme() {
        return new getVersion_argsStandardScheme();
      }
    }

    private static class getVersion_argsStandardScheme extends StandardScheme<getVersion_args> {

      public void read(org.apache.thrift.protocol.TProtocol iprot, getVersion_args struct) throws org.apache.thrift.TException {
        org.apache.thrift.protocol.TField schemeField;
        iprot.readStructBegin();
        while (true)
        {
          schemeField = iprot.readFieldBegin();
          if (schemeField.type == org.apache.thrift.protocol.TType.STOP) { 
            break;
          }
          switch (schemeField.id) {
            default:
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
          }
          iprot.readFieldEnd();
        }
        iprot.readStructEnd();

        // check for required fields of primitive type, which can't be checked in the validate method
        struct.validate();
      }

      public void write(org.apache.thrift.protocol.TProtocol oprot, getVersion_args struct) throws org.apache.thrift.TException {
        struct.validate();

        oprot.writeStructBegin(STRUCT_DESC);
        oprot.writeFieldStop();
        oprot.writeStructEnd();
      }

    }

    private static class getVersion_argsTupleSchemeFactory implements SchemeFactory {
      public getVersion_argsTupleScheme getScheme() {
        return new getVersion_argsTupleScheme();
      }
    }

    private static class getVersion_argsTupleScheme extends TupleScheme<getVersion_args> {

      @Override
      public void write(org.apache.thrift.protocol.TProtocol prot, getVersion_args struct) throws org.apache.thrift.TException {
        TTupleProtocol oprot = (TTupleProtocol) prot;
      }

      @Override
      public void read(org.apache.thrift.protocol.TProtocol prot, getVersion_args struct) throws org.apache.thrift.TException {
        TTupleProtocol iprot = (TTupleProtocol) prot;
      }
    }

  }

  public static class getVersion_result implements org.apache.thrift.TBase<getVersion_result, getVersion_result._Fields>, java.io.Serializable, Cloneable, Comparable<getVersion_result>   {
    private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getVersion_result");

    private static final org.apache.thrift.protocol.TField SUCCESS_FIELD_DESC = new org.apache.thrift.protocol.TField("success", org.apache.thrift.protocol.TType.I64, (short)0);

    private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
    static {
      schemes.put(StandardScheme.class, new getVersion_resultStandardSchemeFactory());
      schemes.put(TupleScheme.class, new getVersion_resultTupleSchemeFactory());
    }

    public long success; // required

    /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
    public enum _Fields implements org.apache.thrift.TFieldIdEnum {
      SUCCESS((short)0, "success");

      private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();

      static {
        for (_Fields field : EnumSet.allOf(_Fields.class)) {
          byName.put(field.getFieldName(), field);
        }
      }

      /**
       * Find the _Fields constant that matches fieldId, or null if its not found.
       */
      public static _Fields findByThriftId(int fieldId) {
        switch(fieldId) {
          case 0: // SUCCESS
            return SUCCESS;
          default:
            return null;
        }
      }

      /**
       * Find the _Fields constant that matches fieldId, throwing an exception
       * if it is not found.
       */
      public static _Fields findByThriftIdOrThrow(int fieldId) {
        _Fields fields = findByThriftId(fieldId);
        if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
        return fields;
      }

      /**
       * Find the _Fields constant that matches name, or null if its not found.
       */
      public static _Fields findByName(String name) {
        return byName.get(name);
      }

      private final short _thriftId;
      private final String _fieldName;

      _Fields(short thriftId, String fieldName) {
        _thriftId = thriftId;
        _fieldName = fieldName;
      }

      public short getThriftFieldId() {
        return _thriftId;
      }

      public String getFieldName() {
        return _fieldName;
      }
    }

    // isset id assignments
    private static final int __SUCCESS_ISSET_ID = 0;
    private byte __isset_bitfield = 0;
    public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
    static {
      Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
      tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, 
          new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64          , "int")));
      metaDataMap = Collections.unmodifiableMap(tmpMap);
      org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getVersion_result.class, metaDataMap);
    }

    public getVersion_result() {
    }

    public getVersion_result(
      long success)
    {
      this();
      this.success = success;
      setSuccessIsSet(true);
    }

    /**
     * Performs a deep copy on <i>other</i>.
     */
    public getVersion_result(getVersion_result other) {
      __isset_bitfield = other.__isset_bitfield;
      this.success = other.success;
    }

    public getVersion_result deepCopy() {
      return new getVersion_result(this);
    }

    @Override
    public void clear() {
      setSuccessIsSet(false);
      this.success = 0;
    }

    public long getSuccess() {
      return this.success;
    }

    public getVersion_result setSuccess(long success) {
      this.success = success;
      setSuccessIsSet(true);
      return this;
    }

    public void unsetSuccess() {
      __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __SUCCESS_ISSET_ID);
    }

    /** Returns true if field success is set (has been assigned a value) and false otherwise */
    public boolean isSetSuccess() {
      return EncodingUtils.testBit(__isset_bitfield, __SUCCESS_ISSET_ID);
    }

    public void setSuccessIsSet(boolean value) {
      __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __SUCCESS_ISSET_ID, value);
    }

    public void setFieldValue(_Fields field, Object value) {
      switch (field) {
      case SUCCESS:
        if (value == null) {
          unsetSuccess();
        } else {
          setSuccess((Long)value);
        }
        break;

      }
    }

    public Object getFieldValue(_Fields field) {
      switch (field) {
      case SUCCESS:
        return Long.valueOf(getSuccess());

      }
      throw new IllegalStateException();
    }

    /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
    public boolean isSet(_Fields field) {
      if (field == null) {
        throw new IllegalArgumentException();
      }

      switch (field) {
      case SUCCESS:
        return isSetSuccess();
      }
      throw new IllegalStateException();
    }

    @Override
    public boolean equals(Object that) {
      if (that == null)
        return false;
      if (that instanceof getVersion_result)
        return this.equals((getVersion_result)that);
      return false;
    }

    public boolean equals(getVersion_result that) {
      if (that == null)
        return false;

      boolean this_present_success = true;
      boolean that_present_success = true;
      if (this_present_success || that_present_success) {
        if (!(this_present_success && that_present_success))
          return false;
        if (this.success != that.success)
          return false;
      }

      return true;
    }

    @Override
    public int hashCode() {
      return 0;
    }

    @Override
    public int compareTo(getVersion_result other) {
      if (!getClass().equals(other.getClass())) {
        return getClass().getName().compareTo(other.getClass().getName());
      }

      int lastComparison = 0;

      lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(other.isSetSuccess());
      if (lastComparison != 0) {
        return lastComparison;
      }
      if (isSetSuccess()) {
        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, other.success);
        if (lastComparison != 0) {
          return lastComparison;
        }
      }
      return 0;
    }

    public _Fields fieldForId(int fieldId) {
      return _Fields.findByThriftId(fieldId);
    }

    public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
      schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
    }

    public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
      schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
      }

    @Override
    public String toString() {
      StringBuilder sb = new StringBuilder("getVersion_result(");
      boolean first = true;

      sb.append("success:");
      sb.append(this.success);
      first = false;
      sb.append(")");
      return sb.toString();
    }

    public void validate() throws org.apache.thrift.TException {
      // check for required fields
      // check for sub-struct validity
    }

    private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
      try {
        write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
      } catch (org.apache.thrift.TException te) {
        throw new java.io.IOException(te);
      }
    }

    private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
      try {
        // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor.
        __isset_bitfield = 0;
        read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
      } catch (org.apache.thrift.TException te) {
        throw new java.io.IOException(te);
      }
    }

    private static class getVersion_resultStandardSchemeFactory implements SchemeFactory {
      public getVersion_resultStandardScheme getScheme() {
        return new getVersion_resultStandardScheme();
      }
    }

    private static class getVersion_resultStandardScheme extends StandardScheme<getVersion_result> {

      public void read(org.apache.thrift.protocol.TProtocol iprot, getVersion_result struct) throws org.apache.thrift.TException {
        org.apache.thrift.protocol.TField schemeField;
        iprot.readStructBegin();
        while (true)
        {
          schemeField = iprot.readFieldBegin();
          if (schemeField.type == org.apache.thrift.protocol.TType.STOP) { 
            break;
          }
          switch (schemeField.id) {
            case 0: // SUCCESS
              if (schemeField.type == org.apache.thrift.protocol.TType.I64) {
                struct.success = iprot.readI64();
                struct.setSuccessIsSet(true);
              } else { 
                org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
              }
              break;
            default:
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
          }
          iprot.readFieldEnd();
        }
        iprot.readStructEnd();

        // check for required fields of primitive type, which can't be checked in the validate method
        struct.validate();
      }

      public void write(org.apache.thrift.protocol.TProtocol oprot, getVersion_result struct) throws org.apache.thrift.TException {
        struct.validate();

        oprot.writeStructBegin(STRUCT_DESC);
        if (struct.isSetSuccess()) {
          oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
          oprot.writeI64(struct.success);
          oprot.writeFieldEnd();
        }
        oprot.writeFieldStop();
        oprot.writeStructEnd();
      }

    }

    private static class getVersion_resultTupleSchemeFactory implements SchemeFactory {
      public getVersion_resultTupleScheme getScheme() {
        return new getVersion_resultTupleScheme();
      }
    }

    private static class getVersion_resultTupleScheme extends TupleScheme<getVersion_result> {

      @Override
      public void write(org.apache.thrift.protocol.TProtocol prot, getVersion_result struct) throws org.apache.thrift.TException {
        TTupleProtocol oprot = (TTupleProtocol) prot;
        BitSet optionals = new BitSet();
        if (struct.isSetSuccess()) {
          optionals.set(0);
        }
        oprot.writeBitSet(optionals, 1);
        if (struct.isSetSuccess()) {
          oprot.writeI64(struct.success);
        }
      }

      @Override
      public void read(org.apache.thrift.protocol.TProtocol prot, getVersion_result struct) throws org.apache.thrift.TException {
        TTupleProtocol iprot = (TTupleProtocol) prot;
        BitSet incoming = iprot.readBitSet(1);
        if (incoming.get(0)) {
          struct.success = iprot.readI64();
          struct.setSuccessIsSet(true);
        }
      }
    }

  }

  public static class getConfiguration_args implements org.apache.thrift.TBase<getConfiguration_args, getConfiguration_args._Fields>, java.io.Serializable, Cloneable, Comparable<getConfiguration_args>   {
    private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getConfiguration_args");


    private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
    static {
      schemes.put(StandardScheme.class, new getConfiguration_argsStandardSchemeFactory());
      schemes.put(TupleScheme.class, new getConfiguration_argsTupleSchemeFactory());
    }


    /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
    public enum _Fields implements org.apache.thrift.TFieldIdEnum {
;

      private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();

      static {
        for (_Fields field : EnumSet.allOf(_Fields.class)) {
          byName.put(field.getFieldName(), field);
        }
      }

      /**
       * Find the _Fields constant that matches fieldId, or null if its not found.
       */
      public static _Fields findByThriftId(int fieldId) {
        switch(fieldId) {
          default:
            return null;
        }
      }

      /**
       * Find the _Fields constant that matches fieldId, throwing an exception
       * if it is not found.
       */
      public static _Fields findByThriftIdOrThrow(int fieldId) {
        _Fields fields = findByThriftId(fieldId);
        if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
        return fields;
      }

      /**
       * Find the _Fields constant that matches name, or null if its not found.
       */
      public static _Fields findByName(String name) {
        return byName.get(name);
      }

      private final short _thriftId;
      private final String _fieldName;

      _Fields(short thriftId, String fieldName) {
        _thriftId = thriftId;
        _fieldName = fieldName;
      }

      public short getThriftFieldId() {
        return _thriftId;
      }

      public String getFieldName() {
        return _fieldName;
      }
    }
    public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
    static {
      Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
      metaDataMap = Collections.unmodifiableMap(tmpMap);
      org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getConfiguration_args.class, metaDataMap);
    }

    public getConfiguration_args() {
    }

    /**
     * Performs a deep copy on <i>other</i>.
     */
    public getConfiguration_args(getConfiguration_args other) {
    }

    public getConfiguration_args deepCopy() {
      return new getConfiguration_args(this);
    }

    @Override
    public void clear() {
    }

    public void setFieldValue(_Fields field, Object value) {
      switch (field) {
      }
    }

    public Object getFieldValue(_Fields field) {
      switch (field) {
      }
      throw new IllegalStateException();
    }

    /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
    public boolean isSet(_Fields field) {
      if (field == null) {
        throw new IllegalArgumentException();
      }

      switch (field) {
      }
      throw new IllegalStateException();
    }

    @Override
    public boolean equals(Object that) {
      if (that == null)
        return false;
      if (that instanceof getConfiguration_args)
        return this.equals((getConfiguration_args)that);
      return false;
    }

    public boolean equals(getConfiguration_args that) {
      if (that == null)
        return false;

      return true;
    }

    @Override
    public int hashCode() {
      return 0;
    }

    @Override
    public int compareTo(getConfiguration_args other) {
      if (!getClass().equals(other.getClass())) {
        return getClass().getName().compareTo(other.getClass().getName());
      }

      int lastComparison = 0;

      return 0;
    }

    public _Fields fieldForId(int fieldId) {
      return _Fields.findByThriftId(fieldId);
    }

    public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
      schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
    }

    public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
      schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
    }

    @Override
    public String toString() {
      StringBuilder sb = new StringBuilder("getConfiguration_args(");
      boolean first = true;

      sb.append(")");
      return sb.toString();
    }

    public void validate() throws org.apache.thrift.TException {
      // check for required fields
      // check for sub-struct validity
    }

    private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
      try {
        write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
      } catch (org.apache.thrift.TException te) {
        throw new java.io.IOException(te);
      }
    }

    private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
      try {
        read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
      } catch (org.apache.thrift.TException te) {
        throw new java.io.IOException(te);
      }
    }

    private static class getConfiguration_argsStandardSchemeFactory implements SchemeFactory {
      public getConfiguration_argsStandardScheme getScheme() {
        return new getConfiguration_argsStandardScheme();
      }
    }

    private static class getConfiguration_argsStandardScheme extends StandardScheme<getConfiguration_args> {

      public void read(org.apache.thrift.protocol.TProtocol iprot, getConfiguration_args struct) throws org.apache.thrift.TException {
        org.apache.thrift.protocol.TField schemeField;
        iprot.readStructBegin();
        while (true)
        {
          schemeField = iprot.readFieldBegin();
          if (schemeField.type == org.apache.thrift.protocol.TType.STOP) { 
            break;
          }
          switch (schemeField.id) {
            default:
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
          }
          iprot.readFieldEnd();
        }
        iprot.readStructEnd();

        // check for required fields of primitive type, which can't be checked in the validate method
        struct.validate();
      }

      public void write(org.apache.thrift.protocol.TProtocol oprot, getConfiguration_args struct) throws org.apache.thrift.TException {
        struct.validate();

        oprot.writeStructBegin(STRUCT_DESC);
        oprot.writeFieldStop();
        oprot.writeStructEnd();
      }

    }

    private static class getConfiguration_argsTupleSchemeFactory implements SchemeFactory {
      public getConfiguration_argsTupleScheme getScheme() {
        return new getConfiguration_argsTupleScheme();
      }
    }

    private static class getConfiguration_argsTupleScheme extends TupleScheme<getConfiguration_args> {

      @Override
      public void write(org.apache.thrift.protocol.TProtocol prot, getConfiguration_args struct) throws org.apache.thrift.TException {
        TTupleProtocol oprot = (TTupleProtocol) prot;
      }

      @Override
      public void read(org.apache.thrift.protocol.TProtocol prot, getConfiguration_args struct) throws org.apache.thrift.TException {
        TTupleProtocol iprot = (TTupleProtocol) prot;
      }
    }

  }

  public static class getConfiguration_result implements org.apache.thrift.TBase<getConfiguration_result, getConfiguration_result._Fields>, java.io.Serializable, Cloneable, Comparable<getConfiguration_result>   {
    private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getConfiguration_result");

    private static final org.apache.thrift.protocol.TField SUCCESS_FIELD_DESC = new org.apache.thrift.protocol.TField("success", org.apache.thrift.protocol.TType.STRUCT, (short)0);

    private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
    static {
      schemes.put(StandardScheme.class, new getConfiguration_resultStandardSchemeFactory());
      schemes.put(TupleScheme.class, new getConfiguration_resultTupleSchemeFactory());
    }

    public SatelliteConfig success; // required

    /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
    public enum _Fields implements org.apache.thrift.TFieldIdEnum {
      SUCCESS((short)0, "success");

      private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();

      static {
        for (_Fields field : EnumSet.allOf(_Fields.class)) {
          byName.put(field.getFieldName(), field);
        }
      }

      /**
       * Find the _Fields constant that matches fieldId, or null if its not found.
       */
      public static _Fields findByThriftId(int fieldId) {
        switch(fieldId) {
          case 0: // SUCCESS
            return SUCCESS;
          default:
            return null;
        }
      }

      /**
       * Find the _Fields constant that matches fieldId, throwing an exception
       * if it is not found.
       */
      public static _Fields findByThriftIdOrThrow(int fieldId) {
        _Fields fields = findByThriftId(fieldId);
        if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
        return fields;
      }

      /**
       * Find the _Fields constant that matches name, or null if its not found.
       */
      public static _Fields findByName(String name) {
        return byName.get(name);
      }

      private final short _thriftId;
      private final String _fieldName;

      _Fields(short thriftId, String fieldName) {
        _thriftId = thriftId;
        _fieldName = fieldName;
      }

      public short getThriftFieldId() {
        return _thriftId;
      }

      public String getFieldName() {
        return _fieldName;
      }
    }

    // isset id assignments
    public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
    static {
      Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
      tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, 
          new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, SatelliteConfig.class)));
      metaDataMap = Collections.unmodifiableMap(tmpMap);
      org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getConfiguration_result.class, metaDataMap);
    }

    public getConfiguration_result() {
    }

    public getConfiguration_result(
      SatelliteConfig success)
    {
      this();
      this.success = success;
    }

    /**
     * Performs a deep copy on <i>other</i>.
     */
    public getConfiguration_result(getConfiguration_result other) {
      if (other.isSetSuccess()) {
        this.success = new SatelliteConfig(other.success);
      }
    }

    public getConfiguration_result deepCopy() {
      return new getConfiguration_result(this);
    }

    @Override
    public void clear() {
      this.success = null;
    }

    public SatelliteConfig getSuccess() {
      return this.success;
    }

    public getConfiguration_result setSuccess(SatelliteConfig success) {
      this.success = success;
      return this;
    }

    public void unsetSuccess() {
      this.success = null;
    }

    /** Returns true if field success is set (has been assigned a value) and false otherwise */
    public boolean isSetSuccess() {
      return this.success != null;
    }

    public void setSuccessIsSet(boolean value) {
      if (!value) {
        this.success = null;
      }
    }

    public void setFieldValue(_Fields field, Object value) {
      switch (field) {
      case SUCCESS:
        if (value == null) {
          unsetSuccess();
        } else {
          setSuccess((SatelliteConfig)value);
        }
        break;

      }
    }

    public Object getFieldValue(_Fields field) {
      switch (field) {
      case SUCCESS:
        return getSuccess();

      }
      throw new IllegalStateException();
    }

    /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
    public boolean isSet(_Fields field) {
      if (field == null) {
        throw new IllegalArgumentException();
      }

      switch (field) {
      case SUCCESS:
        return isSetSuccess();
      }
      throw new IllegalStateException();
    }

    @Override
    public boolean equals(Object that) {
      if (that == null)
        return false;
      if (that instanceof getConfiguration_result)
        return this.equals((getConfiguration_result)that);
      return false;
    }

    public boolean equals(getConfiguration_result that) {
      if (that == null)
        return false;

      boolean this_present_success = true && this.isSetSuccess();
      boolean that_present_success = true && that.isSetSuccess();
      if (this_present_success || that_present_success) {
        if (!(this_present_success && that_present_success))
          return false;
        if (!this.success.equals(that.success))
          return false;
      }

      return true;
    }

    @Override
    public int hashCode() {
      return 0;
    }

    @Override
    public int compareTo(getConfiguration_result other) {
      if (!getClass().equals(other.getClass())) {
        return getClass().getName().compareTo(other.getClass().getName());
      }

      int lastComparison = 0;

      lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(other.isSetSuccess());
      if (lastComparison != 0) {
        return lastComparison;
      }
      if (isSetSuccess()) {
        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, other.success);
        if (lastComparison != 0) {
          return lastComparison;
        }
      }
      return 0;
    }

    public _Fields fieldForId(int fieldId) {
      return _Fields.findByThriftId(fieldId);
    }

    public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
      schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
    }

    public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
      schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
      }

    @Override
    public String toString() {
      StringBuilder sb = new StringBuilder("getConfiguration_result(");
      boolean first = true;

      sb.append("success:");
      if (this.success == null) {
        sb.append("null");
      } else {
        sb.append(this.success);
      }
      first = false;
      sb.append(")");
      return sb.toString();
    }

    public void validate() throws org.apache.thrift.TException {
      // check for required fields
      // check for sub-struct validity
      if (success != null) {
        success.validate();
      }
    }

    private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
      try {
        write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
      } catch (org.apache.thrift.TException te) {
        throw new java.io.IOException(te);
      }
    }

    private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
      try {
        read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
      } catch (org.apache.thrift.TException te) {
        throw new java.io.IOException(te);
      }
    }

    private static class getConfiguration_resultStandardSchemeFactory implements SchemeFactory {
      public getConfiguration_resultStandardScheme getScheme() {
        return new getConfiguration_resultStandardScheme();
      }
    }

    private static class getConfiguration_resultStandardScheme extends StandardScheme<getConfiguration_result> {

      public void read(org.apache.thrift.protocol.TProtocol iprot, getConfiguration_result struct) throws org.apache.thrift.TException {
        org.apache.thrift.protocol.TField schemeField;
        iprot.readStructBegin();
        while (true)
        {
          schemeField = iprot.readFieldBegin();
          if (schemeField.type == org.apache.thrift.protocol.TType.STOP) { 
            break;
          }
          switch (schemeField.id) {
            case 0: // SUCCESS
              if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
                struct.success = new SatelliteConfig();
                struct.success.read(iprot);
                struct.setSuccessIsSet(true);
              } else { 
                org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
              }
              break;
            default:
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
          }
          iprot.readFieldEnd();
        }
        iprot.readStructEnd();

        // check for required fields of primitive type, which can't be checked in the validate method
        struct.validate();
      }

      public void write(org.apache.thrift.protocol.TProtocol oprot, getConfiguration_result struct) throws org.apache.thrift.TException {
        struct.validate();

        oprot.writeStructBegin(STRUCT_DESC);
        if (struct.success != null) {
          oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
          struct.success.write(oprot);
          oprot.writeFieldEnd();
        }
        oprot.writeFieldStop();
        oprot.writeStructEnd();
      }

    }

    private static class getConfiguration_resultTupleSchemeFactory implements SchemeFactory {
      public getConfiguration_resultTupleScheme getScheme() {
        return new getConfiguration_resultTupleScheme();
      }
    }

    private static class getConfiguration_resultTupleScheme extends TupleScheme<getConfiguration_result> {

      @Override
      public void write(org.apache.thrift.protocol.TProtocol prot, getConfiguration_result struct) throws org.apache.thrift.TException {
        TTupleProtocol oprot = (TTupleProtocol) prot;
        BitSet optionals = new BitSet();
        if (struct.isSetSuccess()) {
          optionals.set(0);
        }
        oprot.writeBitSet(optionals, 1);
        if (struct.isSetSuccess()) {
          struct.success.write(oprot);
        }
      }

      @Override
      public void read(org.apache.thrift.protocol.TProtocol prot, getConfiguration_result struct) throws org.apache.thrift.TException {
        TTupleProtocol iprot = (TTupleProtocol) prot;
        BitSet incoming = iprot.readBitSet(1);
        if (incoming.get(0)) {
          struct.success = new SatelliteConfig();
          struct.success.read(iprot);
          struct.setSuccessIsSet(true);
        }
      }
    }

  }

  public static class requestImageVersionUpload_args implements org.apache.thrift.TBase<requestImageVersionUpload_args, requestImageVersionUpload_args._Fields>, java.io.Serializable, Cloneable, Comparable<requestImageVersionUpload_args>   {
    private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("requestImageVersionUpload_args");

    private static final org.apache.thrift.protocol.TField USER_TOKEN_FIELD_DESC = new org.apache.thrift.protocol.TField("userToken", org.apache.thrift.protocol.TType.STRING, (short)1);
    private static final org.apache.thrift.protocol.TField IMAGE_BASE_ID_FIELD_DESC = new org.apache.thrift.protocol.TField("imageBaseId", org.apache.thrift.protocol.TType.STRING, (short)2);
    private static final org.apache.thrift.protocol.TField FILE_SIZE_FIELD_DESC = new org.apache.thrift.protocol.TField("fileSize", org.apache.thrift.protocol.TType.I64, (short)3);
    private static final org.apache.thrift.protocol.TField BLOCK_HASHES_FIELD_DESC = new org.apache.thrift.protocol.TField("blockHashes", org.apache.thrift.protocol.TType.LIST, (short)4);
    private static final org.apache.thrift.protocol.TField MACHINE_DESCRIPTION_FIELD_DESC = new org.apache.thrift.protocol.TField("machineDescription", org.apache.thrift.protocol.TType.STRING, (short)5);

    private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
    static {
      schemes.put(StandardScheme.class, new requestImageVersionUpload_argsStandardSchemeFactory());
      schemes.put(TupleScheme.class, new requestImageVersionUpload_argsTupleSchemeFactory());
    }

    public String userToken; // required
    public String imageBaseId; // required
    public long fileSize; // required
    public List<ByteBuffer> blockHashes; // required
    public ByteBuffer machineDescription; // required

    /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
    public enum _Fields implements org.apache.thrift.TFieldIdEnum {
      USER_TOKEN((short)1, "userToken"),
      IMAGE_BASE_ID((short)2, "imageBaseId"),
      FILE_SIZE((short)3, "fileSize"),
      BLOCK_HASHES((short)4, "blockHashes"),
      MACHINE_DESCRIPTION((short)5, "machineDescription");

      private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();

      static {
        for (_Fields field : EnumSet.allOf(_Fields.class)) {
          byName.put(field.getFieldName(), field);
        }
      }

      /**
       * Find the _Fields constant that matches fieldId, or null if its not found.
       */
      public static _Fields findByThriftId(int fieldId) {
        switch(fieldId) {
          case 1: // USER_TOKEN
            return USER_TOKEN;
          case 2: // IMAGE_BASE_ID
            return IMAGE_BASE_ID;
          case 3: // FILE_SIZE
            return FILE_SIZE;
          case 4: // BLOCK_HASHES
            return BLOCK_HASHES;
          case 5: // MACHINE_DESCRIPTION
            return MACHINE_DESCRIPTION;
          default:
            return null;
        }
      }

      /**
       * Find the _Fields constant that matches fieldId, throwing an exception
       * if it is not found.
       */
      public static _Fields findByThriftIdOrThrow(int fieldId) {
        _Fields fields = findByThriftId(fieldId);
        if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
        return fields;
      }

      /**
       * Find the _Fields constant that matches name, or null if its not found.
       */
      public static _Fields findByName(String name) {
        return byName.get(name);
      }

      private final short _thriftId;
      private final String _fieldName;

      _Fields(short thriftId, String fieldName) {
        _thriftId = thriftId;
        _fieldName = fieldName;
      }

      public short getThriftFieldId() {
        return _thriftId;
      }

      public String getFieldName() {
        return _fieldName;
      }
    }

    // isset id assignments
    private static final int __FILESIZE_ISSET_ID = 0;
    private byte __isset_bitfield = 0;
    public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
    static {
      Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
      tmpMap.put(_Fields.USER_TOKEN, new org.apache.thrift.meta_data.FieldMetaData("userToken", org.apache.thrift.TFieldRequirementType.DEFAULT, 
          new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING          , "Token")));
      tmpMap.put(_Fields.IMAGE_BASE_ID, new org.apache.thrift.meta_data.FieldMetaData("imageBaseId", org.apache.thrift.TFieldRequirementType.DEFAULT, 
          new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING          , "UUID")));
      tmpMap.put(_Fields.FILE_SIZE, new org.apache.thrift.meta_data.FieldMetaData("fileSize", org.apache.thrift.TFieldRequirementType.DEFAULT, 
          new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64)));
      tmpMap.put(_Fields.BLOCK_HASHES, new org.apache.thrift.meta_data.FieldMetaData("blockHashes", org.apache.thrift.TFieldRequirementType.DEFAULT, 
          new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST, 
              new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING              , true))));
      tmpMap.put(_Fields.MACHINE_DESCRIPTION, new org.apache.thrift.meta_data.FieldMetaData("machineDescription", org.apache.thrift.TFieldRequirementType.DEFAULT, 
          new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING          , true)));
      metaDataMap = Collections.unmodifiableMap(tmpMap);
      org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(requestImageVersionUpload_args.class, metaDataMap);
    }

    public requestImageVersionUpload_args() {
    }

    public requestImageVersionUpload_args(
      String userToken,
      String imageBaseId,
      long fileSize,
      List<ByteBuffer> blockHashes,
      ByteBuffer machineDescription)
    {
      this();
      this.userToken = userToken;
      this.imageBaseId = imageBaseId;
      this.fileSize = fileSize;
      setFileSizeIsSet(true);
      this.blockHashes = blockHashes;
      this.machineDescription = machineDescription;
    }

    /**
     * Performs a deep copy on <i>other</i>.
     */
    public requestImageVersionUpload_args(requestImageVersionUpload_args other) {
      __isset_bitfield = other.__isset_bitfield;
      if (other.isSetUserToken()) {
        this.userToken = other.userToken;
      }
      if (other.isSetImageBaseId()) {
        this.imageBaseId = other.imageBaseId;
      }
      this.fileSize = other.fileSize;
      if (other.isSetBlockHashes()) {
        List<ByteBuffer> __this__blockHashes = new ArrayList<ByteBuffer>(other.blockHashes);
        this.blockHashes = __this__blockHashes;
      }
      if (other.isSetMachineDescription()) {
        this.machineDescription = org.apache.thrift.TBaseHelper.copyBinary(other.machineDescription);
;
      }
    }

    public requestImageVersionUpload_args deepCopy() {
      return new requestImageVersionUpload_args(this);
    }

    @Override
    public void clear() {
      this.userToken = null;
      this.imageBaseId = null;
      setFileSizeIsSet(false);
      this.fileSize = 0;
      this.blockHashes = null;
      this.machineDescription = null;
    }

    public String getUserToken() {
      return this.userToken;
    }

    public requestImageVersionUpload_args setUserToken(String userToken) {
      this.userToken = userToken;
      return this;
    }

    public void unsetUserToken() {
      this.userToken = null;
    }

    /** Returns true if field userToken is set (has been assigned a value) and false otherwise */
    public boolean isSetUserToken() {
      return this.userToken != null;
    }

    public void setUserTokenIsSet(boolean value) {
      if (!value) {
        this.userToken = null;
      }
    }

    public String getImageBaseId() {
      return this.imageBaseId;
    }

    public requestImageVersionUpload_args setImageBaseId(String imageBaseId) {
      this.imageBaseId = imageBaseId;
      return this;
    }

    public void unsetImageBaseId() {
      this.imageBaseId = null;
    }

    /** Returns true if field imageBaseId is set (has been assigned a value) and false otherwise */
    public boolean isSetImageBaseId() {
      return this.imageBaseId != null;
    }

    public void setImageBaseIdIsSet(boolean value) {
      if (!value) {
        this.imageBaseId = null;
      }
    }

    public long getFileSize() {
      return this.fileSize;
    }

    public requestImageVersionUpload_args setFileSize(long fileSize) {
      this.fileSize = fileSize;
      setFileSizeIsSet(true);
      return this;
    }

    public void unsetFileSize() {
      __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __FILESIZE_ISSET_ID);
    }

    /** Returns true if field fileSize is set (has been assigned a value) and false otherwise */
    public boolean isSetFileSize() {
      return EncodingUtils.testBit(__isset_bitfield, __FILESIZE_ISSET_ID);
    }

    public void setFileSizeIsSet(boolean value) {
      __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __FILESIZE_ISSET_ID, value);
    }

    public int getBlockHashesSize() {
      return (this.blockHashes == null) ? 0 : this.blockHashes.size();
    }

    public java.util.Iterator<ByteBuffer> getBlockHashesIterator() {
      return (this.blockHashes == null) ? null : this.blockHashes.iterator();
    }

    public void addToBlockHashes(ByteBuffer elem) {
      if (this.blockHashes == null) {
        this.blockHashes = new ArrayList<ByteBuffer>();
      }
      this.blockHashes.add(elem);
    }

    public List<ByteBuffer> getBlockHashes() {
      return this.blockHashes;
    }

    public requestImageVersionUpload_args setBlockHashes(List<ByteBuffer> blockHashes) {
      this.blockHashes = blockHashes;
      return this;
    }

    public void unsetBlockHashes() {
      this.blockHashes = null;
    }

    /** Returns true if field blockHashes is set (has been assigned a value) and false otherwise */
    public boolean isSetBlockHashes() {
      return this.blockHashes != null;
    }

    public void setBlockHashesIsSet(boolean value) {
      if (!value) {
        this.blockHashes = null;
      }
    }

    public byte[] getMachineDescription() {
      setMachineDescription(org.apache.thrift.TBaseHelper.rightSize(machineDescription));
      return machineDescription == null ? null : machineDescription.array();
    }

    public ByteBuffer bufferForMachineDescription() {
      return machineDescription;
    }

    public requestImageVersionUpload_args setMachineDescription(byte[] machineDescription) {
      setMachineDescription(machineDescription == null ? (ByteBuffer)null : ByteBuffer.wrap(machineDescription));
      return this;
    }

    public requestImageVersionUpload_args setMachineDescription(ByteBuffer machineDescription) {
      this.machineDescription = machineDescription;
      return this;
    }

    public void unsetMachineDescription() {
      this.machineDescription = null;
    }

    /** Returns true if field machineDescription is set (has been assigned a value) and false otherwise */
    public boolean isSetMachineDescription() {
      return this.machineDescription != null;
    }

    public void setMachineDescriptionIsSet(boolean value) {
      if (!value) {
        this.machineDescription = null;
      }
    }

    public void setFieldValue(_Fields field, Object value) {
      switch (field) {
      case USER_TOKEN:
        if (value == null) {
          unsetUserToken();
        } else {
          setUserToken((String)value);
        }
        break;

      case IMAGE_BASE_ID:
        if (value == null) {
          unsetImageBaseId();
        } else {
          setImageBaseId((String)value);
        }
        break;

      case FILE_SIZE:
        if (value == null) {
          unsetFileSize();
        } else {
          setFileSize((Long)value);
        }
        break;

      case BLOCK_HASHES:
        if (value == null) {
          unsetBlockHashes();
        } else {
          setBlockHashes((List<ByteBuffer>)value);
        }
        break;

      case MACHINE_DESCRIPTION:
        if (value == null) {
          unsetMachineDescription();
        } else {
          setMachineDescription((ByteBuffer)value);
        }
        break;

      }
    }

    public Object getFieldValue(_Fields field) {
      switch (field) {
      case USER_TOKEN:
        return getUserToken();

      case IMAGE_BASE_ID:
        return getImageBaseId();

      case FILE_SIZE:
        return Long.valueOf(getFileSize());

      case BLOCK_HASHES:
        return getBlockHashes();

      case MACHINE_DESCRIPTION:
        return getMachineDescription();

      }
      throw new IllegalStateException();
    }

    /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
    public boolean isSet(_Fields field) {
      if (field == null) {
        throw new IllegalArgumentException();
      }

      switch (field) {
      case USER_TOKEN:
        return isSetUserToken();
      case IMAGE_BASE_ID:
        return isSetImageBaseId();
      case FILE_SIZE:
        return isSetFileSize();
      case BLOCK_HASHES:
        return isSetBlockHashes();
      case MACHINE_DESCRIPTION:
        return isSetMachineDescription();
      }
      throw new IllegalStateException();
    }

    @Override
    public boolean equals(Object that) {
      if (that == null)
        return false;
      if (that instanceof requestImageVersionUpload_args)
        return this.equals((requestImageVersionUpload_args)that);
      return false;
    }

    public boolean equals(requestImageVersionUpload_args that) {
      if (that == null)
        return false;

      boolean this_present_userToken = true && this.isSetUserToken();
      boolean that_present_userToken = true && that.isSetUserToken();
      if (this_present_userToken || that_present_userToken) {
        if (!(this_present_userToken && that_present_userToken))
          return false;
        if (!this.userToken.equals(that.userToken))
          return false;
      }

      boolean this_present_imageBaseId = true && this.isSetImageBaseId();
      boolean that_present_imageBaseId = true && that.isSetImageBaseId();
      if (this_present_imageBaseId || that_present_imageBaseId) {
        if (!(this_present_imageBaseId && that_present_imageBaseId))
          return false;
        if (!this.imageBaseId.equals(that.imageBaseId))
          return false;
      }

      boolean this_present_fileSize = true;
      boolean that_present_fileSize = true;
      if (this_present_fileSize || that_present_fileSize) {
        if (!(this_present_fileSize && that_present_fileSize))
          return false;
        if (this.fileSize != that.fileSize)
          return false;
      }

      boolean this_present_blockHashes = true && this.isSetBlockHashes();
      boolean that_present_blockHashes = true && that.isSetBlockHashes();
      if (this_present_blockHashes || that_present_blockHashes) {
        if (!(this_present_blockHashes && that_present_blockHashes))
          return false;
        if (!this.blockHashes.equals(that.blockHashes))
          return false;
      }

      boolean this_present_machineDescription = true && this.isSetMachineDescription();
      boolean that_present_machineDescription = true && that.isSetMachineDescription();
      if (this_present_machineDescription || that_present_machineDescription) {
        if (!(this_present_machineDescription && that_present_machineDescription))
          return false;
        if (!this.machineDescription.equals(that.machineDescription))
          return false;
      }

      return true;
    }

    @Override
    public int hashCode() {
      return 0;
    }

    @Override
    public int compareTo(requestImageVersionUpload_args other) {
      if (!getClass().equals(other.getClass())) {
        return getClass().getName().compareTo(other.getClass().getName());
      }

      int lastComparison = 0;

      lastComparison = Boolean.valueOf(isSetUserToken()).compareTo(other.isSetUserToken());
      if (lastComparison != 0) {
        return lastComparison;
      }
      if (isSetUserToken()) {
        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.userToken, other.userToken);
        if (lastComparison != 0) {
          return lastComparison;
        }
      }
      lastComparison = Boolean.valueOf(isSetImageBaseId()).compareTo(other.isSetImageBaseId());
      if (lastComparison != 0) {
        return lastComparison;
      }
      if (isSetImageBaseId()) {
        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.imageBaseId, other.imageBaseId);
        if (lastComparison != 0) {
          return lastComparison;
        }
      }
      lastComparison = Boolean.valueOf(isSetFileSize()).compareTo(other.isSetFileSize());
      if (lastComparison != 0) {
        return lastComparison;
      }
      if (isSetFileSize()) {
        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.fileSize, other.fileSize);
        if (lastComparison != 0) {
          return lastComparison;
        }
      }
      lastComparison = Boolean.valueOf(isSetBlockHashes()).compareTo(other.isSetBlockHashes());
      if (lastComparison != 0) {
        return lastComparison;
      }
      if (isSetBlockHashes()) {
        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.blockHashes, other.blockHashes);
        if (lastComparison != 0) {
          return lastComparison;
        }
      }
      lastComparison = Boolean.valueOf(isSetMachineDescription()).compareTo(other.isSetMachineDescription());
      if (lastComparison != 0) {
        return lastComparison;
      }
      if (isSetMachineDescription()) {
        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.machineDescription, other.machineDescription);
        if (lastComparison != 0) {
          return lastComparison;
        }
      }
      return 0;
    }

    public _Fields fieldForId(int fieldId) {
      return _Fields.findByThriftId(fieldId);
    }

    public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
      schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
    }

    public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
      schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
    }

    @Override
    public String toString() {
      StringBuilder sb = new StringBuilder("requestImageVersionUpload_args(");
      boolean first = true;

      sb.append("userToken:");
      if (this.userToken == null) {
        sb.append("null");
      } else {
        sb.append(this.userToken);
      }
      first = false;
      if (!first) sb.append(", ");
      sb.append("imageBaseId:");
      if (this.imageBaseId == null) {
        sb.append("null");
      } else {
        sb.append(this.imageBaseId);
      }
      first = false;
      if (!first) sb.append(", ");
      sb.append("fileSize:");
      sb.append(this.fileSize);
      first = false;
      if (!first) sb.append(", ");
      sb.append("blockHashes:");
      if (this.blockHashes == null) {
        sb.append("null");
      } else {
        sb.append(this.blockHashes);
      }
      first = false;
      if (!first) sb.append(", ");
      sb.append("machineDescription:");
      if (this.machineDescription == null) {
        sb.append("null");
      } else {
        org.apache.thrift.TBaseHelper.toString(this.machineDescription, sb);
      }
      first = false;
      sb.append(")");
      return sb.toString();
    }

    public void validate() throws org.apache.thrift.TException {
      // check for required fields
      // check for sub-struct validity
    }

    private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
      try {
        write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
      } catch (org.apache.thrift.TException te) {
        throw new java.io.IOException(te);
      }
    }

    private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
      try {
        // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor.
        __isset_bitfield = 0;
        read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
      } catch (org.apache.thrift.TException te) {
        throw new java.io.IOException(te);
      }
    }

    private static class requestImageVersionUpload_argsStandardSchemeFactory implements SchemeFactory {
      public requestImageVersionUpload_argsStandardScheme getScheme() {
        return new requestImageVersionUpload_argsStandardScheme();
      }
    }

    private static class requestImageVersionUpload_argsStandardScheme extends StandardScheme<requestImageVersionUpload_args> {

      public void read(org.apache.thrift.protocol.TProtocol iprot, requestImageVersionUpload_args struct) throws org.apache.thrift.TException {
        org.apache.thrift.protocol.TField schemeField;
        iprot.readStructBegin();
        while (true)
        {
          schemeField = iprot.readFieldBegin();
          if (schemeField.type == org.apache.thrift.protocol.TType.STOP) { 
            break;
          }
          switch (schemeField.id) {
            case 1: // USER_TOKEN
              if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
                struct.userToken = iprot.readString();
                struct.setUserTokenIsSet(true);
              } else { 
                org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
              }
              break;
            case 2: // IMAGE_BASE_ID
              if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
                struct.imageBaseId = iprot.readString();
                struct.setImageBaseIdIsSet(true);
              } else { 
                org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
              }
              break;
            case 3: // FILE_SIZE
              if (schemeField.type == org.apache.thrift.protocol.TType.I64) {
                struct.fileSize = iprot.readI64();
                struct.setFileSizeIsSet(true);
              } else { 
                org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
              }
              break;
            case 4: // BLOCK_HASHES
              if (schemeField.type == org.apache.thrift.protocol.TType.LIST) {
                {
                  org.apache.thrift.protocol.TList _list130 = iprot.readListBegin();
                  struct.blockHashes = new ArrayList<ByteBuffer>(_list130.size);
                  for (int _i131 = 0; _i131 < _list130.size; ++_i131)
                  {
                    ByteBuffer _elem132;
                    _elem132 = iprot.readBinary();
                    struct.blockHashes.add(_elem132);
                  }
                  iprot.readListEnd();
                }
                struct.setBlockHashesIsSet(true);
              } else { 
                org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
              }
              break;
            case 5: // MACHINE_DESCRIPTION
              if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
                struct.machineDescription = iprot.readBinary();
                struct.setMachineDescriptionIsSet(true);
              } else { 
                org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
              }
              break;
            default:
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
          }
          iprot.readFieldEnd();
        }
        iprot.readStructEnd();

        // check for required fields of primitive type, which can't be checked in the validate method
        struct.validate();
      }

      public void write(org.apache.thrift.protocol.TProtocol oprot, requestImageVersionUpload_args struct) throws org.apache.thrift.TException {
        struct.validate();

        oprot.writeStructBegin(STRUCT_DESC);
        if (struct.userToken != null) {
          oprot.writeFieldBegin(USER_TOKEN_FIELD_DESC);
          oprot.writeString(struct.userToken);
          oprot.writeFieldEnd();
        }
        if (struct.imageBaseId != null) {
          oprot.writeFieldBegin(IMAGE_BASE_ID_FIELD_DESC);
          oprot.writeString(struct.imageBaseId);
          oprot.writeFieldEnd();
        }
        oprot.writeFieldBegin(FILE_SIZE_FIELD_DESC);
        oprot.writeI64(struct.fileSize);
        oprot.writeFieldEnd();
        if (struct.blockHashes != null) {
          oprot.writeFieldBegin(BLOCK_HASHES_FIELD_DESC);
          {
            oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.blockHashes.size()));
            for (ByteBuffer _iter133 : struct.blockHashes)
            {
              oprot.writeBinary(_iter133);
            }
            oprot.writeListEnd();
          }
          oprot.writeFieldEnd();
        }
        if (struct.machineDescription != null) {
          oprot.writeFieldBegin(MACHINE_DESCRIPTION_FIELD_DESC);
          oprot.writeBinary(struct.machineDescription);
          oprot.writeFieldEnd();
        }
        oprot.writeFieldStop();
        oprot.writeStructEnd();
      }

    }

    private static class requestImageVersionUpload_argsTupleSchemeFactory implements SchemeFactory {
      public requestImageVersionUpload_argsTupleScheme getScheme() {
        return new requestImageVersionUpload_argsTupleScheme();
      }
    }

    private static class requestImageVersionUpload_argsTupleScheme extends TupleScheme<requestImageVersionUpload_args> {

      @Override
      public void write(org.apache.thrift.protocol.TProtocol prot, requestImageVersionUpload_args struct) throws org.apache.thrift.TException {
        TTupleProtocol oprot = (TTupleProtocol) prot;
        BitSet optionals = new BitSet();
        if (struct.isSetUserToken()) {
          optionals.set(0);
        }
        if (struct.isSetImageBaseId()) {
          optionals.set(1);
        }
        if (struct.isSetFileSize()) {
          optionals.set(2);
        }
        if (struct.isSetBlockHashes()) {
          optionals.set(3);
        }
        if (struct.isSetMachineDescription()) {
          optionals.set(4);
        }
        oprot.writeBitSet(optionals, 5);
        if (struct.isSetUserToken()) {
          oprot.writeString(struct.userToken);
        }
        if (struct.isSetImageBaseId()) {
          oprot.writeString(struct.imageBaseId);
        }
        if (struct.isSetFileSize()) {
          oprot.writeI64(struct.fileSize);
        }
        if (struct.isSetBlockHashes()) {
          {
            oprot.writeI32(struct.blockHashes.size());
            for (ByteBuffer _iter134 : struct.blockHashes)
            {
              oprot.writeBinary(_iter134);
            }
          }
        }
        if (struct.isSetMachineDescription()) {
          oprot.writeBinary(struct.machineDescription);
        }
      }

      @Override
      public void read(org.apache.thrift.protocol.TProtocol prot, requestImageVersionUpload_args struct) throws org.apache.thrift.TException {
        TTupleProtocol iprot = (TTupleProtocol) prot;
        BitSet incoming = iprot.readBitSet(5);
        if (incoming.get(0)) {
          struct.userToken = iprot.readString();
          struct.setUserTokenIsSet(true);
        }
        if (incoming.get(1)) {
          struct.imageBaseId = iprot.readString();
          struct.setImageBaseIdIsSet(true);
        }
        if (incoming.get(2)) {
          struct.fileSize = iprot.readI64();
          struct.setFileSizeIsSet(true);
        }
        if (incoming.get(3)) {
          {
            org.apache.thrift.protocol.TList _list135 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32());
            struct.blockHashes = new ArrayList<ByteBuffer>(_list135.size);
            for (int _i136 = 0; _i136 < _list135.size; ++_i136)
            {
              ByteBuffer _elem137;
              _elem137 = iprot.readBinary();
              struct.blockHashes.add(_elem137);
            }
          }
          struct.setBlockHashesIsSet(true);
        }
        if (incoming.get(4)) {
          struct.machineDescription = iprot.readBinary();
          struct.setMachineDescriptionIsSet(true);
        }
      }
    }

  }

  public static class requestImageVersionUpload_result implements org.apache.thrift.TBase<requestImageVersionUpload_result, requestImageVersionUpload_result._Fields>, java.io.Serializable, Cloneable, Comparable<requestImageVersionUpload_result>   {
    private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("requestImageVersionUpload_result");

    private static final org.apache.thrift.protocol.TField SUCCESS_FIELD_DESC = new org.apache.thrift.protocol.TField("success", org.apache.thrift.protocol.TType.STRUCT, (short)0);
    private static final org.apache.thrift.protocol.TField REJECTION_FIELD_DESC = new org.apache.thrift.protocol.TField("rejection", org.apache.thrift.protocol.TType.STRUCT, (short)1);
    private static final org.apache.thrift.protocol.TField AUTH_ERROR_FIELD_DESC = new org.apache.thrift.protocol.TField("authError", org.apache.thrift.protocol.TType.STRUCT, (short)2);
    private static final org.apache.thrift.protocol.TField FFFF_FIELD_DESC = new org.apache.thrift.protocol.TField("ffff", org.apache.thrift.protocol.TType.STRUCT, (short)3);
    private static final org.apache.thrift.protocol.TField SDF_FIELD_DESC = new org.apache.thrift.protocol.TField("sdf", org.apache.thrift.protocol.TType.STRUCT, (short)4);

    private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
    static {
      schemes.put(StandardScheme.class, new requestImageVersionUpload_resultStandardSchemeFactory());
      schemes.put(TupleScheme.class, new requestImageVersionUpload_resultTupleSchemeFactory());
    }

    public TransferInformation success; // required
    public TTransferRejectedException rejection; // required
    public TAuthorizationException authError; // required
    public TInternalServerError ffff; // required
    public TNotFoundException sdf; // required

    /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
    public enum _Fields implements org.apache.thrift.TFieldIdEnum {
      SUCCESS((short)0, "success"),
      REJECTION((short)1, "rejection"),
      AUTH_ERROR((short)2, "authError"),
      FFFF((short)3, "ffff"),
      SDF((short)4, "sdf");

      private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();

      static {
        for (_Fields field : EnumSet.allOf(_Fields.class)) {
          byName.put(field.getFieldName(), field);
        }
      }

      /**
       * Find the _Fields constant that matches fieldId, or null if its not found.
       */
      public static _Fields findByThriftId(int fieldId) {
        switch(fieldId) {
          case 0: // SUCCESS
            return SUCCESS;
          case 1: // REJECTION
            return REJECTION;
          case 2: // AUTH_ERROR
            return AUTH_ERROR;
          case 3: // FFFF
            return FFFF;
          case 4: // SDF
            return SDF;
          default:
            return null;
        }
      }

      /**
       * Find the _Fields constant that matches fieldId, throwing an exception
       * if it is not found.
       */
      public static _Fields findByThriftIdOrThrow(int fieldId) {
        _Fields fields = findByThriftId(fieldId);
        if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
        return fields;
      }

      /**
       * Find the _Fields constant that matches name, or null if its not found.
       */
      public static _Fields findByName(String name) {
        return byName.get(name);
      }

      private final short _thriftId;
      private final String _fieldName;

      _Fields(short thriftId, String fieldName) {
        _thriftId = thriftId;
        _fieldName = fieldName;
      }

      public short getThriftFieldId() {
        return _thriftId;
      }

      public String getFieldName() {
        return _fieldName;
      }
    }

    // isset id assignments
    public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
    static {
      Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
      tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, 
          new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TransferInformation.class)));
      tmpMap.put(_Fields.REJECTION, new org.apache.thrift.meta_data.FieldMetaData("rejection", org.apache.thrift.TFieldRequirementType.DEFAULT, 
          new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT)));
      tmpMap.put(_Fields.AUTH_ERROR, new org.apache.thrift.meta_data.FieldMetaData("authError", org.apache.thrift.TFieldRequirementType.DEFAULT, 
          new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT)));
      tmpMap.put(_Fields.FFFF, new org.apache.thrift.meta_data.FieldMetaData("ffff", org.apache.thrift.TFieldRequirementType.DEFAULT, 
          new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT)));
      tmpMap.put(_Fields.SDF, new org.apache.thrift.meta_data.FieldMetaData("sdf", org.apache.thrift.TFieldRequirementType.DEFAULT, 
          new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT)));
      metaDataMap = Collections.unmodifiableMap(tmpMap);
      org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(requestImageVersionUpload_result.class, metaDataMap);
    }

    public requestImageVersionUpload_result() {
    }

    public requestImageVersionUpload_result(
      TransferInformation success,
      TTransferRejectedException rejection,
      TAuthorizationException authError,
      TInternalServerError ffff,
      TNotFoundException sdf)
    {
      this();
      this.success = success;
      this.rejection = rejection;
      this.authError = authError;
      this.ffff = ffff;
      this.sdf = sdf;
    }

    /**
     * Performs a deep copy on <i>other</i>.
     */
    public requestImageVersionUpload_result(requestImageVersionUpload_result other) {
      if (other.isSetSuccess()) {
        this.success = new TransferInformation(other.success);
      }
      if (other.isSetRejection()) {
        this.rejection = new TTransferRejectedException(other.rejection);
      }
      if (other.isSetAuthError()) {
        this.authError = new TAuthorizationException(other.authError);
      }
      if (other.isSetFfff()) {
        this.ffff = new TInternalServerError(other.ffff);
      }
      if (other.isSetSdf()) {
        this.sdf = new TNotFoundException(other.sdf);
      }
    }

    public requestImageVersionUpload_result deepCopy() {
      return new requestImageVersionUpload_result(this);
    }

    @Override
    public void clear() {
      this.success = null;
      this.rejection = null;
      this.authError = null;
      this.ffff = null;
      this.sdf = null;
    }

    public TransferInformation getSuccess() {
      return this.success;
    }

    public requestImageVersionUpload_result setSuccess(TransferInformation success) {
      this.success = success;
      return this;
    }

    public void unsetSuccess() {
      this.success = null;
    }

    /** Returns true if field success is set (has been assigned a value) and false otherwise */
    public boolean isSetSuccess() {
      return this.success != null;
    }

    public void setSuccessIsSet(boolean value) {
      if (!value) {
        this.success = null;
      }
    }

    public TTransferRejectedException getRejection() {
      return this.rejection;
    }

    public requestImageVersionUpload_result setRejection(TTransferRejectedException rejection) {
      this.rejection = rejection;
      return this;
    }

    public void unsetRejection() {
      this.rejection = null;
    }

    /** Returns true if field rejection is set (has been assigned a value) and false otherwise */
    public boolean isSetRejection() {
      return this.rejection != null;
    }

    public void setRejectionIsSet(boolean value) {
      if (!value) {
        this.rejection = null;
      }
    }

    public TAuthorizationException getAuthError() {
      return this.authError;
    }

    public requestImageVersionUpload_result setAuthError(TAuthorizationException authError) {
      this.authError = authError;
      return this;
    }

    public void unsetAuthError() {
      this.authError = null;
    }

    /** Returns true if field authError is set (has been assigned a value) and false otherwise */
    public boolean isSetAuthError() {
      return this.authError != null;
    }

    public void setAuthErrorIsSet(boolean value) {
      if (!value) {
        this.authError = null;
      }
    }

    public TInternalServerError getFfff() {
      return this.ffff;
    }

    public requestImageVersionUpload_result setFfff(TInternalServerError ffff) {
      this.ffff = ffff;
      return this;
    }

    public void unsetFfff() {
      this.ffff = null;
    }

    /** Returns true if field ffff is set (has been assigned a value) and false otherwise */
    public boolean isSetFfff() {
      return this.ffff != null;
    }

    public void setFfffIsSet(boolean value) {
      if (!value) {
        this.ffff = null;
      }
    }

    public TNotFoundException getSdf() {
      return this.sdf;
    }

    public requestImageVersionUpload_result setSdf(TNotFoundException sdf) {
      this.sdf = sdf;
      return this;
    }

    public void unsetSdf() {
      this.sdf = null;
    }

    /** Returns true if field sdf is set (has been assigned a value) and false otherwise */
    public boolean isSetSdf() {
      return this.sdf != null;
    }

    public void setSdfIsSet(boolean value) {
      if (!value) {
        this.sdf = null;
      }
    }

    public void setFieldValue(_Fields field, Object value) {
      switch (field) {
      case SUCCESS:
        if (value == null) {
          unsetSuccess();
        } else {
          setSuccess((TransferInformation)value);
        }
        break;

      case REJECTION:
        if (value == null) {
          unsetRejection();
        } else {
          setRejection((TTransferRejectedException)value);
        }
        break;

      case AUTH_ERROR:
        if (value == null) {
          unsetAuthError();
        } else {
          setAuthError((TAuthorizationException)value);
        }
        break;

      case FFFF:
        if (value == null) {
          unsetFfff();
        } else {
          setFfff((TInternalServerError)value);
        }
        break;

      case SDF:
        if (value == null) {
          unsetSdf();
        } else {
          setSdf((TNotFoundException)value);
        }
        break;

      }
    }

    public Object getFieldValue(_Fields field) {
      switch (field) {
      case SUCCESS:
        return getSuccess();

      case REJECTION:
        return getRejection();

      case AUTH_ERROR:
        return getAuthError();

      case FFFF:
        return getFfff();

      case SDF:
        return getSdf();

      }
      throw new IllegalStateException();
    }

    /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
    public boolean isSet(_Fields field) {
      if (field == null) {
        throw new IllegalArgumentException();
      }

      switch (field) {
      case SUCCESS:
        return isSetSuccess();
      case REJECTION:
        return isSetRejection();
      case AUTH_ERROR:
        return isSetAuthError();
      case FFFF:
        return isSetFfff();
      case SDF:
        return isSetSdf();
      }
      throw new IllegalStateException();
    }

    @Override
    public boolean equals(Object that) {
      if (that == null)
        return false;
      if (that instanceof requestImageVersionUpload_result)
        return this.equals((requestImageVersionUpload_result)that);
      return false;
    }

    public boolean equals(requestImageVersionUpload_result that) {
      if (that == null)
        return false;

      boolean this_present_success = true && this.isSetSuccess();
      boolean that_present_success = true && that.isSetSuccess();
      if (this_present_success || that_present_success) {
        if (!(this_present_success && that_present_success))
          return false;
        if (!this.success.equals(that.success))
          return false;
      }

      boolean this_present_rejection = true && this.isSetRejection();
      boolean that_present_rejection = true && that.isSetRejection();
      if (this_present_rejection || that_present_rejection) {
        if (!(this_present_rejection && that_present_rejection))
          return false;
        if (!this.rejection.equals(that.rejection))
          return false;
      }

      boolean this_present_authError = true && this.isSetAuthError();
      boolean that_present_authError = true && that.isSetAuthError();
      if (this_present_authError || that_present_authError) {
        if (!(this_present_authError && that_present_authError))
          return false;
        if (!this.authError.equals(that.authError))
          return false;
      }

      boolean this_present_ffff = true && this.isSetFfff();
      boolean that_present_ffff = true && that.isSetFfff();
      if (this_present_ffff || that_present_ffff) {
        if (!(this_present_ffff && that_present_ffff))
          return false;
        if (!this.ffff.equals(that.ffff))
          return false;
      }

      boolean this_present_sdf = true && this.isSetSdf();
      boolean that_present_sdf = true && that.isSetSdf();
      if (this_present_sdf || that_present_sdf) {
        if (!(this_present_sdf && that_present_sdf))
          return false;
        if (!this.sdf.equals(that.sdf))
          return false;
      }

      return true;
    }

    @Override
    public int hashCode() {
      return 0;
    }

    @Override
    public int compareTo(requestImageVersionUpload_result other) {
      if (!getClass().equals(other.getClass())) {
        return getClass().getName().compareTo(other.getClass().getName());
      }

      int lastComparison = 0;

      lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(other.isSetSuccess());
      if (lastComparison != 0) {
        return lastComparison;
      }
      if (isSetSuccess()) {
        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, other.success);
        if (lastComparison != 0) {
          return lastComparison;
        }
      }
      lastComparison = Boolean.valueOf(isSetRejection()).compareTo(other.isSetRejection());
      if (lastComparison != 0) {
        return lastComparison;
      }
      if (isSetRejection()) {
        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.rejection, other.rejection);
        if (lastComparison != 0) {
          return lastComparison;
        }
      }
      lastComparison = Boolean.valueOf(isSetAuthError()).compareTo(other.isSetAuthError());
      if (lastComparison != 0) {
        return lastComparison;
      }
      if (isSetAuthError()) {
        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.authError, other.authError);
        if (lastComparison != 0) {
          return lastComparison;
        }
      }
      lastComparison = Boolean.valueOf(isSetFfff()).compareTo(other.isSetFfff());
      if (lastComparison != 0) {
        return lastComparison;
      }
      if (isSetFfff()) {
        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.ffff, other.ffff);
        if (lastComparison != 0) {
          return lastComparison;
        }
      }
      lastComparison = Boolean.valueOf(isSetSdf()).compareTo(other.isSetSdf());
      if (lastComparison != 0) {
        return lastComparison;
      }
      if (isSetSdf()) {
        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.sdf, other.sdf);
        if (lastComparison != 0) {
          return lastComparison;
        }
      }
      return 0;
    }

    public _Fields fieldForId(int fieldId) {
      return _Fields.findByThriftId(fieldId);
    }

    public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
      schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
    }

    public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
      schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
      }

    @Override
    public String toString() {
      StringBuilder sb = new StringBuilder("requestImageVersionUpload_result(");
      boolean first = true;

      sb.append("success:");
      if (this.success == null) {
        sb.append("null");
      } else {
        sb.append(this.success);
      }
      first = false;
      if (!first) sb.append(", ");
      sb.append("rejection:");
      if (this.rejection == null) {
        sb.append("null");
      } else {
        sb.append(this.rejection);
      }
      first = false;
      if (!first) sb.append(", ");
      sb.append("authError:");
      if (this.authError == null) {
        sb.append("null");
      } else {
        sb.append(this.authError);
      }
      first = false;
      if (!first) sb.append(", ");
      sb.append("ffff:");
      if (this.ffff == null) {
        sb.append("null");
      } else {
        sb.append(this.ffff);
      }
      first = false;
      if (!first) sb.append(", ");
      sb.append("sdf:");
      if (this.sdf == null) {
        sb.append("null");
      } else {
        sb.append(this.sdf);
      }
      first = false;
      sb.append(")");
      return sb.toString();
    }

    public void validate() throws org.apache.thrift.TException {
      // check for required fields
      // check for sub-struct validity
      if (success != null) {
        success.validate();
      }
    }

    private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
      try {
        write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
      } catch (org.apache.thrift.TException te) {
        throw new java.io.IOException(te);
      }
    }

    private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
      try {
        read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
      } catch (org.apache.thrift.TException te) {
        throw new java.io.IOException(te);
      }
    }

    private static class requestImageVersionUpload_resultStandardSchemeFactory implements SchemeFactory {
      public requestImageVersionUpload_resultStandardScheme getScheme() {
        return new requestImageVersionUpload_resultStandardScheme();
      }
    }

    private static class requestImageVersionUpload_resultStandardScheme extends StandardScheme<requestImageVersionUpload_result> {

      public void read(org.apache.thrift.protocol.TProtocol iprot, requestImageVersionUpload_result struct) throws org.apache.thrift.TException {
        org.apache.thrift.protocol.TField schemeField;
        iprot.readStructBegin();
        while (true)
        {
          schemeField = iprot.readFieldBegin();
          if (schemeField.type == org.apache.thrift.protocol.TType.STOP) { 
            break;
          }
          switch (schemeField.id) {
            case 0: // SUCCESS
              if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
                struct.success = new TransferInformation();
                struct.success.read(iprot);
                struct.setSuccessIsSet(true);
              } else { 
                org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
              }
              break;
            case 1: // REJECTION
              if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
                struct.rejection = new TTransferRejectedException();
                struct.rejection.read(iprot);
                struct.setRejectionIsSet(true);
              } else { 
                org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
              }
              break;
            case 2: // AUTH_ERROR
              if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
                struct.authError = new TAuthorizationException();
                struct.authError.read(iprot);
                struct.setAuthErrorIsSet(true);
              } else { 
                org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
              }
              break;
            case 3: // FFFF
              if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
                struct.ffff = new TInternalServerError();
                struct.ffff.read(iprot);
                struct.setFfffIsSet(true);
              } else { 
                org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
              }
              break;
            case 4: // SDF
              if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
                struct.sdf = new TNotFoundException();
                struct.sdf.read(iprot);
                struct.setSdfIsSet(true);
              } else { 
                org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
              }
              break;
            default:
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
          }
          iprot.readFieldEnd();
        }
        iprot.readStructEnd();

        // check for required fields of primitive type, which can't be checked in the validate method
        struct.validate();
      }

      public void write(org.apache.thrift.protocol.TProtocol oprot, requestImageVersionUpload_result struct) throws org.apache.thrift.TException {
        struct.validate();

        oprot.writeStructBegin(STRUCT_DESC);
        if (struct.success != null) {
          oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
          struct.success.write(oprot);
          oprot.writeFieldEnd();
        }
        if (struct.rejection != null) {
          oprot.writeFieldBegin(REJECTION_FIELD_DESC);
          struct.rejection.write(oprot);
          oprot.writeFieldEnd();
        }
        if (struct.authError != null) {
          oprot.writeFieldBegin(AUTH_ERROR_FIELD_DESC);
          struct.authError.write(oprot);
          oprot.writeFieldEnd();
        }
        if (struct.ffff != null) {
          oprot.writeFieldBegin(FFFF_FIELD_DESC);
          struct.ffff.write(oprot);
          oprot.writeFieldEnd();
        }
        if (struct.sdf != null) {
          oprot.writeFieldBegin(SDF_FIELD_DESC);
          struct.sdf.write(oprot);
          oprot.writeFieldEnd();
        }
        oprot.writeFieldStop();
        oprot.writeStructEnd();
      }

    }

    private static class requestImageVersionUpload_resultTupleSchemeFactory implements SchemeFactory {
      public requestImageVersionUpload_resultTupleScheme getScheme() {
        return new requestImageVersionUpload_resultTupleScheme();
      }
    }

    private static class requestImageVersionUpload_resultTupleScheme extends TupleScheme<requestImageVersionUpload_result> {

      @Override
      public void write(org.apache.thrift.protocol.TProtocol prot, requestImageVersionUpload_result struct) throws org.apache.thrift.TException {
        TTupleProtocol oprot = (TTupleProtocol) prot;
        BitSet optionals = new BitSet();
        if (struct.isSetSuccess()) {
          optionals.set(0);
        }
        if (struct.isSetRejection()) {
          optionals.set(1);
        }
        if (struct.isSetAuthError()) {
          optionals.set(2);
        }
        if (struct.isSetFfff()) {
          optionals.set(3);
        }
        if (struct.isSetSdf()) {
          optionals.set(4);
        }
        oprot.writeBitSet(optionals, 5);
        if (struct.isSetSuccess()) {
          struct.success.write(oprot);
        }
        if (struct.isSetRejection()) {
          struct.rejection.write(oprot);
        }
        if (struct.isSetAuthError()) {
          struct.authError.write(oprot);
        }
        if (struct.isSetFfff()) {
          struct.ffff.write(oprot);
        }
        if (struct.isSetSdf()) {
          struct.sdf.write(oprot);
        }
      }

      @Override
      public void read(org.apache.thrift.protocol.TProtocol prot, requestImageVersionUpload_result struct) throws org.apache.thrift.TException {
        TTupleProtocol iprot = (TTupleProtocol) prot;
        BitSet incoming = iprot.readBitSet(5);
        if (incoming.get(0)) {
          struct.success = new TransferInformation();
          struct.success.read(iprot);
          struct.setSuccessIsSet(true);
        }
        if (incoming.get(1)) {
          struct.rejection = new TTransferRejectedException();
          struct.rejection.read(iprot);
          struct.setRejectionIsSet(true);
        }
        if (incoming.get(2)) {
          struct.authError = new TAuthorizationException();
          struct.authError.read(iprot);
          struct.setAuthErrorIsSet(true);
        }
        if (incoming.get(3)) {
          struct.ffff = new TInternalServerError();
          struct.ffff.read(iprot);
          struct.setFfffIsSet(true);
        }
        if (incoming.get(4)) {
          struct.sdf = new TNotFoundException();
          struct.sdf.read(iprot);
          struct.setSdfIsSet(true);
        }
      }
    }

  }

  public static class cancelUpload_args implements org.apache.thrift.TBase<cancelUpload_args, cancelUpload_args._Fields>, java.io.Serializable, Cloneable, Comparable<cancelUpload_args>   {
    private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("cancelUpload_args");

    private static final org.apache.thrift.protocol.TField UPLOAD_TOKEN_FIELD_DESC = new org.apache.thrift.protocol.TField("uploadToken", org.apache.thrift.protocol.TType.STRING, (short)1);

    private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
    static {
      schemes.put(StandardScheme.class, new cancelUpload_argsStandardSchemeFactory());
      schemes.put(TupleScheme.class, new cancelUpload_argsTupleSchemeFactory());
    }

    public String uploadToken; // required

    /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
    public enum _Fields implements org.apache.thrift.TFieldIdEnum {
      UPLOAD_TOKEN((short)1, "uploadToken");

      private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();

      static {
        for (_Fields field : EnumSet.allOf(_Fields.class)) {
          byName.put(field.getFieldName(), field);
        }
      }

      /**
       * Find the _Fields constant that matches fieldId, or null if its not found.
       */
      public static _Fields findByThriftId(int fieldId) {
        switch(fieldId) {
          case 1: // UPLOAD_TOKEN
            return UPLOAD_TOKEN;
          default:
            return null;
        }
      }

      /**
       * Find the _Fields constant that matches fieldId, throwing an exception
       * if it is not found.
       */
      public static _Fields findByThriftIdOrThrow(int fieldId) {
        _Fields fields = findByThriftId(fieldId);
        if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
        return fields;
      }

      /**
       * Find the _Fields constant that matches name, or null if its not found.
       */
      public static _Fields findByName(String name) {
        return byName.get(name);
      }

      private final short _thriftId;
      private final String _fieldName;

      _Fields(short thriftId, String fieldName) {
        _thriftId = thriftId;
        _fieldName = fieldName;
      }

      public short getThriftFieldId() {
        return _thriftId;
      }

      public String getFieldName() {
        return _fieldName;
      }
    }

    // isset id assignments
    public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
    static {
      Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
      tmpMap.put(_Fields.UPLOAD_TOKEN, new org.apache.thrift.meta_data.FieldMetaData("uploadToken", org.apache.thrift.TFieldRequirementType.DEFAULT, 
          new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING          , "Token")));
      metaDataMap = Collections.unmodifiableMap(tmpMap);
      org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(cancelUpload_args.class, metaDataMap);
    }

    public cancelUpload_args() {
    }

    public cancelUpload_args(
      String uploadToken)
    {
      this();
      this.uploadToken = uploadToken;
    }

    /**
     * Performs a deep copy on <i>other</i>.
     */
    public cancelUpload_args(cancelUpload_args other) {
      if (other.isSetUploadToken()) {
        this.uploadToken = other.uploadToken;
      }
    }

    public cancelUpload_args deepCopy() {
      return new cancelUpload_args(this);
    }

    @Override
    public void clear() {
      this.uploadToken = null;
    }

    public String getUploadToken() {
      return this.uploadToken;
    }

    public cancelUpload_args setUploadToken(String uploadToken) {
      this.uploadToken = uploadToken;
      return this;
    }

    public void unsetUploadToken() {
      this.uploadToken = null;
    }

    /** Returns true if field uploadToken is set (has been assigned a value) and false otherwise */
    public boolean isSetUploadToken() {
      return this.uploadToken != null;
    }

    public void setUploadTokenIsSet(boolean value) {
      if (!value) {
        this.uploadToken = null;
      }
    }

    public void setFieldValue(_Fields field, Object value) {
      switch (field) {
      case UPLOAD_TOKEN:
        if (value == null) {
          unsetUploadToken();
        } else {
          setUploadToken((String)value);
        }
        break;

      }
    }

    public Object getFieldValue(_Fields field) {
      switch (field) {
      case UPLOAD_TOKEN:
        return getUploadToken();

      }
      throw new IllegalStateException();
    }

    /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
    public boolean isSet(_Fields field) {
      if (field == null) {
        throw new IllegalArgumentException();
      }

      switch (field) {
      case UPLOAD_TOKEN:
        return isSetUploadToken();
      }
      throw new IllegalStateException();
    }

    @Override
    public boolean equals(Object that) {
      if (that == null)
        return false;
      if (that instanceof cancelUpload_args)
        return this.equals((cancelUpload_args)that);
      return false;
    }

    public boolean equals(cancelUpload_args that) {
      if (that == null)
        return false;

      boolean this_present_uploadToken = true && this.isSetUploadToken();
      boolean that_present_uploadToken = true && that.isSetUploadToken();
      if (this_present_uploadToken || that_present_uploadToken) {
        if (!(this_present_uploadToken && that_present_uploadToken))
          return false;
        if (!this.uploadToken.equals(that.uploadToken))
          return false;
      }

      return true;
    }

    @Override
    public int hashCode() {
      return 0;
    }

    @Override
    public int compareTo(cancelUpload_args other) {
      if (!getClass().equals(other.getClass())) {
        return getClass().getName().compareTo(other.getClass().getName());
      }

      int lastComparison = 0;

      lastComparison = Boolean.valueOf(isSetUploadToken()).compareTo(other.isSetUploadToken());
      if (lastComparison != 0) {
        return lastComparison;
      }
      if (isSetUploadToken()) {
        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.uploadToken, other.uploadToken);
        if (lastComparison != 0) {
          return lastComparison;
        }
      }
      return 0;
    }

    public _Fields fieldForId(int fieldId) {
      return _Fields.findByThriftId(fieldId);
    }

    public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
      schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
    }

    public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
      schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
    }

    @Override
    public String toString() {
      StringBuilder sb = new StringBuilder("cancelUpload_args(");
      boolean first = true;

      sb.append("uploadToken:");
      if (this.uploadToken == null) {
        sb.append("null");
      } else {
        sb.append(this.uploadToken);
      }
      first = false;
      sb.append(")");
      return sb.toString();
    }

    public void validate() throws org.apache.thrift.TException {
      // check for required fields
      // check for sub-struct validity
    }

    private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
      try {
        write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
      } catch (org.apache.thrift.TException te) {
        throw new java.io.IOException(te);
      }
    }

    private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
      try {
        read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
      } catch (org.apache.thrift.TException te) {
        throw new java.io.IOException(te);
      }
    }

    private static class cancelUpload_argsStandardSchemeFactory implements SchemeFactory {
      public cancelUpload_argsStandardScheme getScheme() {
        return new cancelUpload_argsStandardScheme();
      }
    }

    private static class cancelUpload_argsStandardScheme extends StandardScheme<cancelUpload_args> {

      public void read(org.apache.thrift.protocol.TProtocol iprot, cancelUpload_args struct) throws org.apache.thrift.TException {
        org.apache.thrift.protocol.TField schemeField;
        iprot.readStructBegin();
        while (true)
        {
          schemeField = iprot.readFieldBegin();
          if (schemeField.type == org.apache.thrift.protocol.TType.STOP) { 
            break;
          }
          switch (schemeField.id) {
            case 1: // UPLOAD_TOKEN
              if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
                struct.uploadToken = iprot.readString();
                struct.setUploadTokenIsSet(true);
              } else { 
                org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
              }
              break;
            default:
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
          }
          iprot.readFieldEnd();
        }
        iprot.readStructEnd();

        // check for required fields of primitive type, which can't be checked in the validate method
        struct.validate();
      }

      public void write(org.apache.thrift.protocol.TProtocol oprot, cancelUpload_args struct) throws org.apache.thrift.TException {
        struct.validate();

        oprot.writeStructBegin(STRUCT_DESC);
        if (struct.uploadToken != null) {
          oprot.writeFieldBegin(UPLOAD_TOKEN_FIELD_DESC);
          oprot.writeString(struct.uploadToken);
          oprot.writeFieldEnd();
        }
        oprot.writeFieldStop();
        oprot.writeStructEnd();
      }

    }

    private static class cancelUpload_argsTupleSchemeFactory implements SchemeFactory {
      public cancelUpload_argsTupleScheme getScheme() {
        return new cancelUpload_argsTupleScheme();
      }
    }

    private static class cancelUpload_argsTupleScheme extends TupleScheme<cancelUpload_args> {

      @Override
      public void write(org.apache.thrift.protocol.TProtocol prot, cancelUpload_args struct) throws org.apache.thrift.TException {
        TTupleProtocol oprot = (TTupleProtocol) prot;
        BitSet optionals = new BitSet();
        if (struct.isSetUploadToken()) {
          optionals.set(0);
        }
        oprot.writeBitSet(optionals, 1);
        if (struct.isSetUploadToken()) {
          oprot.writeString(struct.uploadToken);
        }
      }

      @Override
      public void read(org.apache.thrift.protocol.TProtocol prot, cancelUpload_args struct) throws org.apache.thrift.TException {
        TTupleProtocol iprot = (TTupleProtocol) prot;
        BitSet incoming = iprot.readBitSet(1);
        if (incoming.get(0)) {
          struct.uploadToken = iprot.readString();
          struct.setUploadTokenIsSet(true);
        }
      }
    }

  }

  public static class cancelUpload_result implements org.apache.thrift.TBase<cancelUpload_result, cancelUpload_result._Fields>, java.io.Serializable, Cloneable, Comparable<cancelUpload_result>   {
    private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("cancelUpload_result");

    private static final org.apache.thrift.protocol.TField EX1_FIELD_DESC = new org.apache.thrift.protocol.TField("ex1", org.apache.thrift.protocol.TType.STRUCT, (short)1);

    private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
    static {
      schemes.put(StandardScheme.class, new cancelUpload_resultStandardSchemeFactory());
      schemes.put(TupleScheme.class, new cancelUpload_resultTupleSchemeFactory());
    }

    public TInvalidTokenException ex1; // required

    /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
    public enum _Fields implements org.apache.thrift.TFieldIdEnum {
      EX1((short)1, "ex1");

      private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();

      static {
        for (_Fields field : EnumSet.allOf(_Fields.class)) {
          byName.put(field.getFieldName(), field);
        }
      }

      /**
       * Find the _Fields constant that matches fieldId, or null if its not found.
       */
      public static _Fields findByThriftId(int fieldId) {
        switch(fieldId) {
          case 1: // EX1
            return EX1;
          default:
            return null;
        }
      }

      /**
       * Find the _Fields constant that matches fieldId, throwing an exception
       * if it is not found.
       */
      public static _Fields findByThriftIdOrThrow(int fieldId) {
        _Fields fields = findByThriftId(fieldId);
        if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
        return fields;
      }

      /**
       * Find the _Fields constant that matches name, or null if its not found.
       */
      public static _Fields findByName(String name) {
        return byName.get(name);
      }

      private final short _thriftId;
      private final String _fieldName;

      _Fields(short thriftId, String fieldName) {
        _thriftId = thriftId;
        _fieldName = fieldName;
      }

      public short getThriftFieldId() {
        return _thriftId;
      }

      public String getFieldName() {
        return _fieldName;
      }
    }

    // isset id assignments
    public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
    static {
      Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
      tmpMap.put(_Fields.EX1, new org.apache.thrift.meta_data.FieldMetaData("ex1", org.apache.thrift.TFieldRequirementType.DEFAULT, 
          new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT)));
      metaDataMap = Collections.unmodifiableMap(tmpMap);
      org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(cancelUpload_result.class, metaDataMap);
    }

    public cancelUpload_result() {
    }

    public cancelUpload_result(
      TInvalidTokenException ex1)
    {
      this();
      this.ex1 = ex1;
    }

    /**
     * Performs a deep copy on <i>other</i>.
     */
    public cancelUpload_result(cancelUpload_result other) {
      if (other.isSetEx1()) {
        this.ex1 = new TInvalidTokenException(other.ex1);
      }
    }

    public cancelUpload_result deepCopy() {
      return new cancelUpload_result(this);
    }

    @Override
    public void clear() {
      this.ex1 = null;
    }

    public TInvalidTokenException getEx1() {
      return this.ex1;
    }

    public cancelUpload_result setEx1(TInvalidTokenException ex1) {
      this.ex1 = ex1;
      return this;
    }

    public void unsetEx1() {
      this.ex1 = null;
    }

    /** Returns true if field ex1 is set (has been assigned a value) and false otherwise */
    public boolean isSetEx1() {
      return this.ex1 != null;
    }

    public void setEx1IsSet(boolean value) {
      if (!value) {
        this.ex1 = null;
      }
    }

    public void setFieldValue(_Fields field, Object value) {
      switch (field) {
      case EX1:
        if (value == null) {
          unsetEx1();
        } else {
          setEx1((TInvalidTokenException)value);
        }
        break;

      }
    }

    public Object getFieldValue(_Fields field) {
      switch (field) {
      case EX1:
        return getEx1();

      }
      throw new IllegalStateException();
    }

    /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
    public boolean isSet(_Fields field) {
      if (field == null) {
        throw new IllegalArgumentException();
      }

      switch (field) {
      case EX1:
        return isSetEx1();
      }
      throw new IllegalStateException();
    }

    @Override
    public boolean equals(Object that) {
      if (that == null)
        return false;
      if (that instanceof cancelUpload_result)
        return this.equals((cancelUpload_result)that);
      return false;
    }

    public boolean equals(cancelUpload_result that) {
      if (that == null)
        return false;

      boolean this_present_ex1 = true && this.isSetEx1();
      boolean that_present_ex1 = true && that.isSetEx1();
      if (this_present_ex1 || that_present_ex1) {
        if (!(this_present_ex1 && that_present_ex1))
          return false;
        if (!this.ex1.equals(that.ex1))
          return false;
      }

      return true;
    }

    @Override
    public int hashCode() {
      return 0;
    }

    @Override
    public int compareTo(cancelUpload_result other) {
      if (!getClass().equals(other.getClass())) {
        return getClass().getName().compareTo(other.getClass().getName());
      }

      int lastComparison = 0;

      lastComparison = Boolean.valueOf(isSetEx1()).compareTo(other.isSetEx1());
      if (lastComparison != 0) {
        return lastComparison;
      }
      if (isSetEx1()) {
        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.ex1, other.ex1);
        if (lastComparison != 0) {
          return lastComparison;
        }
      }
      return 0;
    }

    public _Fields fieldForId(int fieldId) {
      return _Fields.findByThriftId(fieldId);
    }

    public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
      schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
    }

    public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
      schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
      }

    @Override
    public String toString() {
      StringBuilder sb = new StringBuilder("cancelUpload_result(");
      boolean first = true;

      sb.append("ex1:");
      if (this.ex1 == null) {
        sb.append("null");
      } else {
        sb.append(this.ex1);
      }
      first = false;
      sb.append(")");
      return sb.toString();
    }

    public void validate() throws org.apache.thrift.TException {
      // check for required fields
      // check for sub-struct validity
    }

    private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
      try {
        write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
      } catch (org.apache.thrift.TException te) {
        throw new java.io.IOException(te);
      }
    }

    private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
      try {
        read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
      } catch (org.apache.thrift.TException te) {
        throw new java.io.IOException(te);
      }
    }

    private static class cancelUpload_resultStandardSchemeFactory implements SchemeFactory {
      public cancelUpload_resultStandardScheme getScheme() {
        return new cancelUpload_resultStandardScheme();
      }
    }

    private static class cancelUpload_resultStandardScheme extends StandardScheme<cancelUpload_result> {

      public void read(org.apache.thrift.protocol.TProtocol iprot, cancelUpload_result struct) throws org.apache.thrift.TException {
        org.apache.thrift.protocol.TField schemeField;
        iprot.readStructBegin();
        while (true)
        {
          schemeField = iprot.readFieldBegin();
          if (schemeField.type == org.apache.thrift.protocol.TType.STOP) { 
            break;
          }
          switch (schemeField.id) {
            case 1: // EX1
              if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
                struct.ex1 = new TInvalidTokenException();
                struct.ex1.read(iprot);
                struct.setEx1IsSet(true);
              } else { 
                org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
              }
              break;
            default:
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
          }
          iprot.readFieldEnd();
        }
        iprot.readStructEnd();

        // check for required fields of primitive type, which can't be checked in the validate method
        struct.validate();
      }

      public void write(org.apache.thrift.protocol.TProtocol oprot, cancelUpload_result struct) throws org.apache.thrift.TException {
        struct.validate();

        oprot.writeStructBegin(STRUCT_DESC);
        if (struct.ex1 != null) {
          oprot.writeFieldBegin(EX1_FIELD_DESC);
          struct.ex1.write(oprot);
          oprot.writeFieldEnd();
        }
        oprot.writeFieldStop();
        oprot.writeStructEnd();
      }

    }

    private static class cancelUpload_resultTupleSchemeFactory implements SchemeFactory {
      public cancelUpload_resultTupleScheme getScheme() {
        return new cancelUpload_resultTupleScheme();
      }
    }

    private static class cancelUpload_resultTupleScheme extends TupleScheme<cancelUpload_result> {

      @Override
      public void write(org.apache.thrift.protocol.TProtocol prot, cancelUpload_result struct) throws org.apache.thrift.TException {
        TTupleProtocol oprot = (TTupleProtocol) prot;
        BitSet optionals = new BitSet();
        if (struct.isSetEx1()) {
          optionals.set(0);
        }
        oprot.writeBitSet(optionals, 1);
        if (struct.isSetEx1()) {
          struct.ex1.write(oprot);
        }
      }

      @Override
      public void read(org.apache.thrift.protocol.TProtocol prot, cancelUpload_result struct) throws org.apache.thrift.TException {
        TTupleProtocol iprot = (TTupleProtocol) prot;
        BitSet incoming = iprot.readBitSet(1);
        if (incoming.get(0)) {
          struct.ex1 = new TInvalidTokenException();
          struct.ex1.read(iprot);
          struct.setEx1IsSet(true);
        }
      }
    }

  }

  public static class queryUploadStatus_args implements org.apache.thrift.TBase<queryUploadStatus_args, queryUploadStatus_args._Fields>, java.io.Serializable, Cloneable, Comparable<queryUploadStatus_args>   {
    private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("queryUploadStatus_args");

    private static final org.apache.thrift.protocol.TField UPLOAD_TOKEN_FIELD_DESC = new org.apache.thrift.protocol.TField("uploadToken", org.apache.thrift.protocol.TType.STRING, (short)1);

    private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
    static {
      schemes.put(StandardScheme.class, new queryUploadStatus_argsStandardSchemeFactory());
      schemes.put(TupleScheme.class, new queryUploadStatus_argsTupleSchemeFactory());
    }

    public String uploadToken; // required

    /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
    public enum _Fields implements org.apache.thrift.TFieldIdEnum {
      UPLOAD_TOKEN((short)1, "uploadToken");

      private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();

      static {
        for (_Fields field : EnumSet.allOf(_Fields.class)) {
          byName.put(field.getFieldName(), field);
        }
      }

      /**
       * Find the _Fields constant that matches fieldId, or null if its not found.
       */
      public static _Fields findByThriftId(int fieldId) {
        switch(fieldId) {
          case 1: // UPLOAD_TOKEN
            return UPLOAD_TOKEN;
          default:
            return null;
        }
      }

      /**
       * Find the _Fields constant that matches fieldId, throwing an exception
       * if it is not found.
       */
      public static _Fields findByThriftIdOrThrow(int fieldId) {
        _Fields fields = findByThriftId(fieldId);
        if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
        return fields;
      }

      /**
       * Find the _Fields constant that matches name, or null if its not found.
       */
      public static _Fields findByName(String name) {
        return byName.get(name);
      }

      private final short _thriftId;
      private final String _fieldName;

      _Fields(short thriftId, String fieldName) {
        _thriftId = thriftId;
        _fieldName = fieldName;
      }

      public short getThriftFieldId() {
        return _thriftId;
      }

      public String getFieldName() {
        return _fieldName;
      }
    }

    // isset id assignments
    public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
    static {
      Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
      tmpMap.put(_Fields.UPLOAD_TOKEN, new org.apache.thrift.meta_data.FieldMetaData("uploadToken", org.apache.thrift.TFieldRequirementType.DEFAULT, 
          new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING          , "Token")));
      metaDataMap = Collections.unmodifiableMap(tmpMap);
      org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(queryUploadStatus_args.class, metaDataMap);
    }

    public queryUploadStatus_args() {
    }

    public queryUploadStatus_args(
      String uploadToken)
    {
      this();
      this.uploadToken = uploadToken;
    }

    /**
     * Performs a deep copy on <i>other</i>.
     */
    public queryUploadStatus_args(queryUploadStatus_args other) {
      if (other.isSetUploadToken()) {
        this.uploadToken = other.uploadToken;
      }
    }

    public queryUploadStatus_args deepCopy() {
      return new queryUploadStatus_args(this);
    }

    @Override
    public void clear() {
      this.uploadToken = null;
    }

    public String getUploadToken() {
      return this.uploadToken;
    }

    public queryUploadStatus_args setUploadToken(String uploadToken) {
      this.uploadToken = uploadToken;
      return this;
    }

    public void unsetUploadToken() {
      this.uploadToken = null;
    }

    /** Returns true if field uploadToken is set (has been assigned a value) and false otherwise */
    public boolean isSetUploadToken() {
      return this.uploadToken != null;
    }

    public void setUploadTokenIsSet(boolean value) {
      if (!value) {
        this.uploadToken = null;
      }
    }

    public void setFieldValue(_Fields field, Object value) {
      switch (field) {
      case UPLOAD_TOKEN:
        if (value == null) {
          unsetUploadToken();
        } else {
          setUploadToken((String)value);
        }
        break;

      }
    }

    public Object getFieldValue(_Fields field) {
      switch (field) {
      case UPLOAD_TOKEN:
        return getUploadToken();

      }
      throw new IllegalStateException();
    }

    /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
    public boolean isSet(_Fields field) {
      if (field == null) {
        throw new IllegalArgumentException();
      }

      switch (field) {
      case UPLOAD_TOKEN:
        return isSetUploadToken();
      }
      throw new IllegalStateException();
    }

    @Override
    public boolean equals(Object that) {
      if (that == null)
        return false;
      if (that instanceof queryUploadStatus_args)
        return this.equals((queryUploadStatus_args)that);
      return false;
    }

    public boolean equals(queryUploadStatus_args that) {
      if (that == null)
        return false;

      boolean this_present_uploadToken = true && this.isSetUploadToken();
      boolean that_present_uploadToken = true && that.isSetUploadToken();
      if (this_present_uploadToken || that_present_uploadToken) {
        if (!(this_present_uploadToken && that_present_uploadToken))
          return false;
        if (!this.uploadToken.equals(that.uploadToken))
          return false;
      }

      return true;
    }

    @Override
    public int hashCode() {
      return 0;
    }

    @Override
    public int compareTo(queryUploadStatus_args other) {
      if (!getClass().equals(other.getClass())) {
        return getClass().getName().compareTo(other.getClass().getName());
      }

      int lastComparison = 0;

      lastComparison = Boolean.valueOf(isSetUploadToken()).compareTo(other.isSetUploadToken());
      if (lastComparison != 0) {
        return lastComparison;
      }
      if (isSetUploadToken()) {
        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.uploadToken, other.uploadToken);
        if (lastComparison != 0) {
          return lastComparison;
        }
      }
      return 0;
    }

    public _Fields fieldForId(int fieldId) {
      return _Fields.findByThriftId(fieldId);
    }

    public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
      schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
    }

    public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
      schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
    }

    @Override
    public String toString() {
      StringBuilder sb = new StringBuilder("queryUploadStatus_args(");
      boolean first = true;

      sb.append("uploadToken:");
      if (this.uploadToken == null) {
        sb.append("null");
      } else {
        sb.append(this.uploadToken);
      }
      first = false;
      sb.append(")");
      return sb.toString();
    }

    public void validate() throws org.apache.thrift.TException {
      // check for required fields
      // check for sub-struct validity
    }

    private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
      try {
        write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
      } catch (org.apache.thrift.TException te) {
        throw new java.io.IOException(te);
      }
    }

    private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
      try {
        read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
      } catch (org.apache.thrift.TException te) {
        throw new java.io.IOException(te);
      }
    }

    private static class queryUploadStatus_argsStandardSchemeFactory implements SchemeFactory {
      public queryUploadStatus_argsStandardScheme getScheme() {
        return new queryUploadStatus_argsStandardScheme();
      }
    }

    private static class queryUploadStatus_argsStandardScheme extends StandardScheme<queryUploadStatus_args> {

      public void read(org.apache.thrift.protocol.TProtocol iprot, queryUploadStatus_args struct) throws org.apache.thrift.TException {
        org.apache.thrift.protocol.TField schemeField;
        iprot.readStructBegin();
        while (true)
        {
          schemeField = iprot.readFieldBegin();
          if (schemeField.type == org.apache.thrift.protocol.TType.STOP) { 
            break;
          }
          switch (schemeField.id) {
            case 1: // UPLOAD_TOKEN
              if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
                struct.uploadToken = iprot.readString();
                struct.setUploadTokenIsSet(true);
              } else { 
                org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
              }
              break;
            default:
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
          }
          iprot.readFieldEnd();
        }
        iprot.readStructEnd();

        // check for required fields of primitive type, which can't be checked in the validate method
        struct.validate();
      }

      public void write(org.apache.thrift.protocol.TProtocol oprot, queryUploadStatus_args struct) throws org.apache.thrift.TException {
        struct.validate();

        oprot.writeStructBegin(STRUCT_DESC);
        if (struct.uploadToken != null) {
          oprot.writeFieldBegin(UPLOAD_TOKEN_FIELD_DESC);
          oprot.writeString(struct.uploadToken);
          oprot.writeFieldEnd();
        }
        oprot.writeFieldStop();
        oprot.writeStructEnd();
      }

    }

    private static class queryUploadStatus_argsTupleSchemeFactory implements SchemeFactory {
      public queryUploadStatus_argsTupleScheme getScheme() {
        return new queryUploadStatus_argsTupleScheme();
      }
    }

    private static class queryUploadStatus_argsTupleScheme extends TupleScheme<queryUploadStatus_args> {

      @Override
      public void write(org.apache.thrift.protocol.TProtocol prot, queryUploadStatus_args struct) throws org.apache.thrift.TException {
        TTupleProtocol oprot = (TTupleProtocol) prot;
        BitSet optionals = new BitSet();
        if (struct.isSetUploadToken()) {
          optionals.set(0);
        }
        oprot.writeBitSet(optionals, 1);
        if (struct.isSetUploadToken()) {
          oprot.writeString(struct.uploadToken);
        }
      }

      @Override
      public void read(org.apache.thrift.protocol.TProtocol prot, queryUploadStatus_args struct) throws org.apache.thrift.TException {
        TTupleProtocol iprot = (TTupleProtocol) prot;
        BitSet incoming = iprot.readBitSet(1);
        if (incoming.get(0)) {
          struct.uploadToken = iprot.readString();
          struct.setUploadTokenIsSet(true);
        }
      }
    }

  }

  public static class queryUploadStatus_result implements org.apache.thrift.TBase<queryUploadStatus_result, queryUploadStatus_result._Fields>, java.io.Serializable, Cloneable, Comparable<queryUploadStatus_result>   {
    private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("queryUploadStatus_result");

    private static final org.apache.thrift.protocol.TField SUCCESS_FIELD_DESC = new org.apache.thrift.protocol.TField("success", org.apache.thrift.protocol.TType.STRUCT, (short)0);
    private static final org.apache.thrift.protocol.TField EX1_FIELD_DESC = new org.apache.thrift.protocol.TField("ex1", org.apache.thrift.protocol.TType.STRUCT, (short)1);

    private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
    static {
      schemes.put(StandardScheme.class, new queryUploadStatus_resultStandardSchemeFactory());
      schemes.put(TupleScheme.class, new queryUploadStatus_resultTupleSchemeFactory());
    }

    public TransferStatus success; // required
    public TInvalidTokenException ex1; // required

    /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
    public enum _Fields implements org.apache.thrift.TFieldIdEnum {
      SUCCESS((short)0, "success"),
      EX1((short)1, "ex1");

      private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();

      static {
        for (_Fields field : EnumSet.allOf(_Fields.class)) {
          byName.put(field.getFieldName(), field);
        }
      }

      /**
       * Find the _Fields constant that matches fieldId, or null if its not found.
       */
      public static _Fields findByThriftId(int fieldId) {
        switch(fieldId) {
          case 0: // SUCCESS
            return SUCCESS;
          case 1: // EX1
            return EX1;
          default:
            return null;
        }
      }

      /**
       * Find the _Fields constant that matches fieldId, throwing an exception
       * if it is not found.
       */
      public static _Fields findByThriftIdOrThrow(int fieldId) {
        _Fields fields = findByThriftId(fieldId);
        if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
        return fields;
      }

      /**
       * Find the _Fields constant that matches name, or null if its not found.
       */
      public static _Fields findByName(String name) {
        return byName.get(name);
      }

      private final short _thriftId;
      private final String _fieldName;

      _Fields(short thriftId, String fieldName) {
        _thriftId = thriftId;
        _fieldName = fieldName;
      }

      public short getThriftFieldId() {
        return _thriftId;
      }

      public String getFieldName() {
        return _fieldName;
      }
    }

    // isset id assignments
    public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
    static {
      Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
      tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, 
          new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TransferStatus.class)));
      tmpMap.put(_Fields.EX1, new org.apache.thrift.meta_data.FieldMetaData("ex1", org.apache.thrift.TFieldRequirementType.DEFAULT, 
          new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT)));
      metaDataMap = Collections.unmodifiableMap(tmpMap);
      org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(queryUploadStatus_result.class, metaDataMap);
    }

    public queryUploadStatus_result() {
    }

    public queryUploadStatus_result(
      TransferStatus success,
      TInvalidTokenException ex1)
    {
      this();
      this.success = success;
      this.ex1 = ex1;
    }

    /**
     * Performs a deep copy on <i>other</i>.
     */
    public queryUploadStatus_result(queryUploadStatus_result other) {
      if (other.isSetSuccess()) {
        this.success = new TransferStatus(other.success);
      }
      if (other.isSetEx1()) {
        this.ex1 = new TInvalidTokenException(other.ex1);
      }
    }

    public queryUploadStatus_result deepCopy() {
      return new queryUploadStatus_result(this);
    }

    @Override
    public void clear() {
      this.success = null;
      this.ex1 = null;
    }

    public TransferStatus getSuccess() {
      return this.success;
    }

    public queryUploadStatus_result setSuccess(TransferStatus success) {
      this.success = success;
      return this;
    }

    public void unsetSuccess() {
      this.success = null;
    }

    /** Returns true if field success is set (has been assigned a value) and false otherwise */
    public boolean isSetSuccess() {
      return this.success != null;
    }

    public void setSuccessIsSet(boolean value) {
      if (!value) {
        this.success = null;
      }
    }

    public TInvalidTokenException getEx1() {
      return this.ex1;
    }

    public queryUploadStatus_result setEx1(TInvalidTokenException ex1) {
      this.ex1 = ex1;
      return this;
    }

    public void unsetEx1() {
      this.ex1 = null;
    }

    /** Returns true if field ex1 is set (has been assigned a value) and false otherwise */
    public boolean isSetEx1() {
      return this.ex1 != null;
    }

    public void setEx1IsSet(boolean value) {
      if (!value) {
        this.ex1 = null;
      }
    }

    public void setFieldValue(_Fields field, Object value) {
      switch (field) {
      case SUCCESS:
        if (value == null) {
          unsetSuccess();
        } else {
          setSuccess((TransferStatus)value);
        }
        break;

      case EX1:
        if (value == null) {
          unsetEx1();
        } else {
          setEx1((TInvalidTokenException)value);
        }
        break;

      }
    }

    public Object getFieldValue(_Fields field) {
      switch (field) {
      case SUCCESS:
        return getSuccess();

      case EX1:
        return getEx1();

      }
      throw new IllegalStateException();
    }

    /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
    public boolean isSet(_Fields field) {
      if (field == null) {
        throw new IllegalArgumentException();
      }

      switch (field) {
      case SUCCESS:
        return isSetSuccess();
      case EX1:
        return isSetEx1();
      }
      throw new IllegalStateException();
    }

    @Override
    public boolean equals(Object that) {
      if (that == null)
        return false;
      if (that instanceof queryUploadStatus_result)
        return this.equals((queryUploadStatus_result)that);
      return false;
    }

    public boolean equals(queryUploadStatus_result that) {
      if (that == null)
        return false;

      boolean this_present_success = true && this.isSetSuccess();
      boolean that_present_success = true && that.isSetSuccess();
      if (this_present_success || that_present_success) {
        if (!(this_present_success && that_present_success))
          return false;
        if (!this.success.equals(that.success))
          return false;
      }

      boolean this_present_ex1 = true && this.isSetEx1();
      boolean that_present_ex1 = true && that.isSetEx1();
      if (this_present_ex1 || that_present_ex1) {
        if (!(this_present_ex1 && that_present_ex1))
          return false;
        if (!this.ex1.equals(that.ex1))
          return false;
      }

      return true;
    }

    @Override
    public int hashCode() {
      return 0;
    }

    @Override
    public int compareTo(queryUploadStatus_result other) {
      if (!getClass().equals(other.getClass())) {
        return getClass().getName().compareTo(other.getClass().getName());
      }

      int lastComparison = 0;

      lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(other.isSetSuccess());
      if (lastComparison != 0) {
        return lastComparison;
      }
      if (isSetSuccess()) {
        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, other.success);
        if (lastComparison != 0) {
          return lastComparison;
        }
      }
      lastComparison = Boolean.valueOf(isSetEx1()).compareTo(other.isSetEx1());
      if (lastComparison != 0) {
        return lastComparison;
      }
      if (isSetEx1()) {
        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.ex1, other.ex1);
        if (lastComparison != 0) {
          return lastComparison;
        }
      }
      return 0;
    }

    public _Fields fieldForId(int fieldId) {
      return _Fields.findByThriftId(fieldId);
    }

    public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
      schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
    }

    public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
      schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
      }

    @Override
    public String toString() {
      StringBuilder sb = new StringBuilder("queryUploadStatus_result(");
      boolean first = true;

      sb.append("success:");
      if (this.success == null) {
        sb.append("null");
      } else {
        sb.append(this.success);
      }
      first = false;
      if (!first) sb.append(", ");
      sb.append("ex1:");
      if (this.ex1 == null) {
        sb.append("null");
      } else {
        sb.append(this.ex1);
      }
      first = false;
      sb.append(")");
      return sb.toString();
    }

    public void validate() throws org.apache.thrift.TException {
      // check for required fields
      // check for sub-struct validity
      if (success != null) {
        success.validate();
      }
    }

    private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
      try {
        write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
      } catch (org.apache.thrift.TException te) {
        throw new java.io.IOException(te);
      }
    }

    private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
      try {
        read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
      } catch (org.apache.thrift.TException te) {
        throw new java.io.IOException(te);
      }
    }

    private static class queryUploadStatus_resultStandardSchemeFactory implements SchemeFactory {
      public queryUploadStatus_resultStandardScheme getScheme() {
        return new queryUploadStatus_resultStandardScheme();
      }
    }

    private static class queryUploadStatus_resultStandardScheme extends StandardScheme<queryUploadStatus_result> {

      public void read(org.apache.thrift.protocol.TProtocol iprot, queryUploadStatus_result struct) throws org.apache.thrift.TException {
        org.apache.thrift.protocol.TField schemeField;
        iprot.readStructBegin();
        while (true)
        {
          schemeField = iprot.readFieldBegin();
          if (schemeField.type == org.apache.thrift.protocol.TType.STOP) { 
            break;
          }
          switch (schemeField.id) {
            case 0: // SUCCESS
              if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
                struct.success = new TransferStatus();
                struct.success.read(iprot);
                struct.setSuccessIsSet(true);
              } else { 
                org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
              }
              break;
            case 1: // EX1
              if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
                struct.ex1 = new TInvalidTokenException();
                struct.ex1.read(iprot);
                struct.setEx1IsSet(true);
              } else { 
                org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
              }
              break;
            default:
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
          }
          iprot.readFieldEnd();
        }
        iprot.readStructEnd();

        // check for required fields of primitive type, which can't be checked in the validate method
        struct.validate();
      }

      public void write(org.apache.thrift.protocol.TProtocol oprot, queryUploadStatus_result struct) throws org.apache.thrift.TException {
        struct.validate();

        oprot.writeStructBegin(STRUCT_DESC);
        if (struct.success != null) {
          oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
          struct.success.write(oprot);
          oprot.writeFieldEnd();
        }
        if (struct.ex1 != null) {
          oprot.writeFieldBegin(EX1_FIELD_DESC);
          struct.ex1.write(oprot);
          oprot.writeFieldEnd();
        }
        oprot.writeFieldStop();
        oprot.writeStructEnd();
      }

    }

    private static class queryUploadStatus_resultTupleSchemeFactory implements SchemeFactory {
      public queryUploadStatus_resultTupleScheme getScheme() {
        return new queryUploadStatus_resultTupleScheme();
      }
    }

    private static class queryUploadStatus_resultTupleScheme extends TupleScheme<queryUploadStatus_result> {

      @Override
      public void write(org.apache.thrift.protocol.TProtocol prot, queryUploadStatus_result struct) throws org.apache.thrift.TException {
        TTupleProtocol oprot = (TTupleProtocol) prot;
        BitSet optionals = new BitSet();
        if (struct.isSetSuccess()) {
          optionals.set(0);
        }
        if (struct.isSetEx1()) {
          optionals.set(1);
        }
        oprot.writeBitSet(optionals, 2);
        if (struct.isSetSuccess()) {
          struct.success.write(oprot);
        }
        if (struct.isSetEx1()) {
          struct.ex1.write(oprot);
        }
      }

      @Override
      public void read(org.apache.thrift.protocol.TProtocol prot, queryUploadStatus_result struct) throws org.apache.thrift.TException {
        TTupleProtocol iprot = (TTupleProtocol) prot;
        BitSet incoming = iprot.readBitSet(2);
        if (incoming.get(0)) {
          struct.success = new TransferStatus();
          struct.success.read(iprot);
          struct.setSuccessIsSet(true);
        }
        if (incoming.get(1)) {
          struct.ex1 = new TInvalidTokenException();
          struct.ex1.read(iprot);
          struct.setEx1IsSet(true);
        }
      }
    }

  }

  public static class requestDownload_args implements org.apache.thrift.TBase<requestDownload_args, requestDownload_args._Fields>, java.io.Serializable, Cloneable, Comparable<requestDownload_args>   {
    private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("requestDownload_args");

    private static final org.apache.thrift.protocol.TField USER_TOKEN_FIELD_DESC = new org.apache.thrift.protocol.TField("userToken", org.apache.thrift.protocol.TType.STRING, (short)1);
    private static final org.apache.thrift.protocol.TField IMAGE_VERSION_ID_FIELD_DESC = new org.apache.thrift.protocol.TField("imageVersionId", org.apache.thrift.protocol.TType.STRING, (short)2);

    private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
    static {
      schemes.put(StandardScheme.class, new requestDownload_argsStandardSchemeFactory());
      schemes.put(TupleScheme.class, new requestDownload_argsTupleSchemeFactory());
    }

    public String userToken; // required
    public String imageVersionId; // required

    /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
    public enum _Fields implements org.apache.thrift.TFieldIdEnum {
      USER_TOKEN((short)1, "userToken"),
      IMAGE_VERSION_ID((short)2, "imageVersionId");

      private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();

      static {
        for (_Fields field : EnumSet.allOf(_Fields.class)) {
          byName.put(field.getFieldName(), field);
        }
      }

      /**
       * Find the _Fields constant that matches fieldId, or null if its not found.
       */
      public static _Fields findByThriftId(int fieldId) {
        switch(fieldId) {
          case 1: // USER_TOKEN
            return USER_TOKEN;
          case 2: // IMAGE_VERSION_ID
            return IMAGE_VERSION_ID;
          default:
            return null;
        }
      }

      /**
       * Find the _Fields constant that matches fieldId, throwing an exception
       * if it is not found.
       */
      public static _Fields findByThriftIdOrThrow(int fieldId) {
        _Fields fields = findByThriftId(fieldId);
        if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
        return fields;
      }

      /**
       * Find the _Fields constant that matches name, or null if its not found.
       */
      public static _Fields findByName(String name) {
        return byName.get(name);
      }

      private final short _thriftId;
      private final String _fieldName;

      _Fields(short thriftId, String fieldName) {
        _thriftId = thriftId;
        _fieldName = fieldName;
      }

      public short getThriftFieldId() {
        return _thriftId;
      }

      public String getFieldName() {
        return _fieldName;
      }
    }

    // isset id assignments
    public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
    static {
      Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
      tmpMap.put(_Fields.USER_TOKEN, new org.apache.thrift.meta_data.FieldMetaData("userToken", org.apache.thrift.TFieldRequirementType.DEFAULT, 
          new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING          , "Token")));
      tmpMap.put(_Fields.IMAGE_VERSION_ID, new org.apache.thrift.meta_data.FieldMetaData("imageVersionId", org.apache.thrift.TFieldRequirementType.DEFAULT, 
          new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING          , "UUID")));
      metaDataMap = Collections.unmodifiableMap(tmpMap);
      org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(requestDownload_args.class, metaDataMap);
    }

    public requestDownload_args() {
    }

    public requestDownload_args(
      String userToken,
      String imageVersionId)
    {
      this();
      this.userToken = userToken;
      this.imageVersionId = imageVersionId;
    }

    /**
     * Performs a deep copy on <i>other</i>.
     */
    public requestDownload_args(requestDownload_args other) {
      if (other.isSetUserToken()) {
        this.userToken = other.userToken;
      }
      if (other.isSetImageVersionId()) {
        this.imageVersionId = other.imageVersionId;
      }
    }

    public requestDownload_args deepCopy() {
      return new requestDownload_args(this);
    }

    @Override
    public void clear() {
      this.userToken = null;
      this.imageVersionId = null;
    }

    public String getUserToken() {
      return this.userToken;
    }

    public requestDownload_args setUserToken(String userToken) {
      this.userToken = userToken;
      return this;
    }

    public void unsetUserToken() {
      this.userToken = null;
    }

    /** Returns true if field userToken is set (has been assigned a value) and false otherwise */
    public boolean isSetUserToken() {
      return this.userToken != null;
    }

    public void setUserTokenIsSet(boolean value) {
      if (!value) {
        this.userToken = null;
      }
    }

    public String getImageVersionId() {
      return this.imageVersionId;
    }

    public requestDownload_args setImageVersionId(String imageVersionId) {
      this.imageVersionId = imageVersionId;
      return this;
    }

    public void unsetImageVersionId() {
      this.imageVersionId = null;
    }

    /** Returns true if field imageVersionId is set (has been assigned a value) and false otherwise */
    public boolean isSetImageVersionId() {
      return this.imageVersionId != null;
    }

    public void setImageVersionIdIsSet(boolean value) {
      if (!value) {
        this.imageVersionId = null;
      }
    }

    public void setFieldValue(_Fields field, Object value) {
      switch (field) {
      case USER_TOKEN:
        if (value == null) {
          unsetUserToken();
        } else {
          setUserToken((String)value);
        }
        break;

      case IMAGE_VERSION_ID:
        if (value == null) {
          unsetImageVersionId();
        } else {
          setImageVersionId((String)value);
        }
        break;

      }
    }

    public Object getFieldValue(_Fields field) {
      switch (field) {
      case USER_TOKEN:
        return getUserToken();

      case IMAGE_VERSION_ID:
        return getImageVersionId();

      }
      throw new IllegalStateException();
    }

    /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
    public boolean isSet(_Fields field) {
      if (field == null) {
        throw new IllegalArgumentException();
      }

      switch (field) {
      case USER_TOKEN:
        return isSetUserToken();
      case IMAGE_VERSION_ID:
        return isSetImageVersionId();
      }
      throw new IllegalStateException();
    }

    @Override
    public boolean equals(Object that) {
      if (that == null)
        return false;
      if (that instanceof requestDownload_args)
        return this.equals((requestDownload_args)that);
      return false;
    }

    public boolean equals(requestDownload_args that) {
      if (that == null)
        return false;

      boolean this_present_userToken = true && this.isSetUserToken();
      boolean that_present_userToken = true && that.isSetUserToken();
      if (this_present_userToken || that_present_userToken) {
        if (!(this_present_userToken && that_present_userToken))
          return false;
        if (!this.userToken.equals(that.userToken))
          return false;
      }

      boolean this_present_imageVersionId = true && this.isSetImageVersionId();
      boolean that_present_imageVersionId = true && that.isSetImageVersionId();
      if (this_present_imageVersionId || that_present_imageVersionId) {
        if (!(this_present_imageVersionId && that_present_imageVersionId))
          return false;
        if (!this.imageVersionId.equals(that.imageVersionId))
          return false;
      }

      return true;
    }

    @Override
    public int hashCode() {
      return 0;
    }

    @Override
    public int compareTo(requestDownload_args other) {
      if (!getClass().equals(other.getClass())) {
        return getClass().getName().compareTo(other.getClass().getName());
      }

      int lastComparison = 0;

      lastComparison = Boolean.valueOf(isSetUserToken()).compareTo(other.isSetUserToken());
      if (lastComparison != 0) {
        return lastComparison;
      }
      if (isSetUserToken()) {
        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.userToken, other.userToken);
        if (lastComparison != 0) {
          return lastComparison;
        }
      }
      lastComparison = Boolean.valueOf(isSetImageVersionId()).compareTo(other.isSetImageVersionId());
      if (lastComparison != 0) {
        return lastComparison;
      }
      if (isSetImageVersionId()) {
        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.imageVersionId, other.imageVersionId);
        if (lastComparison != 0) {
          return lastComparison;
        }
      }
      return 0;
    }

    public _Fields fieldForId(int fieldId) {
      return _Fields.findByThriftId(fieldId);
    }

    public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
      schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
    }

    public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
      schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
    }

    @Override
    public String toString() {
      StringBuilder sb = new StringBuilder("requestDownload_args(");
      boolean first = true;

      sb.append("userToken:");
      if (this.userToken == null) {
        sb.append("null");
      } else {
        sb.append(this.userToken);
      }
      first = false;
      if (!first) sb.append(", ");
      sb.append("imageVersionId:");
      if (this.imageVersionId == null) {
        sb.append("null");
      } else {
        sb.append(this.imageVersionId);
      }
      first = false;
      sb.append(")");
      return sb.toString();
    }

    public void validate() throws org.apache.thrift.TException {
      // check for required fields
      // check for sub-struct validity
    }

    private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
      try {
        write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
      } catch (org.apache.thrift.TException te) {
        throw new java.io.IOException(te);
      }
    }

    private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
      try {
        read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
      } catch (org.apache.thrift.TException te) {
        throw new java.io.IOException(te);
      }
    }

    private static class requestDownload_argsStandardSchemeFactory implements SchemeFactory {
      public requestDownload_argsStandardScheme getScheme() {
        return new requestDownload_argsStandardScheme();
      }
    }

    private static class requestDownload_argsStandardScheme extends StandardScheme<requestDownload_args> {

      public void read(org.apache.thrift.protocol.TProtocol iprot, requestDownload_args struct) throws org.apache.thrift.TException {
        org.apache.thrift.protocol.TField schemeField;
        iprot.readStructBegin();
        while (true)
        {
          schemeField = iprot.readFieldBegin();
          if (schemeField.type == org.apache.thrift.protocol.TType.STOP) { 
            break;
          }
          switch (schemeField.id) {
            case 1: // USER_TOKEN
              if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
                struct.userToken = iprot.readString();
                struct.setUserTokenIsSet(true);
              } else { 
                org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
              }
              break;
            case 2: // IMAGE_VERSION_ID
              if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
                struct.imageVersionId = iprot.readString();
                struct.setImageVersionIdIsSet(true);
              } else { 
                org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
              }
              break;
            default:
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
          }
          iprot.readFieldEnd();
        }
        iprot.readStructEnd();

        // check for required fields of primitive type, which can't be checked in the validate method
        struct.validate();
      }

      public void write(org.apache.thrift.protocol.TProtocol oprot, requestDownload_args struct) throws org.apache.thrift.TException {
        struct.validate();

        oprot.writeStructBegin(STRUCT_DESC);
        if (struct.userToken != null) {
          oprot.writeFieldBegin(USER_TOKEN_FIELD_DESC);
          oprot.writeString(struct.userToken);
          oprot.writeFieldEnd();
        }
        if (struct.imageVersionId != null) {
          oprot.writeFieldBegin(IMAGE_VERSION_ID_FIELD_DESC);
          oprot.writeString(struct.imageVersionId);
          oprot.writeFieldEnd();
        }
        oprot.writeFieldStop();
        oprot.writeStructEnd();
      }

    }

    private static class requestDownload_argsTupleSchemeFactory implements SchemeFactory {
      public requestDownload_argsTupleScheme getScheme() {
        return new requestDownload_argsTupleScheme();
      }
    }

    private static class requestDownload_argsTupleScheme extends TupleScheme<requestDownload_args> {

      @Override
      public void write(org.apache.thrift.protocol.TProtocol prot, requestDownload_args struct) throws org.apache.thrift.TException {
        TTupleProtocol oprot = (TTupleProtocol) prot;
        BitSet optionals = new BitSet();
        if (struct.isSetUserToken()) {
          optionals.set(0);
        }
        if (struct.isSetImageVersionId()) {
          optionals.set(1);
        }
        oprot.writeBitSet(optionals, 2);
        if (struct.isSetUserToken()) {
          oprot.writeString(struct.userToken);
        }
        if (struct.isSetImageVersionId()) {
          oprot.writeString(struct.imageVersionId);
        }
      }

      @Override
      public void read(org.apache.thrift.protocol.TProtocol prot, requestDownload_args struct) throws org.apache.thrift.TException {
        TTupleProtocol iprot = (TTupleProtocol) prot;
        BitSet incoming = iprot.readBitSet(2);
        if (incoming.get(0)) {
          struct.userToken = iprot.readString();
          struct.setUserTokenIsSet(true);
        }
        if (incoming.get(1)) {
          struct.imageVersionId = iprot.readString();
          struct.setImageVersionIdIsSet(true);
        }
      }
    }

  }

  public static class requestDownload_result implements org.apache.thrift.TBase<requestDownload_result, requestDownload_result._Fields>, java.io.Serializable, Cloneable, Comparable<requestDownload_result>   {
    private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("requestDownload_result");

    private static final org.apache.thrift.protocol.TField SUCCESS_FIELD_DESC = new org.apache.thrift.protocol.TField("success", org.apache.thrift.protocol.TType.STRUCT, (short)0);
    private static final org.apache.thrift.protocol.TField REJECTION_FIELD_DESC = new org.apache.thrift.protocol.TField("rejection", org.apache.thrift.protocol.TType.STRUCT, (short)1);
    private static final org.apache.thrift.protocol.TField AUTH_ERROR_FIELD_DESC = new org.apache.thrift.protocol.TField("authError", org.apache.thrift.protocol.TType.STRUCT, (short)2);
    private static final org.apache.thrift.protocol.TField FFFF_FIELD_DESC = new org.apache.thrift.protocol.TField("ffff", org.apache.thrift.protocol.TType.STRUCT, (short)3);
    private static final org.apache.thrift.protocol.TField SDF_FIELD_DESC = new org.apache.thrift.protocol.TField("sdf", org.apache.thrift.protocol.TType.STRUCT, (short)4);

    private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
    static {
      schemes.put(StandardScheme.class, new requestDownload_resultStandardSchemeFactory());
      schemes.put(TupleScheme.class, new requestDownload_resultTupleSchemeFactory());
    }

    public TransferInformation success; // required
    public TTransferRejectedException rejection; // required
    public TAuthorizationException authError; // required
    public TInternalServerError ffff; // required
    public TNotFoundException sdf; // required

    /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
    public enum _Fields implements org.apache.thrift.TFieldIdEnum {
      SUCCESS((short)0, "success"),
      REJECTION((short)1, "rejection"),
      AUTH_ERROR((short)2, "authError"),
      FFFF((short)3, "ffff"),
      SDF((short)4, "sdf");

      private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();

      static {
        for (_Fields field : EnumSet.allOf(_Fields.class)) {
          byName.put(field.getFieldName(), field);
        }
      }

      /**
       * Find the _Fields constant that matches fieldId, or null if its not found.
       */
      public static _Fields findByThriftId(int fieldId) {
        switch(fieldId) {
          case 0: // SUCCESS
            return SUCCESS;
          case 1: // REJECTION
            return REJECTION;
          case 2: // AUTH_ERROR
            return AUTH_ERROR;
          case 3: // FFFF
            return FFFF;
          case 4: // SDF
            return SDF;
          default:
            return null;
        }
      }

      /**
       * Find the _Fields constant that matches fieldId, throwing an exception
       * if it is not found.
       */
      public static _Fields findByThriftIdOrThrow(int fieldId) {
        _Fields fields = findByThriftId(fieldId);
        if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
        return fields;
      }

      /**
       * Find the _Fields constant that matches name, or null if its not found.
       */
      public static _Fields findByName(String name) {
        return byName.get(name);
      }

      private final short _thriftId;
      private final String _fieldName;

      _Fields(short thriftId, String fieldName) {
        _thriftId = thriftId;
        _fieldName = fieldName;
      }

      public short getThriftFieldId() {
        return _thriftId;
      }

      public String getFieldName() {
        return _fieldName;
      }
    }

    // isset id assignments
    public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
    static {
      Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
      tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, 
          new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, TransferInformation.class)));
      tmpMap.put(_Fields.REJECTION, new org.apache.thrift.meta_data.FieldMetaData("rejection", org.apache.thrift.TFieldRequirementType.DEFAULT, 
          new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT)));
      tmpMap.put(_Fields.AUTH_ERROR, new org.apache.thrift.meta_data.FieldMetaData("authError", org.apache.thrift.TFieldRequirementType.DEFAULT, 
          new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT)));
      tmpMap.put(_Fields.FFFF, new org.apache.thrift.meta_data.FieldMetaData("ffff", org.apache.thrift.TFieldRequirementType.DEFAULT, 
          new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT)));
      tmpMap.put(_Fields.SDF, new org.apache.thrift.meta_data.FieldMetaData("sdf", org.apache.thrift.TFieldRequirementType.DEFAULT, 
          new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT)));
      metaDataMap = Collections.unmodifiableMap(tmpMap);
      org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(requestDownload_result.class, metaDataMap);
    }

    public requestDownload_result() {
    }

    public requestDownload_result(
      TransferInformation success,
      TTransferRejectedException rejection,
      TAuthorizationException authError,
      TInternalServerError ffff,
      TNotFoundException sdf)
    {
      this();
      this.success = success;
      this.rejection = rejection;
      this.authError = authError;
      this.ffff = ffff;
      this.sdf = sdf;
    }

    /**
     * Performs a deep copy on <i>other</i>.
     */
    public requestDownload_result(requestDownload_result other) {
      if (other.isSetSuccess()) {
        this.success = new TransferInformation(other.success);
      }
      if (other.isSetRejection()) {
        this.rejection = new TTransferRejectedException(other.rejection);
      }
      if (other.isSetAuthError()) {
        this.authError = new TAuthorizationException(other.authError);
      }
      if (other.isSetFfff()) {
        this.ffff = new TInternalServerError(other.ffff);
      }
      if (other.isSetSdf()) {
        this.sdf = new TNotFoundException(other.sdf);
      }
    }

    public requestDownload_result deepCopy() {
      return new requestDownload_result(this);
    }

    @Override
    public void clear() {
      this.success = null;
      this.rejection = null;
      this.authError = null;
      this.ffff = null;
      this.sdf = null;
    }

    public TransferInformation getSuccess() {
      return this.success;
    }

    public requestDownload_result setSuccess(TransferInformation success) {
      this.success = success;
      return this;
    }

    public void unsetSuccess() {
      this.success = null;
    }

    /** Returns true if field success is set (has been assigned a value) and false otherwise */
    public boolean isSetSuccess() {
      return this.success != null;
    }

    public void setSuccessIsSet(boolean value) {
      if (!value) {
        this.success = null;
      }
    }

    public TTransferRejectedException getRejection() {
      return this.rejection;
    }

    public requestDownload_result setRejection(TTransferRejectedException rejection) {
      this.rejection = rejection;
      return this;
    }

    public void unsetRejection() {
      this.rejection = null;
    }

    /** Returns true if field rejection is set (has been assigned a value) and false otherwise */
    public boolean isSetRejection() {
      return this.rejection != null;
    }

    public void setRejectionIsSet(boolean value) {
      if (!value) {
        this.rejection = null;
      }
    }

    public TAuthorizationException getAuthError() {
      return this.authError;
    }

    public requestDownload_result setAuthError(TAuthorizationException authError) {
      this.authError = authError;
      return this;
    }

    public void unsetAuthError() {
      this.authError = null;
    }

    /** Returns true if field authError is set (has been assigned a value) and false otherwise */
    public boolean isSetAuthError() {
      return this.authError != null;
    }

    public void setAuthErrorIsSet(boolean value) {
      if (!value) {
        this.authError = null;
      }
    }

    public TInternalServerError getFfff() {
      return this.ffff;
    }

    public requestDownload_result setFfff(TInternalServerError ffff) {
      this.ffff = ffff;
      return this;
    }

    public void unsetFfff() {
      this.ffff = null;
    }

    /** Returns true if field ffff is set (has been assigned a value) and false otherwise */
    public boolean isSetFfff() {
      return this.ffff != null;
    }

    public void setFfffIsSet(boolean value) {
      if (!value) {
        this.ffff = null;
      }
    }

    public TNotFoundException getSdf() {
      return this.sdf;
    }

    public requestDownload_result setSdf(TNotFoundException sdf) {
      this.sdf = sdf;
      return this;
    }

    public void unsetSdf() {
      this.sdf = null;
    }

    /** Returns true if field sdf is set (has been assigned a value) and false otherwise */
    public boolean isSetSdf() {
      return this.sdf != null;
    }

    public void setSdfIsSet(boolean value) {
      if (!value) {
        this.sdf = null;
      }
    }

    public void setFieldValue(_Fields field, Object value) {
      switch (field) {
      case SUCCESS:
        if (value == null) {
          unsetSuccess();
        } else {
          setSuccess((TransferInformation)value);
        }
        break;

      case REJECTION:
        if (value == null) {
          unsetRejection();
        } else {
          setRejection((TTransferRejectedException)value);
        }
        break;

      case AUTH_ERROR:
        if (value == null) {
          unsetAuthError();
        } else {
          setAuthError((TAuthorizationException)value);
        }
        break;

      case FFFF:
        if (value == null) {
          unsetFfff();
        } else {
          setFfff((TInternalServerError)value);
        }
        break;

      case SDF:
        if (value == null) {
          unsetSdf();
        } else {
          setSdf((TNotFoundException)value);
        }
        break;

      }
    }

    public Object getFieldValue(_Fields field) {
      switch (field) {
      case SUCCESS:
        return getSuccess();

      case REJECTION:
        return getRejection();

      case AUTH_ERROR:
        return getAuthError();

      case FFFF:
        return getFfff();

      case SDF:
        return getSdf();

      }
      throw new IllegalStateException();
    }

    /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
    public boolean isSet(_Fields field) {
      if (field == null) {
        throw new IllegalArgumentException();
      }

      switch (field) {
      case SUCCESS:
        return isSetSuccess();
      case REJECTION:
        return isSetRejection();
      case AUTH_ERROR:
        return isSetAuthError();
      case FFFF:
        return isSetFfff();
      case SDF:
        return isSetSdf();
      }
      throw new IllegalStateException();
    }

    @Override
    public boolean equals(Object that) {
      if (that == null)
        return false;
      if (that instanceof requestDownload_result)
        return this.equals((requestDownload_result)that);
      return false;
    }

    public boolean equals(requestDownload_result that) {
      if (that == null)
        return false;

      boolean this_present_success = true && this.isSetSuccess();
      boolean that_present_success = true && that.isSetSuccess();
      if (this_present_success || that_present_success) {
        if (!(this_present_success && that_present_success))
          return false;
        if (!this.success.equals(that.success))
          return false;
      }

      boolean this_present_rejection = true && this.isSetRejection();
      boolean that_present_rejection = true && that.isSetRejection();
      if (this_present_rejection || that_present_rejection) {
        if (!(this_present_rejection && that_present_rejection))
          return false;
        if (!this.rejection.equals(that.rejection))
          return false;
      }

      boolean this_present_authError = true && this.isSetAuthError();
      boolean that_present_authError = true && that.isSetAuthError();
      if (this_present_authError || that_present_authError) {
        if (!(this_present_authError && that_present_authError))
          return false;
        if (!this.authError.equals(that.authError))
          return false;
      }

      boolean this_present_ffff = true && this.isSetFfff();
      boolean that_present_ffff = true && that.isSetFfff();
      if (this_present_ffff || that_present_ffff) {
        if (!(this_present_ffff && that_present_ffff))
          return false;
        if (!this.ffff.equals(that.ffff))
          return false;
      }

      boolean this_present_sdf = true && this.isSetSdf();
      boolean that_present_sdf = true && that.isSetSdf();
      if (this_present_sdf || that_present_sdf) {
        if (!(this_present_sdf && that_present_sdf))
          return false;
        if (!this.sdf.equals(that.sdf))
          return false;
      }

      return true;
    }

    @Override
    public int hashCode() {
      return 0;
    }

    @Override
    public int compareTo(requestDownload_result other) {
      if (!getClass().equals(other.getClass())) {
        return getClass().getName().compareTo(other.getClass().getName());
      }

      int lastComparison = 0;

      lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(other.isSetSuccess());
      if (lastComparison != 0) {
        return lastComparison;
      }
      if (isSetSuccess()) {
        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, other.success);
        if (lastComparison != 0) {
          return lastComparison;
        }
      }
      lastComparison = Boolean.valueOf(isSetRejection()).compareTo(other.isSetRejection());
      if (lastComparison != 0) {
        return lastComparison;
      }
      if (isSetRejection()) {
        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.rejection, other.rejection);
        if (lastComparison != 0) {
          return lastComparison;
        }
      }
      lastComparison = Boolean.valueOf(isSetAuthError()).compareTo(other.isSetAuthError());
      if (lastComparison != 0) {
        return lastComparison;
      }
      if (isSetAuthError()) {
        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.authError, other.authError);
        if (lastComparison != 0) {
          return lastComparison;
        }
      }
      lastComparison = Boolean.valueOf(isSetFfff()).compareTo(other.isSetFfff());
      if (lastComparison != 0) {
        return lastComparison;
      }
      if (isSetFfff()) {
        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.ffff, other.ffff);
        if (lastComparison != 0) {
          return lastComparison;
        }
      }
      lastComparison = Boolean.valueOf(isSetSdf()).compareTo(other.isSetSdf());
      if (lastComparison != 0) {
        return lastComparison;
      }
      if (isSetSdf()) {
        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.sdf, other.sdf);
        if (lastComparison != 0) {
          return lastComparison;
        }
      }
      return 0;
    }

    public _Fields fieldForId(int fieldId) {
      return _Fields.findByThriftId(fieldId);
    }

    public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
      schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
    }

    public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
      schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
      }

    @Override
    public String toString() {
      StringBuilder sb = new StringBuilder("requestDownload_result(");
      boolean first = true;

      sb.append("success:");
      if (this.success == null) {
        sb.append("null");
      } else {
        sb.append(this.success);
      }
      first = false;
      if (!first) sb.append(", ");
      sb.append("rejection:");
      if (this.rejection == null) {
        sb.append("null");
      } else {
        sb.append(this.rejection);
      }
      first = false;
      if (!first) sb.append(", ");
      sb.append("authError:");
      if (this.authError == null) {
        sb.append("null");
      } else {
        sb.append(this.authError);
      }
      first = false;
      if (!first) sb.append(", ");
      sb.append("ffff:");
      if (this.ffff == null) {
        sb.append("null");
      } else {
        sb.append(this.ffff);
      }
      first = false;
      if (!first) sb.append(", ");
      sb.append("sdf:");
      if (this.sdf == null) {
        sb.append("null");
      } else {
        sb.append(this.sdf);
      }
      first = false;
      sb.append(")");
      return sb.toString();
    }

    public void validate() throws org.apache.thrift.TException {
      // check for required fields
      // check for sub-struct validity
      if (success != null) {
        success.validate();
      }
    }

    private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
      try {
        write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
      } catch (org.apache.thrift.TException te) {
        throw new java.io.IOException(te);
      }
    }

    private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
      try {
        read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
      } catch (org.apache.thrift.TException te) {
        throw new java.io.IOException(te);
      }
    }

    private static class requestDownload_resultStandardSchemeFactory implements SchemeFactory {
      public requestDownload_resultStandardScheme getScheme() {
        return new requestDownload_resultStandardScheme();
      }
    }

    private static class requestDownload_resultStandardScheme extends StandardScheme<requestDownload_result> {

      public void read(org.apache.thrift.protocol.TProtocol iprot, requestDownload_result struct) throws org.apache.thrift.TException {
        org.apache.thrift.protocol.TField schemeField;
        iprot.readStructBegin();
        while (true)
        {
          schemeField = iprot.readFieldBegin();
          if (schemeField.type == org.apache.thrift.protocol.TType.STOP) { 
            break;
          }
          switch (schemeField.id) {
            case 0: // SUCCESS
              if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
                struct.success = new TransferInformation();
                struct.success.read(iprot);
                struct.setSuccessIsSet(true);
              } else { 
                org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
              }
              break;
            case 1: // REJECTION
              if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
                struct.rejection = new TTransferRejectedException();
                struct.rejection.read(iprot);
                struct.setRejectionIsSet(true);
              } else { 
                org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
              }
              break;
            case 2: // AUTH_ERROR
              if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
                struct.authError = new TAuthorizationException();
                struct.authError.read(iprot);
                struct.setAuthErrorIsSet(true);
              } else { 
                org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
              }
              break;
            case 3: // FFFF
              if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
                struct.ffff = new TInternalServerError();
                struct.ffff.read(iprot);
                struct.setFfffIsSet(true);
              } else { 
                org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
              }
              break;
            case 4: // SDF
              if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
                struct.sdf = new TNotFoundException();
                struct.sdf.read(iprot);
                struct.setSdfIsSet(true);
              } else { 
                org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
              }
              break;
            default:
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
          }
          iprot.readFieldEnd();
        }
        iprot.readStructEnd();

        // check for required fields of primitive type, which can't be checked in the validate method
        struct.validate();
      }

      public void write(org.apache.thrift.protocol.TProtocol oprot, requestDownload_result struct) throws org.apache.thrift.TException {
        struct.validate();

        oprot.writeStructBegin(STRUCT_DESC);
        if (struct.success != null) {
          oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
          struct.success.write(oprot);
          oprot.writeFieldEnd();
        }
        if (struct.rejection != null) {
          oprot.writeFieldBegin(REJECTION_FIELD_DESC);
          struct.rejection.write(oprot);
          oprot.writeFieldEnd();
        }
        if (struct.authError != null) {
          oprot.writeFieldBegin(AUTH_ERROR_FIELD_DESC);
          struct.authError.write(oprot);
          oprot.writeFieldEnd();
        }
        if (struct.ffff != null) {
          oprot.writeFieldBegin(FFFF_FIELD_DESC);
          struct.ffff.write(oprot);
          oprot.writeFieldEnd();
        }
        if (struct.sdf != null) {
          oprot.writeFieldBegin(SDF_FIELD_DESC);
          struct.sdf.write(oprot);
          oprot.writeFieldEnd();
        }
        oprot.writeFieldStop();
        oprot.writeStructEnd();
      }

    }

    private static class requestDownload_resultTupleSchemeFactory implements SchemeFactory {
      public requestDownload_resultTupleScheme getScheme() {
        return new requestDownload_resultTupleScheme();
      }
    }

    private static class requestDownload_resultTupleScheme extends TupleScheme<requestDownload_result> {

      @Override
      public void write(org.apache.thrift.protocol.TProtocol prot, requestDownload_result struct) throws org.apache.thrift.TException {
        TTupleProtocol oprot = (TTupleProtocol) prot;
        BitSet optionals = new BitSet();
        if (struct.isSetSuccess()) {
          optionals.set(0);
        }
        if (struct.isSetRejection()) {
          optionals.set(1);
        }
        if (struct.isSetAuthError()) {
          optionals.set(2);
        }
        if (struct.isSetFfff()) {
          optionals.set(3);
        }
        if (struct.isSetSdf()) {
          optionals.set(4);
        }
        oprot.writeBitSet(optionals, 5);
        if (struct.isSetSuccess()) {
          struct.success.write(oprot);
        }
        if (struct.isSetRejection()) {
          struct.rejection.write(oprot);
        }
        if (struct.isSetAuthError()) {
          struct.authError.write(oprot);
        }
        if (struct.isSetFfff()) {
          struct.ffff.write(oprot);
        }
        if (struct.isSetSdf()) {
          struct.sdf.write(oprot);
        }
      }

      @Override
      public void read(org.apache.thrift.protocol.TProtocol prot, requestDownload_result struct) throws org.apache.thrift.TException {
        TTupleProtocol iprot = (TTupleProtocol) prot;
        BitSet incoming = iprot.readBitSet(5);
        if (incoming.get(0)) {
          struct.success = new TransferInformation();
          struct.success.read(iprot);
          struct.setSuccessIsSet(true);
        }
        if (incoming.get(1)) {
          struct.rejection = new TTransferRejectedException();
          struct.rejection.read(iprot);
          struct.setRejectionIsSet(true);
        }
        if (incoming.get(2)) {
          struct.authError = new TAuthorizationException();
          struct.authError.read(iprot);
          struct.setAuthErrorIsSet(true);
        }
        if (incoming.get(3)) {
          struct.ffff = new TInternalServerError();
          struct.ffff.read(iprot);
          struct.setFfffIsSet(true);
        }
        if (incoming.get(4)) {
          struct.sdf = new TNotFoundException();
          struct.sdf.read(iprot);
          struct.setSdfIsSet(true);
        }
      }
    }

  }

  public static class cancelDownload_args implements org.apache.thrift.TBase<cancelDownload_args, cancelDownload_args._Fields>, java.io.Serializable, Cloneable, Comparable<cancelDownload_args>   {
    private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("cancelDownload_args");

    private static final org.apache.thrift.protocol.TField DOWNLOAD_TOKEN_FIELD_DESC = new org.apache.thrift.protocol.TField("downloadToken", org.apache.thrift.protocol.TType.STRING, (short)1);

    private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
    static {
      schemes.put(StandardScheme.class, new cancelDownload_argsStandardSchemeFactory());
      schemes.put(TupleScheme.class, new cancelDownload_argsTupleSchemeFactory());
    }

    public String downloadToken; // required

    /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
    public enum _Fields implements org.apache.thrift.TFieldIdEnum {
      DOWNLOAD_TOKEN((short)1, "downloadToken");

      private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();

      static {
        for (_Fields field : EnumSet.allOf(_Fields.class)) {
          byName.put(field.getFieldName(), field);
        }
      }

      /**
       * Find the _Fields constant that matches fieldId, or null if its not found.
       */
      public static _Fields findByThriftId(int fieldId) {
        switch(fieldId) {
          case 1: // DOWNLOAD_TOKEN
            return DOWNLOAD_TOKEN;
          default:
            return null;
        }
      }

      /**
       * Find the _Fields constant that matches fieldId, throwing an exception
       * if it is not found.
       */
      public static _Fields findByThriftIdOrThrow(int fieldId) {
        _Fields fields = findByThriftId(fieldId);
        if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
        return fields;
      }

      /**
       * Find the _Fields constant that matches name, or null if its not found.
       */
      public static _Fields findByName(String name) {
        return byName.get(name);
      }

      private final short _thriftId;
      private final String _fieldName;

      _Fields(short thriftId, String fieldName) {
        _thriftId = thriftId;
        _fieldName = fieldName;
      }

      public short getThriftFieldId() {
        return _thriftId;
      }

      public String getFieldName() {
        return _fieldName;
      }
    }

    // isset id assignments
    public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
    static {
      Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
      tmpMap.put(_Fields.DOWNLOAD_TOKEN, new org.apache.thrift.meta_data.FieldMetaData("downloadToken", org.apache.thrift.TFieldRequirementType.DEFAULT, 
          new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING)));
      metaDataMap = Collections.unmodifiableMap(tmpMap);
      org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(cancelDownload_args.class, metaDataMap);
    }

    public cancelDownload_args() {
    }

    public cancelDownload_args(
      String downloadToken)
    {
      this();
      this.downloadToken = downloadToken;
    }

    /**
     * Performs a deep copy on <i>other</i>.
     */
    public cancelDownload_args(cancelDownload_args other) {
      if (other.isSetDownloadToken()) {
        this.downloadToken = other.downloadToken;
      }
    }

    public cancelDownload_args deepCopy() {
      return new cancelDownload_args(this);
    }

    @Override
    public void clear() {
      this.downloadToken = null;
    }

    public String getDownloadToken() {
      return this.downloadToken;
    }

    public cancelDownload_args setDownloadToken(String downloadToken) {
      this.downloadToken = downloadToken;
      return this;
    }

    public void unsetDownloadToken() {
      this.downloadToken = null;
    }

    /** Returns true if field downloadToken is set (has been assigned a value) and false otherwise */
    public boolean isSetDownloadToken() {
      return this.downloadToken != null;
    }

    public void setDownloadTokenIsSet(boolean value) {
      if (!value) {
        this.downloadToken = null;
      }
    }

    public void setFieldValue(_Fields field, Object value) {
      switch (field) {
      case DOWNLOAD_TOKEN:
        if (value == null) {
          unsetDownloadToken();
        } else {
          setDownloadToken((String)value);
        }
        break;

      }
    }

    public Object getFieldValue(_Fields field) {
      switch (field) {
      case DOWNLOAD_TOKEN:
        return getDownloadToken();

      }
      throw new IllegalStateException();
    }

    /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
    public boolean isSet(_Fields field) {
      if (field == null) {
        throw new IllegalArgumentException();
      }

      switch (field) {
      case DOWNLOAD_TOKEN:
        return isSetDownloadToken();
      }
      throw new IllegalStateException();
    }

    @Override
    public boolean equals(Object that) {
      if (that == null)
        return false;
      if (that instanceof cancelDownload_args)
        return this.equals((cancelDownload_args)that);
      return false;
    }

    public boolean equals(cancelDownload_args that) {
      if (that == null)
        return false;

      boolean this_present_downloadToken = true && this.isSetDownloadToken();
      boolean that_present_downloadToken = true && that.isSetDownloadToken();
      if (this_present_downloadToken || that_present_downloadToken) {
        if (!(this_present_downloadToken && that_present_downloadToken))
          return false;
        if (!this.downloadToken.equals(that.downloadToken))
          return false;
      }

      return true;
    }

    @Override
    public int hashCode() {
      return 0;
    }

    @Override
    public int compareTo(cancelDownload_args other) {
      if (!getClass().equals(other.getClass())) {
        return getClass().getName().compareTo(other.getClass().getName());
      }

      int lastComparison = 0;

      lastComparison = Boolean.valueOf(isSetDownloadToken()).compareTo(other.isSetDownloadToken());
      if (lastComparison != 0) {
        return lastComparison;
      }
      if (isSetDownloadToken()) {
        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.downloadToken, other.downloadToken);
        if (lastComparison != 0) {
          return lastComparison;
        }
      }
      return 0;
    }

    public _Fields fieldForId(int fieldId) {
      return _Fields.findByThriftId(fieldId);
    }

    public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
      schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
    }

    public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
      schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
    }

    @Override
    public String toString() {
      StringBuilder sb = new StringBuilder("cancelDownload_args(");
      boolean first = true;

      sb.append("downloadToken:");
      if (this.downloadToken == null) {
        sb.append("null");
      } else {
        sb.append(this.downloadToken);
      }
      first = false;
      sb.append(")");
      return sb.toString();
    }

    public void validate() throws org.apache.thrift.TException {
      // check for required fields
      // check for sub-struct validity
    }

    private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
      try {
        write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
      } catch (org.apache.thrift.TException te) {
        throw new java.io.IOException(te);
      }
    }

    private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
      try {
        read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
      } catch (org.apache.thrift.TException te) {
        throw new java.io.IOException(te);
      }
    }

    private static class cancelDownload_argsStandardSchemeFactory implements SchemeFactory {
      public cancelDownload_argsStandardScheme getScheme() {
        return new cancelDownload_argsStandardScheme();
      }
    }

    private static class cancelDownload_argsStandardScheme extends StandardScheme<cancelDownload_args> {

      public void read(org.apache.thrift.protocol.TProtocol iprot, cancelDownload_args struct) throws org.apache.thrift.TException {
        org.apache.thrift.protocol.TField schemeField;
        iprot.readStructBegin();
        while (true)
        {
          schemeField = iprot.readFieldBegin();
          if (schemeField.type == org.apache.thrift.protocol.TType.STOP) { 
            break;
          }
          switch (schemeField.id) {
            case 1: // DOWNLOAD_TOKEN
              if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
                struct.downloadToken = iprot.readString();
                struct.setDownloadTokenIsSet(true);
              } else { 
                org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
              }
              break;
            default:
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
          }
          iprot.readFieldEnd();
        }
        iprot.readStructEnd();

        // check for required fields of primitive type, which can't be checked in the validate method
        struct.validate();
      }

      public void write(org.apache.thrift.protocol.TProtocol oprot, cancelDownload_args struct) throws org.apache.thrift.TException {
        struct.validate();

        oprot.writeStructBegin(STRUCT_DESC);
        if (struct.downloadToken != null) {
          oprot.writeFieldBegin(DOWNLOAD_TOKEN_FIELD_DESC);
          oprot.writeString(struct.downloadToken);
          oprot.writeFieldEnd();
        }
        oprot.writeFieldStop();
        oprot.writeStructEnd();
      }

    }

    private static class cancelDownload_argsTupleSchemeFactory implements SchemeFactory {
      public cancelDownload_argsTupleScheme getScheme() {
        return new cancelDownload_argsTupleScheme();
      }
    }

    private static class cancelDownload_argsTupleScheme extends TupleScheme<cancelDownload_args> {

      @Override
      public void write(org.apache.thrift.protocol.TProtocol prot, cancelDownload_args struct) throws org.apache.thrift.TException {
        TTupleProtocol oprot = (TTupleProtocol) prot;
        BitSet optionals = new BitSet();
        if (struct.isSetDownloadToken()) {
          optionals.set(0);
        }
        oprot.writeBitSet(optionals, 1);
        if (struct.isSetDownloadToken()) {
          oprot.writeString(struct.downloadToken);
        }
      }

      @Override
      public void read(org.apache.thrift.protocol.TProtocol prot, cancelDownload_args struct) throws org.apache.thrift.TException {
        TTupleProtocol iprot = (TTupleProtocol) prot;
        BitSet incoming = iprot.readBitSet(1);
        if (incoming.get(0)) {
          struct.downloadToken = iprot.readString();
          struct.setDownloadTokenIsSet(true);
        }
      }
    }

  }

  public static class cancelDownload_result implements org.apache.thrift.TBase<cancelDownload_result, cancelDownload_result._Fields>, java.io.Serializable, Cloneable, Comparable<cancelDownload_result>   {
    private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("cancelDownload_result");

    private static final org.apache.thrift.protocol.TField EX1_FIELD_DESC = new org.apache.thrift.protocol.TField("ex1", org.apache.thrift.protocol.TType.STRUCT, (short)1);

    private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
    static {
      schemes.put(StandardScheme.class, new cancelDownload_resultStandardSchemeFactory());
      schemes.put(TupleScheme.class, new cancelDownload_resultTupleSchemeFactory());
    }

    public TInvalidTokenException ex1; // required

    /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
    public enum _Fields implements org.apache.thrift.TFieldIdEnum {
      EX1((short)1, "ex1");

      private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();

      static {
        for (_Fields field : EnumSet.allOf(_Fields.class)) {
          byName.put(field.getFieldName(), field);
        }
      }

      /**
       * Find the _Fields constant that matches fieldId, or null if its not found.
       */
      public static _Fields findByThriftId(int fieldId) {
        switch(fieldId) {
          case 1: // EX1
            return EX1;
          default:
            return null;
        }
      }

      /**
       * Find the _Fields constant that matches fieldId, throwing an exception
       * if it is not found.
       */
      public static _Fields findByThriftIdOrThrow(int fieldId) {
        _Fields fields = findByThriftId(fieldId);
        if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
        return fields;
      }

      /**
       * Find the _Fields constant that matches name, or null if its not found.
       */
      public static _Fields findByName(String name) {
        return byName.get(name);
      }

      private final short _thriftId;
      private final String _fieldName;

      _Fields(short thriftId, String fieldName) {
        _thriftId = thriftId;
        _fieldName = fieldName;
      }

      public short getThriftFieldId() {
        return _thriftId;
      }

      public String getFieldName() {
        return _fieldName;
      }
    }

    // isset id assignments
    public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
    static {
      Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
      tmpMap.put(_Fields.EX1, new org.apache.thrift.meta_data.FieldMetaData("ex1", org.apache.thrift.TFieldRequirementType.DEFAULT, 
          new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT)));
      metaDataMap = Collections.unmodifiableMap(tmpMap);
      org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(cancelDownload_result.class, metaDataMap);
    }

    public cancelDownload_result() {
    }

    public cancelDownload_result(
      TInvalidTokenException ex1)
    {
      this();
      this.ex1 = ex1;
    }

    /**
     * Performs a deep copy on <i>other</i>.
     */
    public cancelDownload_result(cancelDownload_result other) {
      if (other.isSetEx1()) {
        this.ex1 = new TInvalidTokenException(other.ex1);
      }
    }

    public cancelDownload_result deepCopy() {
      return new cancelDownload_result(this);
    }

    @Override
    public void clear() {
      this.ex1 = null;
    }

    public TInvalidTokenException getEx1() {
      return this.ex1;
    }

    public cancelDownload_result setEx1(TInvalidTokenException ex1) {
      this.ex1 = ex1;
      return this;
    }

    public void unsetEx1() {
      this.ex1 = null;
    }

    /** Returns true if field ex1 is set (has been assigned a value) and false otherwise */
    public boolean isSetEx1() {
      return this.ex1 != null;
    }

    public void setEx1IsSet(boolean value) {
      if (!value) {
        this.ex1 = null;
      }
    }

    public void setFieldValue(_Fields field, Object value) {
      switch (field) {
      case EX1:
        if (value == null) {
          unsetEx1();
        } else {
          setEx1((TInvalidTokenException)value);
        }
        break;

      }
    }

    public Object getFieldValue(_Fields field) {
      switch (field) {
      case EX1:
        return getEx1();

      }
      throw new IllegalStateException();
    }

    /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
    public boolean isSet(_Fields field) {
      if (field == null) {
        throw new IllegalArgumentException();
      }

      switch (field) {
      case EX1:
        return isSetEx1();
      }
      throw new IllegalStateException();
    }

    @Override
    public boolean equals(Object that) {
      if (that == null)
        return false;
      if (that instanceof cancelDownload_result)
        return this.equals((cancelDownload_result)that);
      return false;
    }

    public boolean equals(cancelDownload_result that) {
      if (that == null)
        return false;

      boolean this_present_ex1 = true && this.isSetEx1();
      boolean that_present_ex1 = true && that.isSetEx1();
      if (this_present_ex1 || that_present_ex1) {
        if (!(this_present_ex1 && that_present_ex1))
          return false;
        if (!this.ex1.equals(that.ex1))
          return false;
      }

      return true;
    }

    @Override
    public int hashCode() {
      return 0;
    }

    @Override
    public int compareTo(cancelDownload_result other) {
      if (!getClass().equals(other.getClass())) {
        return getClass().getName().compareTo(other.getClass().getName());
      }

      int lastComparison = 0;

      lastComparison = Boolean.valueOf(isSetEx1()).compareTo(other.isSetEx1());
      if (lastComparison != 0) {
        return lastComparison;
      }
      if (isSetEx1()) {
        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.ex1, other.ex1);
        if (lastComparison != 0) {
          return lastComparison;
        }
      }
      return 0;
    }

    public _Fields fieldForId(int fieldId) {
      return _Fields.findByThriftId(fieldId);
    }

    public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
      schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
    }

    public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
      schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
      }

    @Override
    public String toString() {
      StringBuilder sb = new StringBuilder("cancelDownload_result(");
      boolean first = true;

      sb.append("ex1:");
      if (this.ex1 == null) {
        sb.append("null");
      } else {
        sb.append(this.ex1);
      }
      first = false;
      sb.append(")");
      return sb.toString();
    }

    public void validate() throws org.apache.thrift.TException {
      // check for required fields
      // check for sub-struct validity
    }

    private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
      try {
        write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
      } catch (org.apache.thrift.TException te) {
        throw new java.io.IOException(te);
      }
    }

    private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
      try {
        read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
      } catch (org.apache.thrift.TException te) {
        throw new java.io.IOException(te);
      }
    }

    private static class cancelDownload_resultStandardSchemeFactory implements SchemeFactory {
      public cancelDownload_resultStandardScheme getScheme() {
        return new cancelDownload_resultStandardScheme();
      }
    }

    private static class cancelDownload_resultStandardScheme extends StandardScheme<cancelDownload_result> {

      public void read(org.apache.thrift.protocol.TProtocol iprot, cancelDownload_result struct) throws org.apache.thrift.TException {
        org.apache.thrift.protocol.TField schemeField;
        iprot.readStructBegin();
        while (true)
        {
          schemeField = iprot.readFieldBegin();
          if (schemeField.type == org.apache.thrift.protocol.TType.STOP) { 
            break;
          }
          switch (schemeField.id) {
            case 1: // EX1
              if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
                struct.ex1 = new TInvalidTokenException();
                struct.ex1.read(iprot);
                struct.setEx1IsSet(true);
              } else { 
                org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
              }
              break;
            default:
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
          }
          iprot.readFieldEnd();
        }
        iprot.readStructEnd();

        // check for required fields of primitive type, which can't be checked in the validate method
        struct.validate();
      }

      public void write(org.apache.thrift.protocol.TProtocol oprot, cancelDownload_result struct) throws org.apache.thrift.TException {
        struct.validate();

        oprot.writeStructBegin(STRUCT_DESC);
        if (struct.ex1 != null) {
          oprot.writeFieldBegin(EX1_FIELD_DESC);
          struct.ex1.write(oprot);
          oprot.writeFieldEnd();
        }
        oprot.writeFieldStop();
        oprot.writeStructEnd();
      }

    }

    private static class cancelDownload_resultTupleSchemeFactory implements SchemeFactory {
      public cancelDownload_resultTupleScheme getScheme() {
        return new cancelDownload_resultTupleScheme();
      }
    }

    private static class cancelDownload_resultTupleScheme extends TupleScheme<cancelDownload_result> {

      @Override
      public void write(org.apache.thrift.protocol.TProtocol prot, cancelDownload_result struct) throws org.apache.thrift.TException {
        TTupleProtocol oprot = (TTupleProtocol) prot;
        BitSet optionals = new BitSet();
        if (struct.isSetEx1()) {
          optionals.set(0);
        }
        oprot.writeBitSet(optionals, 1);
        if (struct.isSetEx1()) {
          struct.ex1.write(oprot);
        }
      }

      @Override
      public void read(org.apache.thrift.protocol.TProtocol prot, cancelDownload_result struct) throws org.apache.thrift.TException {
        TTupleProtocol iprot = (TTupleProtocol) prot;
        BitSet incoming = iprot.readBitSet(1);
        if (incoming.get(0)) {
          struct.ex1 = new TInvalidTokenException();
          struct.ex1.read(iprot);
          struct.setEx1IsSet(true);
        }
      }
    }

  }

  public static class getMachineDescription_args implements org.apache.thrift.TBase<getMachineDescription_args, getMachineDescription_args._Fields>, java.io.Serializable, Cloneable, Comparable<getMachineDescription_args>   {
    private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getMachineDescription_args");

    private static final org.apache.thrift.protocol.TField USER_TOKEN_FIELD_DESC = new org.apache.thrift.protocol.TField("userToken", org.apache.thrift.protocol.TType.STRING, (short)1);
    private static final org.apache.thrift.protocol.TField IMAGE_VERSION_ID_FIELD_DESC = new org.apache.thrift.protocol.TField("imageVersionId", org.apache.thrift.protocol.TType.STRING, (short)2);

    private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
    static {
      schemes.put(StandardScheme.class, new getMachineDescription_argsStandardSchemeFactory());
      schemes.put(TupleScheme.class, new getMachineDescription_argsTupleSchemeFactory());
    }

    public String userToken; // required
    public String imageVersionId; // required

    /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
    public enum _Fields implements org.apache.thrift.TFieldIdEnum {
      USER_TOKEN((short)1, "userToken"),
      IMAGE_VERSION_ID((short)2, "imageVersionId");

      private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();

      static {
        for (_Fields field : EnumSet.allOf(_Fields.class)) {
          byName.put(field.getFieldName(), field);
        }
      }

      /**
       * Find the _Fields constant that matches fieldId, or null if its not found.
       */
      public static _Fields findByThriftId(int fieldId) {
        switch(fieldId) {
          case 1: // USER_TOKEN
            return USER_TOKEN;
          case 2: // IMAGE_VERSION_ID
            return IMAGE_VERSION_ID;
          default:
            return null;
        }
      }

      /**
       * Find the _Fields constant that matches fieldId, throwing an exception
       * if it is not found.
       */
      public static _Fields findByThriftIdOrThrow(int fieldId) {
        _Fields fields = findByThriftId(fieldId);
        if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
        return fields;
      }

      /**
       * Find the _Fields constant that matches name, or null if its not found.
       */
      public static _Fields findByName(String name) {
        return byName.get(name);
      }

      private final short _thriftId;
      private final String _fieldName;

      _Fields(short thriftId, String fieldName) {
        _thriftId = thriftId;
        _fieldName = fieldName;
      }

      public short getThriftFieldId() {
        return _thriftId;
      }

      public String getFieldName() {
        return _fieldName;
      }
    }

    // isset id assignments
    public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
    static {
      Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
      tmpMap.put(_Fields.USER_TOKEN, new org.apache.thrift.meta_data.FieldMetaData("userToken", org.apache.thrift.TFieldRequirementType.DEFAULT, 
          new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING          , "Token")));
      tmpMap.put(_Fields.IMAGE_VERSION_ID, new org.apache.thrift.meta_data.FieldMetaData("imageVersionId", org.apache.thrift.TFieldRequirementType.DEFAULT, 
          new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING          , "UUID")));
      metaDataMap = Collections.unmodifiableMap(tmpMap);
      org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getMachineDescription_args.class, metaDataMap);
    }

    public getMachineDescription_args() {
    }

    public getMachineDescription_args(
      String userToken,
      String imageVersionId)
    {
      this();
      this.userToken = userToken;
      this.imageVersionId = imageVersionId;
    }

    /**
     * Performs a deep copy on <i>other</i>.
     */
    public getMachineDescription_args(getMachineDescription_args other) {
      if (other.isSetUserToken()) {
        this.userToken = other.userToken;
      }
      if (other.isSetImageVersionId()) {
        this.imageVersionId = other.imageVersionId;
      }
    }

    public getMachineDescription_args deepCopy() {
      return new getMachineDescription_args(this);
    }

    @Override
    public void clear() {
      this.userToken = null;
      this.imageVersionId = null;
    }

    public String getUserToken() {
      return this.userToken;
    }

    public getMachineDescription_args setUserToken(String userToken) {
      this.userToken = userToken;
      return this;
    }

    public void unsetUserToken() {
      this.userToken = null;
    }

    /** Returns true if field userToken is set (has been assigned a value) and false otherwise */
    public boolean isSetUserToken() {
      return this.userToken != null;
    }

    public void setUserTokenIsSet(boolean value) {
      if (!value) {
        this.userToken = null;
      }
    }

    public String getImageVersionId() {
      return this.imageVersionId;
    }

    public getMachineDescription_args setImageVersionId(String imageVersionId) {
      this.imageVersionId = imageVersionId;
      return this;
    }

    public void unsetImageVersionId() {
      this.imageVersionId = null;
    }

    /** Returns true if field imageVersionId is set (has been assigned a value) and false otherwise */
    public boolean isSetImageVersionId() {
      return this.imageVersionId != null;
    }

    public void setImageVersionIdIsSet(boolean value) {
      if (!value) {
        this.imageVersionId = null;
      }
    }

    public void setFieldValue(_Fields field, Object value) {
      switch (field) {
      case USER_TOKEN:
        if (value == null) {
          unsetUserToken();
        } else {
          setUserToken((String)value);
        }
        break;

      case IMAGE_VERSION_ID:
        if (value == null) {
          unsetImageVersionId();
        } else {
          setImageVersionId((String)value);
        }
        break;

      }
    }

    public Object getFieldValue(_Fields field) {
      switch (field) {
      case USER_TOKEN:
        return getUserToken();

      case IMAGE_VERSION_ID:
        return getImageVersionId();

      }
      throw new IllegalStateException();
    }

    /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
    public boolean isSet(_Fields field) {
      if (field == null) {
        throw new IllegalArgumentException();
      }

      switch (field) {
      case USER_TOKEN:
        return isSetUserToken();
      case IMAGE_VERSION_ID:
        return isSetImageVersionId();
      }
      throw new IllegalStateException();
    }

    @Override
    public boolean equals(Object that) {
      if (that == null)
        return false;
      if (that instanceof getMachineDescription_args)
        return this.equals((getMachineDescription_args)that);
      return false;
    }

    public boolean equals(getMachineDescription_args that) {
      if (that == null)
        return false;

      boolean this_present_userToken = true && this.isSetUserToken();
      boolean that_present_userToken = true && that.isSetUserToken();
      if (this_present_userToken || that_present_userToken) {
        if (!(this_present_userToken && that_present_userToken))
          return false;
        if (!this.userToken.equals(that.userToken))
          return false;
      }

      boolean this_present_imageVersionId = true && this.isSetImageVersionId();
      boolean that_present_imageVersionId = true && that.isSetImageVersionId();
      if (this_present_imageVersionId || that_present_imageVersionId) {
        if (!(this_present_imageVersionId && that_present_imageVersionId))
          return false;
        if (!this.imageVersionId.equals(that.imageVersionId))
          return false;
      }

      return true;
    }

    @Override
    public int hashCode() {
      return 0;
    }

    @Override
    public int compareTo(getMachineDescription_args other) {
      if (!getClass().equals(other.getClass())) {
        return getClass().getName().compareTo(other.getClass().getName());
      }

      int lastComparison = 0;

      lastComparison = Boolean.valueOf(isSetUserToken()).compareTo(other.isSetUserToken());
      if (lastComparison != 0) {
        return lastComparison;
      }
      if (isSetUserToken()) {
        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.userToken, other.userToken);
        if (lastComparison != 0) {
          return lastComparison;
        }
      }
      lastComparison = Boolean.valueOf(isSetImageVersionId()).compareTo(other.isSetImageVersionId());
      if (lastComparison != 0) {
        return lastComparison;
      }
      if (isSetImageVersionId()) {
        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.imageVersionId, other.imageVersionId);
        if (lastComparison != 0) {
          return lastComparison;
        }
      }
      return 0;
    }

    public _Fields fieldForId(int fieldId) {
      return _Fields.findByThriftId(fieldId);
    }

    public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
      schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
    }

    public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
      schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
    }

    @Override
    public String toString() {
      StringBuilder sb = new StringBuilder("getMachineDescription_args(");
      boolean first = true;

      sb.append("userToken:");
      if (this.userToken == null) {
        sb.append("null");
      } else {
        sb.append(this.userToken);
      }
      first = false;
      if (!first) sb.append(", ");
      sb.append("imageVersionId:");
      if (this.imageVersionId == null) {
        sb.append("null");
      } else {
        sb.append(this.imageVersionId);
      }
      first = false;
      sb.append(")");
      return sb.toString();
    }

    public void validate() throws org.apache.thrift.TException {
      // check for required fields
      // check for sub-struct validity
    }

    private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
      try {
        write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
      } catch (org.apache.thrift.TException te) {
        throw new java.io.IOException(te);
      }
    }

    private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
      try {
        read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
      } catch (org.apache.thrift.TException te) {
        throw new java.io.IOException(te);
      }
    }

    private static class getMachineDescription_argsStandardSchemeFactory implements SchemeFactory {
      public getMachineDescription_argsStandardScheme getScheme() {
        return new getMachineDescription_argsStandardScheme();
      }
    }

    private static class getMachineDescription_argsStandardScheme extends StandardScheme<getMachineDescription_args> {

      public void read(org.apache.thrift.protocol.TProtocol iprot, getMachineDescription_args struct) throws org.apache.thrift.TException {
        org.apache.thrift.protocol.TField schemeField;
        iprot.readStructBegin();
        while (true)
        {
          schemeField = iprot.readFieldBegin();
          if (schemeField.type == org.apache.thrift.protocol.TType.STOP) { 
            break;
          }
          switch (schemeField.id) {
            case 1: // USER_TOKEN
              if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
                struct.userToken = iprot.readString();
                struct.setUserTokenIsSet(true);
              } else { 
                org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
              }
              break;
            case 2: // IMAGE_VERSION_ID
              if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
                struct.imageVersionId = iprot.readString();
                struct.setImageVersionIdIsSet(true);
              } else { 
                org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
              }
              break;
            default:
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
          }
          iprot.readFieldEnd();
        }
        iprot.readStructEnd();

        // check for required fields of primitive type, which can't be checked in the validate method
        struct.validate();
      }

      public void write(org.apache.thrift.protocol.TProtocol oprot, getMachineDescription_args struct) throws org.apache.thrift.TException {
        struct.validate();

        oprot.writeStructBegin(STRUCT_DESC);
        if (struct.userToken != null) {
          oprot.writeFieldBegin(USER_TOKEN_FIELD_DESC);
          oprot.writeString(struct.userToken);
          oprot.writeFieldEnd();
        }
        if (struct.imageVersionId != null) {
          oprot.writeFieldBegin(IMAGE_VERSION_ID_FIELD_DESC);
          oprot.writeString(struct.imageVersionId);
          oprot.writeFieldEnd();
        }
        oprot.writeFieldStop();
        oprot.writeStructEnd();
      }

    }

    private static class getMachineDescription_argsTupleSchemeFactory implements SchemeFactory {
      public getMachineDescription_argsTupleScheme getScheme() {
        return new getMachineDescription_argsTupleScheme();
      }
    }

    private static class getMachineDescription_argsTupleScheme extends TupleScheme<getMachineDescription_args> {

      @Override
      public void write(org.apache.thrift.protocol.TProtocol prot, getMachineDescription_args struct) throws org.apache.thrift.TException {
        TTupleProtocol oprot = (TTupleProtocol) prot;
        BitSet optionals = new BitSet();
        if (struct.isSetUserToken()) {
          optionals.set(0);
        }
        if (struct.isSetImageVersionId()) {
          optionals.set(1);
        }
        oprot.writeBitSet(optionals, 2);
        if (struct.isSetUserToken()) {
          oprot.writeString(struct.userToken);
        }
        if (struct.isSetImageVersionId()) {
          oprot.writeString(struct.imageVersionId);
        }
      }

      @Override
      public void read(org.apache.thrift.protocol.TProtocol prot, getMachineDescription_args struct) throws org.apache.thrift.TException {
        TTupleProtocol iprot = (TTupleProtocol) prot;
        BitSet incoming = iprot.readBitSet(2);
        if (incoming.get(0)) {
          struct.userToken = iprot.readString();
          struct.setUserTokenIsSet(true);
        }
        if (incoming.get(1)) {
          struct.imageVersionId = iprot.readString();
          struct.setImageVersionIdIsSet(true);
        }
      }
    }

  }

  public static class getMachineDescription_result implements org.apache.thrift.TBase<getMachineDescription_result, getMachineDescription_result._Fields>, java.io.Serializable, Cloneable, Comparable<getMachineDescription_result>   {
    private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getMachineDescription_result");

    private static final org.apache.thrift.protocol.TField SUCCESS_FIELD_DESC = new org.apache.thrift.protocol.TField("success", org.apache.thrift.protocol.TType.STRING, (short)0);
    private static final org.apache.thrift.protocol.TField AUTH_ERROR_FIELD_DESC = new org.apache.thrift.protocol.TField("authError", org.apache.thrift.protocol.TType.STRUCT, (short)1);
    private static final org.apache.thrift.protocol.TField FFFF_FIELD_DESC = new org.apache.thrift.protocol.TField("ffff", org.apache.thrift.protocol.TType.STRUCT, (short)2);
    private static final org.apache.thrift.protocol.TField SDF_FIELD_DESC = new org.apache.thrift.protocol.TField("sdf", org.apache.thrift.protocol.TType.STRUCT, (short)3);

    private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
    static {
      schemes.put(StandardScheme.class, new getMachineDescription_resultStandardSchemeFactory());
      schemes.put(TupleScheme.class, new getMachineDescription_resultTupleSchemeFactory());
    }

    public ByteBuffer success; // required
    public TAuthorizationException authError; // required
    public TInternalServerError ffff; // required
    public TNotFoundException sdf; // required

    /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
    public enum _Fields implements org.apache.thrift.TFieldIdEnum {
      SUCCESS((short)0, "success"),
      AUTH_ERROR((short)1, "authError"),
      FFFF((short)2, "ffff"),
      SDF((short)3, "sdf");

      private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();

      static {
        for (_Fields field : EnumSet.allOf(_Fields.class)) {
          byName.put(field.getFieldName(), field);
        }
      }

      /**
       * Find the _Fields constant that matches fieldId, or null if its not found.
       */
      public static _Fields findByThriftId(int fieldId) {
        switch(fieldId) {
          case 0: // SUCCESS
            return SUCCESS;
          case 1: // AUTH_ERROR
            return AUTH_ERROR;
          case 2: // FFFF
            return FFFF;
          case 3: // SDF
            return SDF;
          default:
            return null;
        }
      }

      /**
       * Find the _Fields constant that matches fieldId, throwing an exception
       * if it is not found.
       */
      public static _Fields findByThriftIdOrThrow(int fieldId) {
        _Fields fields = findByThriftId(fieldId);
        if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
        return fields;
      }

      /**
       * Find the _Fields constant that matches name, or null if its not found.
       */
      public static _Fields findByName(String name) {
        return byName.get(name);
      }

      private final short _thriftId;
      private final String _fieldName;

      _Fields(short thriftId, String fieldName) {
        _thriftId = thriftId;
        _fieldName = fieldName;
      }

      public short getThriftFieldId() {
        return _thriftId;
      }

      public String getFieldName() {
        return _fieldName;
      }
    }

    // isset id assignments
    public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
    static {
      Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
      tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, 
          new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING          , true)));
      tmpMap.put(_Fields.AUTH_ERROR, new org.apache.thrift.meta_data.FieldMetaData("authError", org.apache.thrift.TFieldRequirementType.DEFAULT, 
          new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT)));
      tmpMap.put(_Fields.FFFF, new org.apache.thrift.meta_data.FieldMetaData("ffff", org.apache.thrift.TFieldRequirementType.DEFAULT, 
          new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT)));
      tmpMap.put(_Fields.SDF, new org.apache.thrift.meta_data.FieldMetaData("sdf", org.apache.thrift.TFieldRequirementType.DEFAULT, 
          new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT)));
      metaDataMap = Collections.unmodifiableMap(tmpMap);
      org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getMachineDescription_result.class, metaDataMap);
    }

    public getMachineDescription_result() {
    }

    public getMachineDescription_result(
      ByteBuffer success,
      TAuthorizationException authError,
      TInternalServerError ffff,
      TNotFoundException sdf)
    {
      this();
      this.success = success;
      this.authError = authError;
      this.ffff = ffff;
      this.sdf = sdf;
    }

    /**
     * Performs a deep copy on <i>other</i>.
     */
    public getMachineDescription_result(getMachineDescription_result other) {
      if (other.isSetSuccess()) {
        this.success = org.apache.thrift.TBaseHelper.copyBinary(other.success);
;
      }
      if (other.isSetAuthError()) {
        this.authError = new TAuthorizationException(other.authError);
      }
      if (other.isSetFfff()) {
        this.ffff = new TInternalServerError(other.ffff);
      }
      if (other.isSetSdf()) {
        this.sdf = new TNotFoundException(other.sdf);
      }
    }

    public getMachineDescription_result deepCopy() {
      return new getMachineDescription_result(this);
    }

    @Override
    public void clear() {
      this.success = null;
      this.authError = null;
      this.ffff = null;
      this.sdf = null;
    }

    public byte[] getSuccess() {
      setSuccess(org.apache.thrift.TBaseHelper.rightSize(success));
      return success == null ? null : success.array();
    }

    public ByteBuffer bufferForSuccess() {
      return success;
    }

    public getMachineDescription_result setSuccess(byte[] success) {
      setSuccess(success == null ? (ByteBuffer)null : ByteBuffer.wrap(success));
      return this;
    }

    public getMachineDescription_result setSuccess(ByteBuffer success) {
      this.success = success;
      return this;
    }

    public void unsetSuccess() {
      this.success = null;
    }

    /** Returns true if field success is set (has been assigned a value) and false otherwise */
    public boolean isSetSuccess() {
      return this.success != null;
    }

    public void setSuccessIsSet(boolean value) {
      if (!value) {
        this.success = null;
      }
    }

    public TAuthorizationException getAuthError() {
      return this.authError;
    }

    public getMachineDescription_result setAuthError(TAuthorizationException authError) {
      this.authError = authError;
      return this;
    }

    public void unsetAuthError() {
      this.authError = null;
    }

    /** Returns true if field authError is set (has been assigned a value) and false otherwise */
    public boolean isSetAuthError() {
      return this.authError != null;
    }

    public void setAuthErrorIsSet(boolean value) {
      if (!value) {
        this.authError = null;
      }
    }

    public TInternalServerError getFfff() {
      return this.ffff;
    }

    public getMachineDescription_result setFfff(TInternalServerError ffff) {
      this.ffff = ffff;
      return this;
    }

    public void unsetFfff() {
      this.ffff = null;
    }

    /** Returns true if field ffff is set (has been assigned a value) and false otherwise */
    public boolean isSetFfff() {
      return this.ffff != null;
    }

    public void setFfffIsSet(boolean value) {
      if (!value) {
        this.ffff = null;
      }
    }

    public TNotFoundException getSdf() {
      return this.sdf;
    }

    public getMachineDescription_result setSdf(TNotFoundException sdf) {
      this.sdf = sdf;
      return this;
    }

    public void unsetSdf() {
      this.sdf = null;
    }

    /** Returns true if field sdf is set (has been assigned a value) and false otherwise */
    public boolean isSetSdf() {
      return this.sdf != null;
    }

    public void setSdfIsSet(boolean value) {
      if (!value) {
        this.sdf = null;
      }
    }

    public void setFieldValue(_Fields field, Object value) {
      switch (field) {
      case SUCCESS:
        if (value == null) {
          unsetSuccess();
        } else {
          setSuccess((ByteBuffer)value);
        }
        break;

      case AUTH_ERROR:
        if (value == null) {
          unsetAuthError();
        } else {
          setAuthError((TAuthorizationException)value);
        }
        break;

      case FFFF:
        if (value == null) {
          unsetFfff();
        } else {
          setFfff((TInternalServerError)value);
        }
        break;

      case SDF:
        if (value == null) {
          unsetSdf();
        } else {
          setSdf((TNotFoundException)value);
        }
        break;

      }
    }

    public Object getFieldValue(_Fields field) {
      switch (field) {
      case SUCCESS:
        return getSuccess();

      case AUTH_ERROR:
        return getAuthError();

      case FFFF:
        return getFfff();

      case SDF:
        return getSdf();

      }
      throw new IllegalStateException();
    }

    /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
    public boolean isSet(_Fields field) {
      if (field == null) {
        throw new IllegalArgumentException();
      }

      switch (field) {
      case SUCCESS:
        return isSetSuccess();
      case AUTH_ERROR:
        return isSetAuthError();
      case FFFF:
        return isSetFfff();
      case SDF:
        return isSetSdf();
      }
      throw new IllegalStateException();
    }

    @Override
    public boolean equals(Object that) {
      if (that == null)
        return false;
      if (that instanceof getMachineDescription_result)
        return this.equals((getMachineDescription_result)that);
      return false;
    }

    public boolean equals(getMachineDescription_result that) {
      if (that == null)
        return false;

      boolean this_present_success = true && this.isSetSuccess();
      boolean that_present_success = true && that.isSetSuccess();
      if (this_present_success || that_present_success) {
        if (!(this_present_success && that_present_success))
          return false;
        if (!this.success.equals(that.success))
          return false;
      }

      boolean this_present_authError = true && this.isSetAuthError();
      boolean that_present_authError = true && that.isSetAuthError();
      if (this_present_authError || that_present_authError) {
        if (!(this_present_authError && that_present_authError))
          return false;
        if (!this.authError.equals(that.authError))
          return false;
      }

      boolean this_present_ffff = true && this.isSetFfff();
      boolean that_present_ffff = true && that.isSetFfff();
      if (this_present_ffff || that_present_ffff) {
        if (!(this_present_ffff && that_present_ffff))
          return false;
        if (!this.ffff.equals(that.ffff))
          return false;
      }

      boolean this_present_sdf = true && this.isSetSdf();
      boolean that_present_sdf = true && that.isSetSdf();
      if (this_present_sdf || that_present_sdf) {
        if (!(this_present_sdf && that_present_sdf))
          return false;
        if (!this.sdf.equals(that.sdf))
          return false;
      }

      return true;
    }

    @Override
    public int hashCode() {
      return 0;
    }

    @Override
    public int compareTo(getMachineDescription_result other) {
      if (!getClass().equals(other.getClass())) {
        return getClass().getName().compareTo(other.getClass().getName());
      }

      int lastComparison = 0;

      lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(other.isSetSuccess());
      if (lastComparison != 0) {
        return lastComparison;
      }
      if (isSetSuccess()) {
        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, other.success);
        if (lastComparison != 0) {
          return lastComparison;
        }
      }
      lastComparison = Boolean.valueOf(isSetAuthError()).compareTo(other.isSetAuthError());
      if (lastComparison != 0) {
        return lastComparison;
      }
      if (isSetAuthError()) {
        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.authError, other.authError);
        if (lastComparison != 0) {
          return lastComparison;
        }
      }
      lastComparison = Boolean.valueOf(isSetFfff()).compareTo(other.isSetFfff());
      if (lastComparison != 0) {
        return lastComparison;
      }
      if (isSetFfff()) {
        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.ffff, other.ffff);
        if (lastComparison != 0) {
          return lastComparison;
        }
      }
      lastComparison = Boolean.valueOf(isSetSdf()).compareTo(other.isSetSdf());
      if (lastComparison != 0) {
        return lastComparison;
      }
      if (isSetSdf()) {
        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.sdf, other.sdf);
        if (lastComparison != 0) {
          return lastComparison;
        }
      }
      return 0;
    }

    public _Fields fieldForId(int fieldId) {
      return _Fields.findByThriftId(fieldId);
    }

    public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
      schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
    }

    public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
      schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
      }

    @Override
    public String toString() {
      StringBuilder sb = new StringBuilder("getMachineDescription_result(");
      boolean first = true;

      sb.append("success:");
      if (this.success == null) {
        sb.append("null");
      } else {
        org.apache.thrift.TBaseHelper.toString(this.success, sb);
      }
      first = false;
      if (!first) sb.append(", ");
      sb.append("authError:");
      if (this.authError == null) {
        sb.append("null");
      } else {
        sb.append(this.authError);
      }
      first = false;
      if (!first) sb.append(", ");
      sb.append("ffff:");
      if (this.ffff == null) {
        sb.append("null");
      } else {
        sb.append(this.ffff);
      }
      first = false;
      if (!first) sb.append(", ");
      sb.append("sdf:");
      if (this.sdf == null) {
        sb.append("null");
      } else {
        sb.append(this.sdf);
      }
      first = false;
      sb.append(")");
      return sb.toString();
    }

    public void validate() throws org.apache.thrift.TException {
      // check for required fields
      // check for sub-struct validity
    }

    private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
      try {
        write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
      } catch (org.apache.thrift.TException te) {
        throw new java.io.IOException(te);
      }
    }

    private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
      try {
        read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
      } catch (org.apache.thrift.TException te) {
        throw new java.io.IOException(te);
      }
    }

    private static class getMachineDescription_resultStandardSchemeFactory implements SchemeFactory {
      public getMachineDescription_resultStandardScheme getScheme() {
        return new getMachineDescription_resultStandardScheme();
      }
    }

    private static class getMachineDescription_resultStandardScheme extends StandardScheme<getMachineDescription_result> {

      public void read(org.apache.thrift.protocol.TProtocol iprot, getMachineDescription_result struct) throws org.apache.thrift.TException {
        org.apache.thrift.protocol.TField schemeField;
        iprot.readStructBegin();
        while (true)
        {
          schemeField = iprot.readFieldBegin();
          if (schemeField.type == org.apache.thrift.protocol.TType.STOP) { 
            break;
          }
          switch (schemeField.id) {
            case 0: // SUCCESS
              if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
                struct.success = iprot.readBinary();
                struct.setSuccessIsSet(true);
              } else { 
                org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
              }
              break;
            case 1: // AUTH_ERROR
              if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
                struct.authError = new TAuthorizationException();
                struct.authError.read(iprot);
                struct.setAuthErrorIsSet(true);
              } else { 
                org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
              }
              break;
            case 2: // FFFF
              if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
                struct.ffff = new TInternalServerError();
                struct.ffff.read(iprot);
                struct.setFfffIsSet(true);
              } else { 
                org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
              }
              break;
            case 3: // SDF
              if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
                struct.sdf = new TNotFoundException();
                struct.sdf.read(iprot);
                struct.setSdfIsSet(true);
              } else { 
                org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
              }
              break;
            default:
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
          }
          iprot.readFieldEnd();
        }
        iprot.readStructEnd();

        // check for required fields of primitive type, which can't be checked in the validate method
        struct.validate();
      }

      public void write(org.apache.thrift.protocol.TProtocol oprot, getMachineDescription_result struct) throws org.apache.thrift.TException {
        struct.validate();

        oprot.writeStructBegin(STRUCT_DESC);
        if (struct.success != null) {
          oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
          oprot.writeBinary(struct.success);
          oprot.writeFieldEnd();
        }
        if (struct.authError != null) {
          oprot.writeFieldBegin(AUTH_ERROR_FIELD_DESC);
          struct.authError.write(oprot);
          oprot.writeFieldEnd();
        }
        if (struct.ffff != null) {
          oprot.writeFieldBegin(FFFF_FIELD_DESC);
          struct.ffff.write(oprot);
          oprot.writeFieldEnd();
        }
        if (struct.sdf != null) {
          oprot.writeFieldBegin(SDF_FIELD_DESC);
          struct.sdf.write(oprot);
          oprot.writeFieldEnd();
        }
        oprot.writeFieldStop();
        oprot.writeStructEnd();
      }

    }

    private static class getMachineDescription_resultTupleSchemeFactory implements SchemeFactory {
      public getMachineDescription_resultTupleScheme getScheme() {
        return new getMachineDescription_resultTupleScheme();
      }
    }

    private static class getMachineDescription_resultTupleScheme extends TupleScheme<getMachineDescription_result> {

      @Override
      public void write(org.apache.thrift.protocol.TProtocol prot, getMachineDescription_result struct) throws org.apache.thrift.TException {
        TTupleProtocol oprot = (TTupleProtocol) prot;
        BitSet optionals = new BitSet();
        if (struct.isSetSuccess()) {
          optionals.set(0);
        }
        if (struct.isSetAuthError()) {
          optionals.set(1);
        }
        if (struct.isSetFfff()) {
          optionals.set(2);
        }
        if (struct.isSetSdf()) {
          optionals.set(3);
        }
        oprot.writeBitSet(optionals, 4);
        if (struct.isSetSuccess()) {
          oprot.writeBinary(struct.success);
        }
        if (struct.isSetAuthError()) {
          struct.authError.write(oprot);
        }
        if (struct.isSetFfff()) {
          struct.ffff.write(oprot);
        }
        if (struct.isSetSdf()) {
          struct.sdf.write(oprot);
        }
      }

      @Override
      public void read(org.apache.thrift.protocol.TProtocol prot, getMachineDescription_result struct) throws org.apache.thrift.TException {
        TTupleProtocol iprot = (TTupleProtocol) prot;
        BitSet incoming = iprot.readBitSet(4);
        if (incoming.get(0)) {
          struct.success = iprot.readBinary();
          struct.setSuccessIsSet(true);
        }
        if (incoming.get(1)) {
          struct.authError = new TAuthorizationException();
          struct.authError.read(iprot);
          struct.setAuthErrorIsSet(true);
        }
        if (incoming.get(2)) {
          struct.ffff = new TInternalServerError();
          struct.ffff.read(iprot);
          struct.setFfffIsSet(true);
        }
        if (incoming.get(3)) {
          struct.sdf = new TNotFoundException();
          struct.sdf.read(iprot);
          struct.setSdfIsSet(true);
        }
      }
    }

  }

  public static class isAuthenticated_args implements org.apache.thrift.TBase<isAuthenticated_args, isAuthenticated_args._Fields>, java.io.Serializable, Cloneable, Comparable<isAuthenticated_args>   {
    private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("isAuthenticated_args");

    private static final org.apache.thrift.protocol.TField USER_TOKEN_FIELD_DESC = new org.apache.thrift.protocol.TField("userToken", org.apache.thrift.protocol.TType.STRING, (short)1);

    private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
    static {
      schemes.put(StandardScheme.class, new isAuthenticated_argsStandardSchemeFactory());
      schemes.put(TupleScheme.class, new isAuthenticated_argsTupleSchemeFactory());
    }

    public String userToken; // required

    /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
    public enum _Fields implements org.apache.thrift.TFieldIdEnum {
      USER_TOKEN((short)1, "userToken");

      private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();

      static {
        for (_Fields field : EnumSet.allOf(_Fields.class)) {
          byName.put(field.getFieldName(), field);
        }
      }

      /**
       * Find the _Fields constant that matches fieldId, or null if its not found.
       */
      public static _Fields findByThriftId(int fieldId) {
        switch(fieldId) {
          case 1: // USER_TOKEN
            return USER_TOKEN;
          default:
            return null;
        }
      }

      /**
       * Find the _Fields constant that matches fieldId, throwing an exception
       * if it is not found.
       */
      public static _Fields findByThriftIdOrThrow(int fieldId) {
        _Fields fields = findByThriftId(fieldId);
        if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
        return fields;
      }

      /**
       * Find the _Fields constant that matches name, or null if its not found.
       */
      public static _Fields findByName(String name) {
        return byName.get(name);
      }

      private final short _thriftId;
      private final String _fieldName;

      _Fields(short thriftId, String fieldName) {
        _thriftId = thriftId;
        _fieldName = fieldName;
      }

      public short getThriftFieldId() {
        return _thriftId;
      }

      public String getFieldName() {
        return _fieldName;
      }
    }

    // isset id assignments
    public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
    static {
      Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
      tmpMap.put(_Fields.USER_TOKEN, new org.apache.thrift.meta_data.FieldMetaData("userToken", org.apache.thrift.TFieldRequirementType.DEFAULT, 
          new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING          , "Token")));
      metaDataMap = Collections.unmodifiableMap(tmpMap);
      org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(isAuthenticated_args.class, metaDataMap);
    }

    public isAuthenticated_args() {
    }

    public isAuthenticated_args(
      String userToken)
    {
      this();
      this.userToken = userToken;
    }

    /**
     * Performs a deep copy on <i>other</i>.
     */
    public isAuthenticated_args(isAuthenticated_args other) {
      if (other.isSetUserToken()) {
        this.userToken = other.userToken;
      }
    }

    public isAuthenticated_args deepCopy() {
      return new isAuthenticated_args(this);
    }

    @Override
    public void clear() {
      this.userToken = null;
    }

    public String getUserToken() {
      return this.userToken;
    }

    public isAuthenticated_args setUserToken(String userToken) {
      this.userToken = userToken;
      return this;
    }

    public void unsetUserToken() {
      this.userToken = null;
    }

    /** Returns true if field userToken is set (has been assigned a value) and false otherwise */
    public boolean isSetUserToken() {
      return this.userToken != null;
    }

    public void setUserTokenIsSet(boolean value) {
      if (!value) {
        this.userToken = null;
      }
    }

    public void setFieldValue(_Fields field, Object value) {
      switch (field) {
      case USER_TOKEN:
        if (value == null) {
          unsetUserToken();
        } else {
          setUserToken((String)value);
        }
        break;

      }
    }

    public Object getFieldValue(_Fields field) {
      switch (field) {
      case USER_TOKEN:
        return getUserToken();

      }
      throw new IllegalStateException();
    }

    /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
    public boolean isSet(_Fields field) {
      if (field == null) {
        throw new IllegalArgumentException();
      }

      switch (field) {
      case USER_TOKEN:
        return isSetUserToken();
      }
      throw new IllegalStateException();
    }

    @Override
    public boolean equals(Object that) {
      if (that == null)
        return false;
      if (that instanceof isAuthenticated_args)
        return this.equals((isAuthenticated_args)that);
      return false;
    }

    public boolean equals(isAuthenticated_args that) {
      if (that == null)
        return false;

      boolean this_present_userToken = true && this.isSetUserToken();
      boolean that_present_userToken = true && that.isSetUserToken();
      if (this_present_userToken || that_present_userToken) {
        if (!(this_present_userToken && that_present_userToken))
          return false;
        if (!this.userToken.equals(that.userToken))
          return false;
      }

      return true;
    }

    @Override
    public int hashCode() {
      return 0;
    }

    @Override
    public int compareTo(isAuthenticated_args other) {
      if (!getClass().equals(other.getClass())) {
        return getClass().getName().compareTo(other.getClass().getName());
      }

      int lastComparison = 0;

      lastComparison = Boolean.valueOf(isSetUserToken()).compareTo(other.isSetUserToken());
      if (lastComparison != 0) {
        return lastComparison;
      }
      if (isSetUserToken()) {
        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.userToken, other.userToken);
        if (lastComparison != 0) {
          return lastComparison;
        }
      }
      return 0;
    }

    public _Fields fieldForId(int fieldId) {
      return _Fields.findByThriftId(fieldId);
    }

    public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
      schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
    }

    public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
      schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
    }

    @Override
    public String toString() {
      StringBuilder sb = new StringBuilder("isAuthenticated_args(");
      boolean first = true;

      sb.append("userToken:");
      if (this.userToken == null) {
        sb.append("null");
      } else {
        sb.append(this.userToken);
      }
      first = false;
      sb.append(")");
      return sb.toString();
    }

    public void validate() throws org.apache.thrift.TException {
      // check for required fields
      // check for sub-struct validity
    }

    private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
      try {
        write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
      } catch (org.apache.thrift.TException te) {
        throw new java.io.IOException(te);
      }
    }

    private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
      try {
        read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
      } catch (org.apache.thrift.TException te) {
        throw new java.io.IOException(te);
      }
    }

    private static class isAuthenticated_argsStandardSchemeFactory implements SchemeFactory {
      public isAuthenticated_argsStandardScheme getScheme() {
        return new isAuthenticated_argsStandardScheme();
      }
    }

    private static class isAuthenticated_argsStandardScheme extends StandardScheme<isAuthenticated_args> {

      public void read(org.apache.thrift.protocol.TProtocol iprot, isAuthenticated_args struct) throws org.apache.thrift.TException {
        org.apache.thrift.protocol.TField schemeField;
        iprot.readStructBegin();
        while (true)
        {
          schemeField = iprot.readFieldBegin();
          if (schemeField.type == org.apache.thrift.protocol.TType.STOP) { 
            break;
          }
          switch (schemeField.id) {
            case 1: // USER_TOKEN
              if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
                struct.userToken = iprot.readString();
                struct.setUserTokenIsSet(true);
              } else { 
                org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
              }
              break;
            default:
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
          }
          iprot.readFieldEnd();
        }
        iprot.readStructEnd();

        // check for required fields of primitive type, which can't be checked in the validate method
        struct.validate();
      }

      public void write(org.apache.thrift.protocol.TProtocol oprot, isAuthenticated_args struct) throws org.apache.thrift.TException {
        struct.validate();

        oprot.writeStructBegin(STRUCT_DESC);
        if (struct.userToken != null) {
          oprot.writeFieldBegin(USER_TOKEN_FIELD_DESC);
          oprot.writeString(struct.userToken);
          oprot.writeFieldEnd();
        }
        oprot.writeFieldStop();
        oprot.writeStructEnd();
      }

    }

    private static class isAuthenticated_argsTupleSchemeFactory implements SchemeFactory {
      public isAuthenticated_argsTupleScheme getScheme() {
        return new isAuthenticated_argsTupleScheme();
      }
    }

    private static class isAuthenticated_argsTupleScheme extends TupleScheme<isAuthenticated_args> {

      @Override
      public void write(org.apache.thrift.protocol.TProtocol prot, isAuthenticated_args struct) throws org.apache.thrift.TException {
        TTupleProtocol oprot = (TTupleProtocol) prot;
        BitSet optionals = new BitSet();
        if (struct.isSetUserToken()) {
          optionals.set(0);
        }
        oprot.writeBitSet(optionals, 1);
        if (struct.isSetUserToken()) {
          oprot.writeString(struct.userToken);
        }
      }

      @Override
      public void read(org.apache.thrift.protocol.TProtocol prot, isAuthenticated_args struct) throws org.apache.thrift.TException {
        TTupleProtocol iprot = (TTupleProtocol) prot;
        BitSet incoming = iprot.readBitSet(1);
        if (incoming.get(0)) {
          struct.userToken = iprot.readString();
          struct.setUserTokenIsSet(true);
        }
      }
    }

  }

  public static class isAuthenticated_result implements org.apache.thrift.TBase<isAuthenticated_result, isAuthenticated_result._Fields>, java.io.Serializable, Cloneable, Comparable<isAuthenticated_result>   {
    private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("isAuthenticated_result");

    private static final org.apache.thrift.protocol.TField AUTH_ERROR_FIELD_DESC = new org.apache.thrift.protocol.TField("authError", org.apache.thrift.protocol.TType.STRUCT, (short)1);
    private static final org.apache.thrift.protocol.TField SERVER_ERROR_FIELD_DESC = new org.apache.thrift.protocol.TField("serverError", org.apache.thrift.protocol.TType.STRUCT, (short)2);

    private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
    static {
      schemes.put(StandardScheme.class, new isAuthenticated_resultStandardSchemeFactory());
      schemes.put(TupleScheme.class, new isAuthenticated_resultTupleSchemeFactory());
    }

    public TAuthorizationException authError; // required
    public TInternalServerError serverError; // required

    /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
    public enum _Fields implements org.apache.thrift.TFieldIdEnum {
      AUTH_ERROR((short)1, "authError"),
      SERVER_ERROR((short)2, "serverError");

      private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();

      static {
        for (_Fields field : EnumSet.allOf(_Fields.class)) {
          byName.put(field.getFieldName(), field);
        }
      }

      /**
       * Find the _Fields constant that matches fieldId, or null if its not found.
       */
      public static _Fields findByThriftId(int fieldId) {
        switch(fieldId) {
          case 1: // AUTH_ERROR
            return AUTH_ERROR;
          case 2: // SERVER_ERROR
            return SERVER_ERROR;
          default:
            return null;
        }
      }

      /**
       * Find the _Fields constant that matches fieldId, throwing an exception
       * if it is not found.
       */
      public static _Fields findByThriftIdOrThrow(int fieldId) {
        _Fields fields = findByThriftId(fieldId);
        if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
        return fields;
      }

      /**
       * Find the _Fields constant that matches name, or null if its not found.
       */
      public static _Fields findByName(String name) {
        return byName.get(name);
      }

      private final short _thriftId;
      private final String _fieldName;

      _Fields(short thriftId, String fieldName) {
        _thriftId = thriftId;
        _fieldName = fieldName;
      }

      public short getThriftFieldId() {
        return _thriftId;
      }

      public String getFieldName() {
        return _fieldName;
      }
    }

    // isset id assignments
    public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
    static {
      Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
      tmpMap.put(_Fields.AUTH_ERROR, new org.apache.thrift.meta_data.FieldMetaData("authError", org.apache.thrift.TFieldRequirementType.DEFAULT, 
          new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT)));
      tmpMap.put(_Fields.SERVER_ERROR, new org.apache.thrift.meta_data.FieldMetaData("serverError", org.apache.thrift.TFieldRequirementType.DEFAULT, 
          new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT)));
      metaDataMap = Collections.unmodifiableMap(tmpMap);
      org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(isAuthenticated_result.class, metaDataMap);
    }

    public isAuthenticated_result() {
    }

    public isAuthenticated_result(
      TAuthorizationException authError,
      TInternalServerError serverError)
    {
      this();
      this.authError = authError;
      this.serverError = serverError;
    }

    /**
     * Performs a deep copy on <i>other</i>.
     */
    public isAuthenticated_result(isAuthenticated_result other) {
      if (other.isSetAuthError()) {
        this.authError = new TAuthorizationException(other.authError);
      }
      if (other.isSetServerError()) {
        this.serverError = new TInternalServerError(other.serverError);
      }
    }

    public isAuthenticated_result deepCopy() {
      return new isAuthenticated_result(this);
    }

    @Override
    public void clear() {
      this.authError = null;
      this.serverError = null;
    }

    public TAuthorizationException getAuthError() {
      return this.authError;
    }

    public isAuthenticated_result setAuthError(TAuthorizationException authError) {
      this.authError = authError;
      return this;
    }

    public void unsetAuthError() {
      this.authError = null;
    }

    /** Returns true if field authError is set (has been assigned a value) and false otherwise */
    public boolean isSetAuthError() {
      return this.authError != null;
    }

    public void setAuthErrorIsSet(boolean value) {
      if (!value) {
        this.authError = null;
      }
    }

    public TInternalServerError getServerError() {
      return this.serverError;
    }

    public isAuthenticated_result setServerError(TInternalServerError serverError) {
      this.serverError = serverError;
      return this;
    }

    public void unsetServerError() {
      this.serverError = null;
    }

    /** Returns true if field serverError is set (has been assigned a value) and false otherwise */
    public boolean isSetServerError() {
      return this.serverError != null;
    }

    public void setServerErrorIsSet(boolean value) {
      if (!value) {
        this.serverError = null;
      }
    }

    public void setFieldValue(_Fields field, Object value) {
      switch (field) {
      case AUTH_ERROR:
        if (value == null) {
          unsetAuthError();
        } else {
          setAuthError((TAuthorizationException)value);
        }
        break;

      case SERVER_ERROR:
        if (value == null) {
          unsetServerError();
        } else {
          setServerError((TInternalServerError)value);
        }
        break;

      }
    }

    public Object getFieldValue(_Fields field) {
      switch (field) {
      case AUTH_ERROR:
        return getAuthError();

      case SERVER_ERROR:
        return getServerError();

      }
      throw new IllegalStateException();
    }

    /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
    public boolean isSet(_Fields field) {
      if (field == null) {
        throw new IllegalArgumentException();
      }

      switch (field) {
      case AUTH_ERROR:
        return isSetAuthError();
      case SERVER_ERROR:
        return isSetServerError();
      }
      throw new IllegalStateException();
    }

    @Override
    public boolean equals(Object that) {
      if (that == null)
        return false;
      if (that instanceof isAuthenticated_result)
        return this.equals((isAuthenticated_result)that);
      return false;
    }

    public boolean equals(isAuthenticated_result that) {
      if (that == null)
        return false;

      boolean this_present_authError = true && this.isSetAuthError();
      boolean that_present_authError = true && that.isSetAuthError();
      if (this_present_authError || that_present_authError) {
        if (!(this_present_authError && that_present_authError))
          return false;
        if (!this.authError.equals(that.authError))
          return false;
      }

      boolean this_present_serverError = true && this.isSetServerError();
      boolean that_present_serverError = true && that.isSetServerError();
      if (this_present_serverError || that_present_serverError) {
        if (!(this_present_serverError && that_present_serverError))
          return false;
        if (!this.serverError.equals(that.serverError))
          return false;
      }

      return true;
    }

    @Override
    public int hashCode() {
      return 0;
    }

    @Override
    public int compareTo(isAuthenticated_result other) {
      if (!getClass().equals(other.getClass())) {
        return getClass().getName().compareTo(other.getClass().getName());
      }

      int lastComparison = 0;

      lastComparison = Boolean.valueOf(isSetAuthError()).compareTo(other.isSetAuthError());
      if (lastComparison != 0) {
        return lastComparison;
      }
      if (isSetAuthError()) {
        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.authError, other.authError);
        if (lastComparison != 0) {
          return lastComparison;
        }
      }
      lastComparison = Boolean.valueOf(isSetServerError()).compareTo(other.isSetServerError());
      if (lastComparison != 0) {
        return lastComparison;
      }
      if (isSetServerError()) {
        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.serverError, other.serverError);
        if (lastComparison != 0) {
          return lastComparison;
        }
      }
      return 0;
    }

    public _Fields fieldForId(int fieldId) {
      return _Fields.findByThriftId(fieldId);
    }

    public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
      schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
    }

    public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
      schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
      }

    @Override
    public String toString() {
      StringBuilder sb = new StringBuilder("isAuthenticated_result(");
      boolean first = true;

      sb.append("authError:");
      if (this.authError == null) {
        sb.append("null");
      } else {
        sb.append(this.authError);
      }
      first = false;
      if (!first) sb.append(", ");
      sb.append("serverError:");
      if (this.serverError == null) {
        sb.append("null");
      } else {
        sb.append(this.serverError);
      }
      first = false;
      sb.append(")");
      return sb.toString();
    }

    public void validate() throws org.apache.thrift.TException {
      // check for required fields
      // check for sub-struct validity
    }

    private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
      try {
        write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
      } catch (org.apache.thrift.TException te) {
        throw new java.io.IOException(te);
      }
    }

    private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
      try {
        read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
      } catch (org.apache.thrift.TException te) {
        throw new java.io.IOException(te);
      }
    }

    private static class isAuthenticated_resultStandardSchemeFactory implements SchemeFactory {
      public isAuthenticated_resultStandardScheme getScheme() {
        return new isAuthenticated_resultStandardScheme();
      }
    }

    private static class isAuthenticated_resultStandardScheme extends StandardScheme<isAuthenticated_result> {

      public void read(org.apache.thrift.protocol.TProtocol iprot, isAuthenticated_result struct) throws org.apache.thrift.TException {
        org.apache.thrift.protocol.TField schemeField;
        iprot.readStructBegin();
        while (true)
        {
          schemeField = iprot.readFieldBegin();
          if (schemeField.type == org.apache.thrift.protocol.TType.STOP) { 
            break;
          }
          switch (schemeField.id) {
            case 1: // AUTH_ERROR
              if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
                struct.authError = new TAuthorizationException();
                struct.authError.read(iprot);
                struct.setAuthErrorIsSet(true);
              } else { 
                org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
              }
              break;
            case 2: // SERVER_ERROR
              if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
                struct.serverError = new TInternalServerError();
                struct.serverError.read(iprot);
                struct.setServerErrorIsSet(true);
              } else { 
                org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
              }
              break;
            default:
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
          }
          iprot.readFieldEnd();
        }
        iprot.readStructEnd();

        // check for required fields of primitive type, which can't be checked in the validate method
        struct.validate();
      }

      public void write(org.apache.thrift.protocol.TProtocol oprot, isAuthenticated_result struct) throws org.apache.thrift.TException {
        struct.validate();

        oprot.writeStructBegin(STRUCT_DESC);
        if (struct.authError != null) {
          oprot.writeFieldBegin(AUTH_ERROR_FIELD_DESC);
          struct.authError.write(oprot);
          oprot.writeFieldEnd();
        }
        if (struct.serverError != null) {
          oprot.writeFieldBegin(SERVER_ERROR_FIELD_DESC);
          struct.serverError.write(oprot);
          oprot.writeFieldEnd();
        }
        oprot.writeFieldStop();
        oprot.writeStructEnd();
      }

    }

    private static class isAuthenticated_resultTupleSchemeFactory implements SchemeFactory {
      public isAuthenticated_resultTupleScheme getScheme() {
        return new isAuthenticated_resultTupleScheme();
      }
    }

    private static class isAuthenticated_resultTupleScheme extends TupleScheme<isAuthenticated_result> {

      @Override
      public void write(org.apache.thrift.protocol.TProtocol prot, isAuthenticated_result struct) throws org.apache.thrift.TException {
        TTupleProtocol oprot = (TTupleProtocol) prot;
        BitSet optionals = new BitSet();
        if (struct.isSetAuthError()) {
          optionals.set(0);
        }
        if (struct.isSetServerError()) {
          optionals.set(1);
        }
        oprot.writeBitSet(optionals, 2);
        if (struct.isSetAuthError()) {
          struct.authError.write(oprot);
        }
        if (struct.isSetServerError()) {
          struct.serverError.write(oprot);
        }
      }

      @Override
      public void read(org.apache.thrift.protocol.TProtocol prot, isAuthenticated_result struct) throws org.apache.thrift.TException {
        TTupleProtocol iprot = (TTupleProtocol) prot;
        BitSet incoming = iprot.readBitSet(2);
        if (incoming.get(0)) {
          struct.authError = new TAuthorizationException();
          struct.authError.read(iprot);
          struct.setAuthErrorIsSet(true);
        }
        if (incoming.get(1)) {
          struct.serverError = new TInternalServerError();
          struct.serverError.read(iprot);
          struct.setServerErrorIsSet(true);
        }
      }
    }

  }

  public static class whoami_args implements org.apache.thrift.TBase<whoami_args, whoami_args._Fields>, java.io.Serializable, Cloneable, Comparable<whoami_args>   {
    private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("whoami_args");

    private static final org.apache.thrift.protocol.TField USER_TOKEN_FIELD_DESC = new org.apache.thrift.protocol.TField("userToken", org.apache.thrift.protocol.TType.STRING, (short)1);

    private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
    static {
      schemes.put(StandardScheme.class, new whoami_argsStandardSchemeFactory());
      schemes.put(TupleScheme.class, new whoami_argsTupleSchemeFactory());
    }

    public String userToken; // required

    /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
    public enum _Fields implements org.apache.thrift.TFieldIdEnum {
      USER_TOKEN((short)1, "userToken");

      private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();

      static {
        for (_Fields field : EnumSet.allOf(_Fields.class)) {
          byName.put(field.getFieldName(), field);
        }
      }

      /**
       * Find the _Fields constant that matches fieldId, or null if its not found.
       */
      public static _Fields findByThriftId(int fieldId) {
        switch(fieldId) {
          case 1: // USER_TOKEN
            return USER_TOKEN;
          default:
            return null;
        }
      }

      /**
       * Find the _Fields constant that matches fieldId, throwing an exception
       * if it is not found.
       */
      public static _Fields findByThriftIdOrThrow(int fieldId) {
        _Fields fields = findByThriftId(fieldId);
        if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
        return fields;
      }

      /**
       * Find the _Fields constant that matches name, or null if its not found.
       */
      public static _Fields findByName(String name) {
        return byName.get(name);
      }

      private final short _thriftId;
      private final String _fieldName;

      _Fields(short thriftId, String fieldName) {
        _thriftId = thriftId;
        _fieldName = fieldName;
      }

      public short getThriftFieldId() {
        return _thriftId;
      }

      public String getFieldName() {
        return _fieldName;
      }
    }

    // isset id assignments
    public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
    static {
      Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
      tmpMap.put(_Fields.USER_TOKEN, new org.apache.thrift.meta_data.FieldMetaData("userToken", org.apache.thrift.TFieldRequirementType.DEFAULT, 
          new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING          , "Token")));
      metaDataMap = Collections.unmodifiableMap(tmpMap);
      org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(whoami_args.class, metaDataMap);
    }

    public whoami_args() {
    }

    public whoami_args(
      String userToken)
    {
      this();
      this.userToken = userToken;
    }

    /**
     * Performs a deep copy on <i>other</i>.
     */
    public whoami_args(whoami_args other) {
      if (other.isSetUserToken()) {
        this.userToken = other.userToken;
      }
    }

    public whoami_args deepCopy() {
      return new whoami_args(this);
    }

    @Override
    public void clear() {
      this.userToken = null;
    }

    public String getUserToken() {
      return this.userToken;
    }

    public whoami_args setUserToken(String userToken) {
      this.userToken = userToken;
      return this;
    }

    public void unsetUserToken() {
      this.userToken = null;
    }

    /** Returns true if field userToken is set (has been assigned a value) and false otherwise */
    public boolean isSetUserToken() {
      return this.userToken != null;
    }

    public void setUserTokenIsSet(boolean value) {
      if (!value) {
        this.userToken = null;
      }
    }

    public void setFieldValue(_Fields field, Object value) {
      switch (field) {
      case USER_TOKEN:
        if (value == null) {
          unsetUserToken();
        } else {
          setUserToken((String)value);
        }
        break;

      }
    }

    public Object getFieldValue(_Fields field) {
      switch (field) {
      case USER_TOKEN:
        return getUserToken();

      }
      throw new IllegalStateException();
    }

    /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
    public boolean isSet(_Fields field) {
      if (field == null) {
        throw new IllegalArgumentException();
      }

      switch (field) {
      case USER_TOKEN:
        return isSetUserToken();
      }
      throw new IllegalStateException();
    }

    @Override
    public boolean equals(Object that) {
      if (that == null)
        return false;
      if (that instanceof whoami_args)
        return this.equals((whoami_args)that);
      return false;
    }

    public boolean equals(whoami_args that) {
      if (that == null)
        return false;

      boolean this_present_userToken = true && this.isSetUserToken();
      boolean that_present_userToken = true && that.isSetUserToken();
      if (this_present_userToken || that_present_userToken) {
        if (!(this_present_userToken && that_present_userToken))
          return false;
        if (!this.userToken.equals(that.userToken))
          return false;
      }

      return true;
    }

    @Override
    public int hashCode() {
      return 0;
    }

    @Override
    public int compareTo(whoami_args other) {
      if (!getClass().equals(other.getClass())) {
        return getClass().getName().compareTo(other.getClass().getName());
      }

      int lastComparison = 0;

      lastComparison = Boolean.valueOf(isSetUserToken()).compareTo(other.isSetUserToken());
      if (lastComparison != 0) {
        return lastComparison;
      }
      if (isSetUserToken()) {
        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.userToken, other.userToken);
        if (lastComparison != 0) {
          return lastComparison;
        }
      }
      return 0;
    }

    public _Fields fieldForId(int fieldId) {
      return _Fields.findByThriftId(fieldId);
    }

    public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
      schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
    }

    public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
      schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
    }

    @Override
    public String toString() {
      StringBuilder sb = new StringBuilder("whoami_args(");
      boolean first = true;

      sb.append("userToken:");
      if (this.userToken == null) {
        sb.append("null");
      } else {
        sb.append(this.userToken);
      }
      first = false;
      sb.append(")");
      return sb.toString();
    }

    public void validate() throws org.apache.thrift.TException {
      // check for required fields
      // check for sub-struct validity
    }

    private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
      try {
        write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
      } catch (org.apache.thrift.TException te) {
        throw new java.io.IOException(te);
      }
    }

    private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
      try {
        read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
      } catch (org.apache.thrift.TException te) {
        throw new java.io.IOException(te);
      }
    }

    private static class whoami_argsStandardSchemeFactory implements SchemeFactory {
      public whoami_argsStandardScheme getScheme() {
        return new whoami_argsStandardScheme();
      }
    }

    private static class whoami_argsStandardScheme extends StandardScheme<whoami_args> {

      public void read(org.apache.thrift.protocol.TProtocol iprot, whoami_args struct) throws org.apache.thrift.TException {
        org.apache.thrift.protocol.TField schemeField;
        iprot.readStructBegin();
        while (true)
        {
          schemeField = iprot.readFieldBegin();
          if (schemeField.type == org.apache.thrift.protocol.TType.STOP) { 
            break;
          }
          switch (schemeField.id) {
            case 1: // USER_TOKEN
              if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
                struct.userToken = iprot.readString();
                struct.setUserTokenIsSet(true);
              } else { 
                org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
              }
              break;
            default:
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
          }
          iprot.readFieldEnd();
        }
        iprot.readStructEnd();

        // check for required fields of primitive type, which can't be checked in the validate method
        struct.validate();
      }

      public void write(org.apache.thrift.protocol.TProtocol oprot, whoami_args struct) throws org.apache.thrift.TException {
        struct.validate();

        oprot.writeStructBegin(STRUCT_DESC);
        if (struct.userToken != null) {
          oprot.writeFieldBegin(USER_TOKEN_FIELD_DESC);
          oprot.writeString(struct.userToken);
          oprot.writeFieldEnd();
        }
        oprot.writeFieldStop();
        oprot.writeStructEnd();
      }

    }

    private static class whoami_argsTupleSchemeFactory implements SchemeFactory {
      public whoami_argsTupleScheme getScheme() {
        return new whoami_argsTupleScheme();
      }
    }

    private static class whoami_argsTupleScheme extends TupleScheme<whoami_args> {

      @Override
      public void write(org.apache.thrift.protocol.TProtocol prot, whoami_args struct) throws org.apache.thrift.TException {
        TTupleProtocol oprot = (TTupleProtocol) prot;
        BitSet optionals = new BitSet();
        if (struct.isSetUserToken()) {
          optionals.set(0);
        }
        oprot.writeBitSet(optionals, 1);
        if (struct.isSetUserToken()) {
          oprot.writeString(struct.userToken);
        }
      }

      @Override
      public void read(org.apache.thrift.protocol.TProtocol prot, whoami_args struct) throws org.apache.thrift.TException {
        TTupleProtocol iprot = (TTupleProtocol) prot;
        BitSet incoming = iprot.readBitSet(1);
        if (incoming.get(0)) {
          struct.userToken = iprot.readString();
          struct.setUserTokenIsSet(true);
        }
      }
    }

  }

  public static class whoami_result implements org.apache.thrift.TBase<whoami_result, whoami_result._Fields>, java.io.Serializable, Cloneable, Comparable<whoami_result>   {
    private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("whoami_result");

    private static final org.apache.thrift.protocol.TField SUCCESS_FIELD_DESC = new org.apache.thrift.protocol.TField("success", org.apache.thrift.protocol.TType.STRUCT, (short)0);
    private static final org.apache.thrift.protocol.TField AUTH_ERROR_FIELD_DESC = new org.apache.thrift.protocol.TField("authError", org.apache.thrift.protocol.TType.STRUCT, (short)1);
    private static final org.apache.thrift.protocol.TField SERVER_ERROR_FIELD_DESC = new org.apache.thrift.protocol.TField("serverError", org.apache.thrift.protocol.TType.STRUCT, (short)2);

    private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
    static {
      schemes.put(StandardScheme.class, new whoami_resultStandardSchemeFactory());
      schemes.put(TupleScheme.class, new whoami_resultTupleSchemeFactory());
    }

    public UserInfo success; // required
    public TAuthorizationException authError; // required
    public TInternalServerError serverError; // required

    /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
    public enum _Fields implements org.apache.thrift.TFieldIdEnum {
      SUCCESS((short)0, "success"),
      AUTH_ERROR((short)1, "authError"),
      SERVER_ERROR((short)2, "serverError");

      private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();

      static {
        for (_Fields field : EnumSet.allOf(_Fields.class)) {
          byName.put(field.getFieldName(), field);
        }
      }

      /**
       * Find the _Fields constant that matches fieldId, or null if its not found.
       */
      public static _Fields findByThriftId(int fieldId) {
        switch(fieldId) {
          case 0: // SUCCESS
            return SUCCESS;
          case 1: // AUTH_ERROR
            return AUTH_ERROR;
          case 2: // SERVER_ERROR
            return SERVER_ERROR;
          default:
            return null;
        }
      }

      /**
       * Find the _Fields constant that matches fieldId, throwing an exception
       * if it is not found.
       */
      public static _Fields findByThriftIdOrThrow(int fieldId) {
        _Fields fields = findByThriftId(fieldId);
        if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
        return fields;
      }

      /**
       * Find the _Fields constant that matches name, or null if its not found.
       */
      public static _Fields findByName(String name) {
        return byName.get(name);
      }

      private final short _thriftId;
      private final String _fieldName;

      _Fields(short thriftId, String fieldName) {
        _thriftId = thriftId;
        _fieldName = fieldName;
      }

      public short getThriftFieldId() {
        return _thriftId;
      }

      public String getFieldName() {
        return _fieldName;
      }
    }

    // isset id assignments
    public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
    static {
      Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
      tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, 
          new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, UserInfo.class)));
      tmpMap.put(_Fields.AUTH_ERROR, new org.apache.thrift.meta_data.FieldMetaData("authError", org.apache.thrift.TFieldRequirementType.DEFAULT, 
          new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT)));
      tmpMap.put(_Fields.SERVER_ERROR, new org.apache.thrift.meta_data.FieldMetaData("serverError", org.apache.thrift.TFieldRequirementType.DEFAULT, 
          new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT)));
      metaDataMap = Collections.unmodifiableMap(tmpMap);
      org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(whoami_result.class, metaDataMap);
    }

    public whoami_result() {
    }

    public whoami_result(
      UserInfo success,
      TAuthorizationException authError,
      TInternalServerError serverError)
    {
      this();
      this.success = success;
      this.authError = authError;
      this.serverError = serverError;
    }

    /**
     * Performs a deep copy on <i>other</i>.
     */
    public whoami_result(whoami_result other) {
      if (other.isSetSuccess()) {
        this.success = new UserInfo(other.success);
      }
      if (other.isSetAuthError()) {
        this.authError = new TAuthorizationException(other.authError);
      }
      if (other.isSetServerError()) {
        this.serverError = new TInternalServerError(other.serverError);
      }
    }

    public whoami_result deepCopy() {
      return new whoami_result(this);
    }

    @Override
    public void clear() {
      this.success = null;
      this.authError = null;
      this.serverError = null;
    }

    public UserInfo getSuccess() {
      return this.success;
    }

    public whoami_result setSuccess(UserInfo success) {
      this.success = success;
      return this;
    }

    public void unsetSuccess() {
      this.success = null;
    }

    /** Returns true if field success is set (has been assigned a value) and false otherwise */
    public boolean isSetSuccess() {
      return this.success != null;
    }

    public void setSuccessIsSet(boolean value) {
      if (!value) {
        this.success = null;
      }
    }

    public TAuthorizationException getAuthError() {
      return this.authError;
    }

    public whoami_result setAuthError(TAuthorizationException authError) {
      this.authError = authError;
      return this;
    }

    public void unsetAuthError() {
      this.authError = null;
    }

    /** Returns true if field authError is set (has been assigned a value) and false otherwise */
    public boolean isSetAuthError() {
      return this.authError != null;
    }

    public void setAuthErrorIsSet(boolean value) {
      if (!value) {
        this.authError = null;
      }
    }

    public TInternalServerError getServerError() {
      return this.serverError;
    }

    public whoami_result setServerError(TInternalServerError serverError) {
      this.serverError = serverError;
      return this;
    }

    public void unsetServerError() {
      this.serverError = null;
    }

    /** Returns true if field serverError is set (has been assigned a value) and false otherwise */
    public boolean isSetServerError() {
      return this.serverError != null;
    }

    public void setServerErrorIsSet(boolean value) {
      if (!value) {
        this.serverError = null;
      }
    }

    public void setFieldValue(_Fields field, Object value) {
      switch (field) {
      case SUCCESS:
        if (value == null) {
          unsetSuccess();
        } else {
          setSuccess((UserInfo)value);
        }
        break;

      case AUTH_ERROR:
        if (value == null) {
          unsetAuthError();
        } else {
          setAuthError((TAuthorizationException)value);
        }
        break;

      case SERVER_ERROR:
        if (value == null) {
          unsetServerError();
        } else {
          setServerError((TInternalServerError)value);
        }
        break;

      }
    }

    public Object getFieldValue(_Fields field) {
      switch (field) {
      case SUCCESS:
        return getSuccess();

      case AUTH_ERROR:
        return getAuthError();

      case SERVER_ERROR:
        return getServerError();

      }
      throw new IllegalStateException();
    }

    /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
    public boolean isSet(_Fields field) {
      if (field == null) {
        throw new IllegalArgumentException();
      }

      switch (field) {
      case SUCCESS:
        return isSetSuccess();
      case AUTH_ERROR:
        return isSetAuthError();
      case SERVER_ERROR:
        return isSetServerError();
      }
      throw new IllegalStateException();
    }

    @Override
    public boolean equals(Object that) {
      if (that == null)
        return false;
      if (that instanceof whoami_result)
        return this.equals((whoami_result)that);
      return false;
    }

    public boolean equals(whoami_result that) {
      if (that == null)
        return false;

      boolean this_present_success = true && this.isSetSuccess();
      boolean that_present_success = true && that.isSetSuccess();
      if (this_present_success || that_present_success) {
        if (!(this_present_success && that_present_success))
          return false;
        if (!this.success.equals(that.success))
          return false;
      }

      boolean this_present_authError = true && this.isSetAuthError();
      boolean that_present_authError = true && that.isSetAuthError();
      if (this_present_authError || that_present_authError) {
        if (!(this_present_authError && that_present_authError))
          return false;
        if (!this.authError.equals(that.authError))
          return false;
      }

      boolean this_present_serverError = true && this.isSetServerError();
      boolean that_present_serverError = true && that.isSetServerError();
      if (this_present_serverError || that_present_serverError) {
        if (!(this_present_serverError && that_present_serverError))
          return false;
        if (!this.serverError.equals(that.serverError))
          return false;
      }

      return true;
    }

    @Override
    public int hashCode() {
      return 0;
    }

    @Override
    public int compareTo(whoami_result other) {
      if (!getClass().equals(other.getClass())) {
        return getClass().getName().compareTo(other.getClass().getName());
      }

      int lastComparison = 0;

      lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(other.isSetSuccess());
      if (lastComparison != 0) {
        return lastComparison;
      }
      if (isSetSuccess()) {
        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, other.success);
        if (lastComparison != 0) {
          return lastComparison;
        }
      }
      lastComparison = Boolean.valueOf(isSetAuthError()).compareTo(other.isSetAuthError());
      if (lastComparison != 0) {
        return lastComparison;
      }
      if (isSetAuthError()) {
        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.authError, other.authError);
        if (lastComparison != 0) {
          return lastComparison;
        }
      }
      lastComparison = Boolean.valueOf(isSetServerError()).compareTo(other.isSetServerError());
      if (lastComparison != 0) {
        return lastComparison;
      }
      if (isSetServerError()) {
        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.serverError, other.serverError);
        if (lastComparison != 0) {
          return lastComparison;
        }
      }
      return 0;
    }

    public _Fields fieldForId(int fieldId) {
      return _Fields.findByThriftId(fieldId);
    }

    public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
      schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
    }

    public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
      schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
      }

    @Override
    public String toString() {
      StringBuilder sb = new StringBuilder("whoami_result(");
      boolean first = true;

      sb.append("success:");
      if (this.success == null) {
        sb.append("null");
      } else {
        sb.append(this.success);
      }
      first = false;
      if (!first) sb.append(", ");
      sb.append("authError:");
      if (this.authError == null) {
        sb.append("null");
      } else {
        sb.append(this.authError);
      }
      first = false;
      if (!first) sb.append(", ");
      sb.append("serverError:");
      if (this.serverError == null) {
        sb.append("null");
      } else {
        sb.append(this.serverError);
      }
      first = false;
      sb.append(")");
      return sb.toString();
    }

    public void validate() throws org.apache.thrift.TException {
      // check for required fields
      // check for sub-struct validity
      if (success != null) {
        success.validate();
      }
    }

    private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
      try {
        write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
      } catch (org.apache.thrift.TException te) {
        throw new java.io.IOException(te);
      }
    }

    private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
      try {
        read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
      } catch (org.apache.thrift.TException te) {
        throw new java.io.IOException(te);
      }
    }

    private static class whoami_resultStandardSchemeFactory implements SchemeFactory {
      public whoami_resultStandardScheme getScheme() {
        return new whoami_resultStandardScheme();
      }
    }

    private static class whoami_resultStandardScheme extends StandardScheme<whoami_result> {

      public void read(org.apache.thrift.protocol.TProtocol iprot, whoami_result struct) throws org.apache.thrift.TException {
        org.apache.thrift.protocol.TField schemeField;
        iprot.readStructBegin();
        while (true)
        {
          schemeField = iprot.readFieldBegin();
          if (schemeField.type == org.apache.thrift.protocol.TType.STOP) { 
            break;
          }
          switch (schemeField.id) {
            case 0: // SUCCESS
              if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
                struct.success = new UserInfo();
                struct.success.read(iprot);
                struct.setSuccessIsSet(true);
              } else { 
                org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
              }
              break;
            case 1: // AUTH_ERROR
              if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
                struct.authError = new TAuthorizationException();
                struct.authError.read(iprot);
                struct.setAuthErrorIsSet(true);
              } else { 
                org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
              }
              break;
            case 2: // SERVER_ERROR
              if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
                struct.serverError = new TInternalServerError();
                struct.serverError.read(iprot);
                struct.setServerErrorIsSet(true);
              } else { 
                org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
              }
              break;
            default:
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
          }
          iprot.readFieldEnd();
        }
        iprot.readStructEnd();

        // check for required fields of primitive type, which can't be checked in the validate method
        struct.validate();
      }

      public void write(org.apache.thrift.protocol.TProtocol oprot, whoami_result struct) throws org.apache.thrift.TException {
        struct.validate();

        oprot.writeStructBegin(STRUCT_DESC);
        if (struct.success != null) {
          oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
          struct.success.write(oprot);
          oprot.writeFieldEnd();
        }
        if (struct.authError != null) {
          oprot.writeFieldBegin(AUTH_ERROR_FIELD_DESC);
          struct.authError.write(oprot);
          oprot.writeFieldEnd();
        }
        if (struct.serverError != null) {
          oprot.writeFieldBegin(SERVER_ERROR_FIELD_DESC);
          struct.serverError.write(oprot);
          oprot.writeFieldEnd();
        }
        oprot.writeFieldStop();
        oprot.writeStructEnd();
      }

    }

    private static class whoami_resultTupleSchemeFactory implements SchemeFactory {
      public whoami_resultTupleScheme getScheme() {
        return new whoami_resultTupleScheme();
      }
    }

    private static class whoami_resultTupleScheme extends TupleScheme<whoami_result> {

      @Override
      public void write(org.apache.thrift.protocol.TProtocol prot, whoami_result struct) throws org.apache.thrift.TException {
        TTupleProtocol oprot = (TTupleProtocol) prot;
        BitSet optionals = new BitSet();
        if (struct.isSetSuccess()) {
          optionals.set(0);
        }
        if (struct.isSetAuthError()) {
          optionals.set(1);
        }
        if (struct.isSetServerError()) {
          optionals.set(2);
        }
        oprot.writeBitSet(optionals, 3);
        if (struct.isSetSuccess()) {
          struct.success.write(oprot);
        }
        if (struct.isSetAuthError()) {
          struct.authError.write(oprot);
        }
        if (struct.isSetServerError()) {
          struct.serverError.write(oprot);
        }
      }

      @Override
      public void read(org.apache.thrift.protocol.TProtocol prot, whoami_result struct) throws org.apache.thrift.TException {
        TTupleProtocol iprot = (TTupleProtocol) prot;
        BitSet incoming = iprot.readBitSet(3);
        if (incoming.get(0)) {
          struct.success = new UserInfo();
          struct.success.read(iprot);
          struct.setSuccessIsSet(true);
        }
        if (incoming.get(1)) {
          struct.authError = new TAuthorizationException();
          struct.authError.read(iprot);
          struct.setAuthErrorIsSet(true);
        }
        if (incoming.get(2)) {
          struct.serverError = new TInternalServerError();
          struct.serverError.read(iprot);
          struct.setServerErrorIsSet(true);
        }
      }
    }

  }

  public static class invalidateSession_args implements org.apache.thrift.TBase<invalidateSession_args, invalidateSession_args._Fields>, java.io.Serializable, Cloneable, Comparable<invalidateSession_args>   {
    private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("invalidateSession_args");

    private static final org.apache.thrift.protocol.TField USER_TOKEN_FIELD_DESC = new org.apache.thrift.protocol.TField("userToken", org.apache.thrift.protocol.TType.STRING, (short)1);

    private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
    static {
      schemes.put(StandardScheme.class, new invalidateSession_argsStandardSchemeFactory());
      schemes.put(TupleScheme.class, new invalidateSession_argsTupleSchemeFactory());
    }

    public String userToken; // required

    /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
    public enum _Fields implements org.apache.thrift.TFieldIdEnum {
      USER_TOKEN((short)1, "userToken");

      private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();

      static {
        for (_Fields field : EnumSet.allOf(_Fields.class)) {
          byName.put(field.getFieldName(), field);
        }
      }

      /**
       * Find the _Fields constant that matches fieldId, or null if its not found.
       */
      public static _Fields findByThriftId(int fieldId) {
        switch(fieldId) {
          case 1: // USER_TOKEN
            return USER_TOKEN;
          default:
            return null;
        }
      }

      /**
       * Find the _Fields constant that matches fieldId, throwing an exception
       * if it is not found.
       */
      public static _Fields findByThriftIdOrThrow(int fieldId) {
        _Fields fields = findByThriftId(fieldId);
        if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
        return fields;
      }

      /**
       * Find the _Fields constant that matches name, or null if its not found.
       */
      public static _Fields findByName(String name) {
        return byName.get(name);
      }

      private final short _thriftId;
      private final String _fieldName;

      _Fields(short thriftId, String fieldName) {
        _thriftId = thriftId;
        _fieldName = fieldName;
      }

      public short getThriftFieldId() {
        return _thriftId;
      }

      public String getFieldName() {
        return _fieldName;
      }
    }

    // isset id assignments
    public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
    static {
      Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
      tmpMap.put(_Fields.USER_TOKEN, new org.apache.thrift.meta_data.FieldMetaData("userToken", org.apache.thrift.TFieldRequirementType.DEFAULT, 
          new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING          , "Token")));
      metaDataMap = Collections.unmodifiableMap(tmpMap);
      org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(invalidateSession_args.class, metaDataMap);
    }

    public invalidateSession_args() {
    }

    public invalidateSession_args(
      String userToken)
    {
      this();
      this.userToken = userToken;
    }

    /**
     * Performs a deep copy on <i>other</i>.
     */
    public invalidateSession_args(invalidateSession_args other) {
      if (other.isSetUserToken()) {
        this.userToken = other.userToken;
      }
    }

    public invalidateSession_args deepCopy() {
      return new invalidateSession_args(this);
    }

    @Override
    public void clear() {
      this.userToken = null;
    }

    public String getUserToken() {
      return this.userToken;
    }

    public invalidateSession_args setUserToken(String userToken) {
      this.userToken = userToken;
      return this;
    }

    public void unsetUserToken() {
      this.userToken = null;
    }

    /** Returns true if field userToken is set (has been assigned a value) and false otherwise */
    public boolean isSetUserToken() {
      return this.userToken != null;
    }

    public void setUserTokenIsSet(boolean value) {
      if (!value) {
        this.userToken = null;
      }
    }

    public void setFieldValue(_Fields field, Object value) {
      switch (field) {
      case USER_TOKEN:
        if (value == null) {
          unsetUserToken();
        } else {
          setUserToken((String)value);
        }
        break;

      }
    }

    public Object getFieldValue(_Fields field) {
      switch (field) {
      case USER_TOKEN:
        return getUserToken();

      }
      throw new IllegalStateException();
    }

    /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
    public boolean isSet(_Fields field) {
      if (field == null) {
        throw new IllegalArgumentException();
      }

      switch (field) {
      case USER_TOKEN:
        return isSetUserToken();
      }
      throw new IllegalStateException();
    }

    @Override
    public boolean equals(Object that) {
      if (that == null)
        return false;
      if (that instanceof invalidateSession_args)
        return this.equals((invalidateSession_args)that);
      return false;
    }

    public boolean equals(invalidateSession_args that) {
      if (that == null)
        return false;

      boolean this_present_userToken = true && this.isSetUserToken();
      boolean that_present_userToken = true && that.isSetUserToken();
      if (this_present_userToken || that_present_userToken) {
        if (!(this_present_userToken && that_present_userToken))
          return false;
        if (!this.userToken.equals(that.userToken))
          return false;
      }

      return true;
    }

    @Override
    public int hashCode() {
      return 0;
    }

    @Override
    public int compareTo(invalidateSession_args other) {
      if (!getClass().equals(other.getClass())) {
        return getClass().getName().compareTo(other.getClass().getName());
      }

      int lastComparison = 0;

      lastComparison = Boolean.valueOf(isSetUserToken()).compareTo(other.isSetUserToken());
      if (lastComparison != 0) {
        return lastComparison;
      }
      if (isSetUserToken()) {
        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.userToken, other.userToken);
        if (lastComparison != 0) {
          return lastComparison;
        }
      }
      return 0;
    }

    public _Fields fieldForId(int fieldId) {
      return _Fields.findByThriftId(fieldId);
    }

    public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
      schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
    }

    public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
      schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
    }

    @Override
    public String toString() {
      StringBuilder sb = new StringBuilder("invalidateSession_args(");
      boolean first = true;

      sb.append("userToken:");
      if (this.userToken == null) {
        sb.append("null");
      } else {
        sb.append(this.userToken);
      }
      first = false;
      sb.append(")");
      return sb.toString();
    }

    public void validate() throws org.apache.thrift.TException {
      // check for required fields
      // check for sub-struct validity
    }

    private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
      try {
        write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
      } catch (org.apache.thrift.TException te) {
        throw new java.io.IOException(te);
      }
    }

    private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
      try {
        read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
      } catch (org.apache.thrift.TException te) {
        throw new java.io.IOException(te);
      }
    }

    private static class invalidateSession_argsStandardSchemeFactory implements SchemeFactory {
      public invalidateSession_argsStandardScheme getScheme() {
        return new invalidateSession_argsStandardScheme();
      }
    }

    private static class invalidateSession_argsStandardScheme extends StandardScheme<invalidateSession_args> {

      public void read(org.apache.thrift.protocol.TProtocol iprot, invalidateSession_args struct) throws org.apache.thrift.TException {
        org.apache.thrift.protocol.TField schemeField;
        iprot.readStructBegin();
        while (true)
        {
          schemeField = iprot.readFieldBegin();
          if (schemeField.type == org.apache.thrift.protocol.TType.STOP) { 
            break;
          }
          switch (schemeField.id) {
            case 1: // USER_TOKEN
              if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
                struct.userToken = iprot.readString();
                struct.setUserTokenIsSet(true);
              } else { 
                org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
              }
              break;
            default:
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
          }
          iprot.readFieldEnd();
        }
        iprot.readStructEnd();

        // check for required fields of primitive type, which can't be checked in the validate method
        struct.validate();
      }

      public void write(org.apache.thrift.protocol.TProtocol oprot, invalidateSession_args struct) throws org.apache.thrift.TException {
        struct.validate();

        oprot.writeStructBegin(STRUCT_DESC);
        if (struct.userToken != null) {
          oprot.writeFieldBegin(USER_TOKEN_FIELD_DESC);
          oprot.writeString(struct.userToken);
          oprot.writeFieldEnd();
        }
        oprot.writeFieldStop();
        oprot.writeStructEnd();
      }

    }

    private static class invalidateSession_argsTupleSchemeFactory implements SchemeFactory {
      public invalidateSession_argsTupleScheme getScheme() {
        return new invalidateSession_argsTupleScheme();
      }
    }

    private static class invalidateSession_argsTupleScheme extends TupleScheme<invalidateSession_args> {

      @Override
      public void write(org.apache.thrift.protocol.TProtocol prot, invalidateSession_args struct) throws org.apache.thrift.TException {
        TTupleProtocol oprot = (TTupleProtocol) prot;
        BitSet optionals = new BitSet();
        if (struct.isSetUserToken()) {
          optionals.set(0);
        }
        oprot.writeBitSet(optionals, 1);
        if (struct.isSetUserToken()) {
          oprot.writeString(struct.userToken);
        }
      }

      @Override
      public void read(org.apache.thrift.protocol.TProtocol prot, invalidateSession_args struct) throws org.apache.thrift.TException {
        TTupleProtocol iprot = (TTupleProtocol) prot;
        BitSet incoming = iprot.readBitSet(1);
        if (incoming.get(0)) {
          struct.userToken = iprot.readString();
          struct.setUserTokenIsSet(true);
        }
      }
    }

  }

  public static class invalidateSession_result implements org.apache.thrift.TBase<invalidateSession_result, invalidateSession_result._Fields>, java.io.Serializable, Cloneable, Comparable<invalidateSession_result>   {
    private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("invalidateSession_result");


    private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
    static {
      schemes.put(StandardScheme.class, new invalidateSession_resultStandardSchemeFactory());
      schemes.put(TupleScheme.class, new invalidateSession_resultTupleSchemeFactory());
    }


    /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
    public enum _Fields implements org.apache.thrift.TFieldIdEnum {
;

      private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();

      static {
        for (_Fields field : EnumSet.allOf(_Fields.class)) {
          byName.put(field.getFieldName(), field);
        }
      }

      /**
       * Find the _Fields constant that matches fieldId, or null if its not found.
       */
      public static _Fields findByThriftId(int fieldId) {
        switch(fieldId) {
          default:
            return null;
        }
      }

      /**
       * Find the _Fields constant that matches fieldId, throwing an exception
       * if it is not found.
       */
      public static _Fields findByThriftIdOrThrow(int fieldId) {
        _Fields fields = findByThriftId(fieldId);
        if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
        return fields;
      }

      /**
       * Find the _Fields constant that matches name, or null if its not found.
       */
      public static _Fields findByName(String name) {
        return byName.get(name);
      }

      private final short _thriftId;
      private final String _fieldName;

      _Fields(short thriftId, String fieldName) {
        _thriftId = thriftId;
        _fieldName = fieldName;
      }

      public short getThriftFieldId() {
        return _thriftId;
      }

      public String getFieldName() {
        return _fieldName;
      }
    }
    public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
    static {
      Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
      metaDataMap = Collections.unmodifiableMap(tmpMap);
      org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(invalidateSession_result.class, metaDataMap);
    }

    public invalidateSession_result() {
    }

    /**
     * Performs a deep copy on <i>other</i>.
     */
    public invalidateSession_result(invalidateSession_result other) {
    }

    public invalidateSession_result deepCopy() {
      return new invalidateSession_result(this);
    }

    @Override
    public void clear() {
    }

    public void setFieldValue(_Fields field, Object value) {
      switch (field) {
      }
    }

    public Object getFieldValue(_Fields field) {
      switch (field) {
      }
      throw new IllegalStateException();
    }

    /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
    public boolean isSet(_Fields field) {
      if (field == null) {
        throw new IllegalArgumentException();
      }

      switch (field) {
      }
      throw new IllegalStateException();
    }

    @Override
    public boolean equals(Object that) {
      if (that == null)
        return false;
      if (that instanceof invalidateSession_result)
        return this.equals((invalidateSession_result)that);
      return false;
    }

    public boolean equals(invalidateSession_result that) {
      if (that == null)
        return false;

      return true;
    }

    @Override
    public int hashCode() {
      return 0;
    }

    @Override
    public int compareTo(invalidateSession_result other) {
      if (!getClass().equals(other.getClass())) {
        return getClass().getName().compareTo(other.getClass().getName());
      }

      int lastComparison = 0;

      return 0;
    }

    public _Fields fieldForId(int fieldId) {
      return _Fields.findByThriftId(fieldId);
    }

    public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
      schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
    }

    public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
      schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
      }

    @Override
    public String toString() {
      StringBuilder sb = new StringBuilder("invalidateSession_result(");
      boolean first = true;

      sb.append(")");
      return sb.toString();
    }

    public void validate() throws org.apache.thrift.TException {
      // check for required fields
      // check for sub-struct validity
    }

    private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
      try {
        write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
      } catch (org.apache.thrift.TException te) {
        throw new java.io.IOException(te);
      }
    }

    private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
      try {
        read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
      } catch (org.apache.thrift.TException te) {
        throw new java.io.IOException(te);
      }
    }

    private static class invalidateSession_resultStandardSchemeFactory implements SchemeFactory {
      public invalidateSession_resultStandardScheme getScheme() {
        return new invalidateSession_resultStandardScheme();
      }
    }

    private static class invalidateSession_resultStandardScheme extends StandardScheme<invalidateSession_result> {

      public void read(org.apache.thrift.protocol.TProtocol iprot, invalidateSession_result struct) throws org.apache.thrift.TException {
        org.apache.thrift.protocol.TField schemeField;
        iprot.readStructBegin();
        while (true)
        {
          schemeField = iprot.readFieldBegin();
          if (schemeField.type == org.apache.thrift.protocol.TType.STOP) { 
            break;
          }
          switch (schemeField.id) {
            default:
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
          }
          iprot.readFieldEnd();
        }
        iprot.readStructEnd();

        // check for required fields of primitive type, which can't be checked in the validate method
        struct.validate();
      }

      public void write(org.apache.thrift.protocol.TProtocol oprot, invalidateSession_result struct) throws org.apache.thrift.TException {
        struct.validate();

        oprot.writeStructBegin(STRUCT_DESC);
        oprot.writeFieldStop();
        oprot.writeStructEnd();
      }

    }

    private static class invalidateSession_resultTupleSchemeFactory implements SchemeFactory {
      public invalidateSession_resultTupleScheme getScheme() {
        return new invalidateSession_resultTupleScheme();
      }
    }

    private static class invalidateSession_resultTupleScheme extends TupleScheme<invalidateSession_result> {

      @Override
      public void write(org.apache.thrift.protocol.TProtocol prot, invalidateSession_result struct) throws org.apache.thrift.TException {
        TTupleProtocol oprot = (TTupleProtocol) prot;
      }

      @Override
      public void read(org.apache.thrift.protocol.TProtocol prot, invalidateSession_result struct) throws org.apache.thrift.TException {
        TTupleProtocol iprot = (TTupleProtocol) prot;
      }
    }

  }

  public static class getUserList_args implements org.apache.thrift.TBase<getUserList_args, getUserList_args._Fields>, java.io.Serializable, Cloneable, Comparable<getUserList_args>   {
    private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getUserList_args");

    private static final org.apache.thrift.protocol.TField USER_TOKEN_FIELD_DESC = new org.apache.thrift.protocol.TField("userToken", org.apache.thrift.protocol.TType.STRING, (short)1);
    private static final org.apache.thrift.protocol.TField PAGE_FIELD_DESC = new org.apache.thrift.protocol.TField("page", org.apache.thrift.protocol.TType.I32, (short)2);

    private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
    static {
      schemes.put(StandardScheme.class, new getUserList_argsStandardSchemeFactory());
      schemes.put(TupleScheme.class, new getUserList_argsTupleSchemeFactory());
    }

    public String userToken; // required
    public int page; // required

    /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
    public enum _Fields implements org.apache.thrift.TFieldIdEnum {
      USER_TOKEN((short)1, "userToken"),
      PAGE((short)2, "page");

      private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();

      static {
        for (_Fields field : EnumSet.allOf(_Fields.class)) {
          byName.put(field.getFieldName(), field);
        }
      }

      /**
       * Find the _Fields constant that matches fieldId, or null if its not found.
       */
      public static _Fields findByThriftId(int fieldId) {
        switch(fieldId) {
          case 1: // USER_TOKEN
            return USER_TOKEN;
          case 2: // PAGE
            return PAGE;
          default:
            return null;
        }
      }

      /**
       * Find the _Fields constant that matches fieldId, throwing an exception
       * if it is not found.
       */
      public static _Fields findByThriftIdOrThrow(int fieldId) {
        _Fields fields = findByThriftId(fieldId);
        if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
        return fields;
      }

      /**
       * Find the _Fields constant that matches name, or null if its not found.
       */
      public static _Fields findByName(String name) {
        return byName.get(name);
      }

      private final short _thriftId;
      private final String _fieldName;

      _Fields(short thriftId, String fieldName) {
        _thriftId = thriftId;
        _fieldName = fieldName;
      }

      public short getThriftFieldId() {
        return _thriftId;
      }

      public String getFieldName() {
        return _fieldName;
      }
    }

    // isset id assignments
    private static final int __PAGE_ISSET_ID = 0;
    private byte __isset_bitfield = 0;
    public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
    static {
      Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
      tmpMap.put(_Fields.USER_TOKEN, new org.apache.thrift.meta_data.FieldMetaData("userToken", org.apache.thrift.TFieldRequirementType.DEFAULT, 
          new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING          , "Token")));
      tmpMap.put(_Fields.PAGE, new org.apache.thrift.meta_data.FieldMetaData("page", org.apache.thrift.TFieldRequirementType.DEFAULT, 
          new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32)));
      metaDataMap = Collections.unmodifiableMap(tmpMap);
      org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getUserList_args.class, metaDataMap);
    }

    public getUserList_args() {
    }

    public getUserList_args(
      String userToken,
      int page)
    {
      this();
      this.userToken = userToken;
      this.page = page;
      setPageIsSet(true);
    }

    /**
     * Performs a deep copy on <i>other</i>.
     */
    public getUserList_args(getUserList_args other) {
      __isset_bitfield = other.__isset_bitfield;
      if (other.isSetUserToken()) {
        this.userToken = other.userToken;
      }
      this.page = other.page;
    }

    public getUserList_args deepCopy() {
      return new getUserList_args(this);
    }

    @Override
    public void clear() {
      this.userToken = null;
      setPageIsSet(false);
      this.page = 0;
    }

    public String getUserToken() {
      return this.userToken;
    }

    public getUserList_args setUserToken(String userToken) {
      this.userToken = userToken;
      return this;
    }

    public void unsetUserToken() {
      this.userToken = null;
    }

    /** Returns true if field userToken is set (has been assigned a value) and false otherwise */
    public boolean isSetUserToken() {
      return this.userToken != null;
    }

    public void setUserTokenIsSet(boolean value) {
      if (!value) {
        this.userToken = null;
      }
    }

    public int getPage() {
      return this.page;
    }

    public getUserList_args setPage(int page) {
      this.page = page;
      setPageIsSet(true);
      return this;
    }

    public void unsetPage() {
      __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __PAGE_ISSET_ID);
    }

    /** Returns true if field page is set (has been assigned a value) and false otherwise */
    public boolean isSetPage() {
      return EncodingUtils.testBit(__isset_bitfield, __PAGE_ISSET_ID);
    }

    public void setPageIsSet(boolean value) {
      __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __PAGE_ISSET_ID, value);
    }

    public void setFieldValue(_Fields field, Object value) {
      switch (field) {
      case USER_TOKEN:
        if (value == null) {
          unsetUserToken();
        } else {
          setUserToken((String)value);
        }
        break;

      case PAGE:
        if (value == null) {
          unsetPage();
        } else {
          setPage((Integer)value);
        }
        break;

      }
    }

    public Object getFieldValue(_Fields field) {
      switch (field) {
      case USER_TOKEN:
        return getUserToken();

      case PAGE:
        return Integer.valueOf(getPage());

      }
      throw new IllegalStateException();
    }

    /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
    public boolean isSet(_Fields field) {
      if (field == null) {
        throw new IllegalArgumentException();
      }

      switch (field) {
      case USER_TOKEN:
        return isSetUserToken();
      case PAGE:
        return isSetPage();
      }
      throw new IllegalStateException();
    }

    @Override
    public boolean equals(Object that) {
      if (that == null)
        return false;
      if (that instanceof getUserList_args)
        return this.equals((getUserList_args)that);
      return false;
    }

    public boolean equals(getUserList_args that) {
      if (that == null)
        return false;

      boolean this_present_userToken = true && this.isSetUserToken();
      boolean that_present_userToken = true && that.isSetUserToken();
      if (this_present_userToken || that_present_userToken) {
        if (!(this_present_userToken && that_present_userToken))
          return false;
        if (!this.userToken.equals(that.userToken))
          return false;
      }

      boolean this_present_page = true;
      boolean that_present_page = true;
      if (this_present_page || that_present_page) {
        if (!(this_present_page && that_present_page))
          return false;
        if (this.page != that.page)
          return false;
      }

      return true;
    }

    @Override
    public int hashCode() {
      return 0;
    }

    @Override
    public int compareTo(getUserList_args other) {
      if (!getClass().equals(other.getClass())) {
        return getClass().getName().compareTo(other.getClass().getName());
      }

      int lastComparison = 0;

      lastComparison = Boolean.valueOf(isSetUserToken()).compareTo(other.isSetUserToken());
      if (lastComparison != 0) {
        return lastComparison;
      }
      if (isSetUserToken()) {
        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.userToken, other.userToken);
        if (lastComparison != 0) {
          return lastComparison;
        }
      }
      lastComparison = Boolean.valueOf(isSetPage()).compareTo(other.isSetPage());
      if (lastComparison != 0) {
        return lastComparison;
      }
      if (isSetPage()) {
        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.page, other.page);
        if (lastComparison != 0) {
          return lastComparison;
        }
      }
      return 0;
    }

    public _Fields fieldForId(int fieldId) {
      return _Fields.findByThriftId(fieldId);
    }

    public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
      schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
    }

    public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
      schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
    }

    @Override
    public String toString() {
      StringBuilder sb = new StringBuilder("getUserList_args(");
      boolean first = true;

      sb.append("userToken:");
      if (this.userToken == null) {
        sb.append("null");
      } else {
        sb.append(this.userToken);
      }
      first = false;
      if (!first) sb.append(", ");
      sb.append("page:");
      sb.append(this.page);
      first = false;
      sb.append(")");
      return sb.toString();
    }

    public void validate() throws org.apache.thrift.TException {
      // check for required fields
      // check for sub-struct validity
    }

    private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
      try {
        write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
      } catch (org.apache.thrift.TException te) {
        throw new java.io.IOException(te);
      }
    }

    private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
      try {
        // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor.
        __isset_bitfield = 0;
        read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
      } catch (org.apache.thrift.TException te) {
        throw new java.io.IOException(te);
      }
    }

    private static class getUserList_argsStandardSchemeFactory implements SchemeFactory {
      public getUserList_argsStandardScheme getScheme() {
        return new getUserList_argsStandardScheme();
      }
    }

    private static class getUserList_argsStandardScheme extends StandardScheme<getUserList_args> {

      public void read(org.apache.thrift.protocol.TProtocol iprot, getUserList_args struct) throws org.apache.thrift.TException {
        org.apache.thrift.protocol.TField schemeField;
        iprot.readStructBegin();
        while (true)
        {
          schemeField = iprot.readFieldBegin();
          if (schemeField.type == org.apache.thrift.protocol.TType.STOP) { 
            break;
          }
          switch (schemeField.id) {
            case 1: // USER_TOKEN
              if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
                struct.userToken = iprot.readString();
                struct.setUserTokenIsSet(true);
              } else { 
                org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
              }
              break;
            case 2: // PAGE
              if (schemeField.type == org.apache.thrift.protocol.TType.I32) {
                struct.page = iprot.readI32();
                struct.setPageIsSet(true);
              } else { 
                org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
              }
              break;
            default:
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
          }
          iprot.readFieldEnd();
        }
        iprot.readStructEnd();

        // check for required fields of primitive type, which can't be checked in the validate method
        struct.validate();
      }

      public void write(org.apache.thrift.protocol.TProtocol oprot, getUserList_args struct) throws org.apache.thrift.TException {
        struct.validate();

        oprot.writeStructBegin(STRUCT_DESC);
        if (struct.userToken != null) {
          oprot.writeFieldBegin(USER_TOKEN_FIELD_DESC);
          oprot.writeString(struct.userToken);
          oprot.writeFieldEnd();
        }
        oprot.writeFieldBegin(PAGE_FIELD_DESC);
        oprot.writeI32(struct.page);
        oprot.writeFieldEnd();
        oprot.writeFieldStop();
        oprot.writeStructEnd();
      }

    }

    private static class getUserList_argsTupleSchemeFactory implements SchemeFactory {
      public getUserList_argsTupleScheme getScheme() {
        return new getUserList_argsTupleScheme();
      }
    }

    private static class getUserList_argsTupleScheme extends TupleScheme<getUserList_args> {

      @Override
      public void write(org.apache.thrift.protocol.TProtocol prot, getUserList_args struct) throws org.apache.thrift.TException {
        TTupleProtocol oprot = (TTupleProtocol) prot;
        BitSet optionals = new BitSet();
        if (struct.isSetUserToken()) {
          optionals.set(0);
        }
        if (struct.isSetPage()) {
          optionals.set(1);
        }
        oprot.writeBitSet(optionals, 2);
        if (struct.isSetUserToken()) {
          oprot.writeString(struct.userToken);
        }
        if (struct.isSetPage()) {
          oprot.writeI32(struct.page);
        }
      }

      @Override
      public void read(org.apache.thrift.protocol.TProtocol prot, getUserList_args struct) throws org.apache.thrift.TException {
        TTupleProtocol iprot = (TTupleProtocol) prot;
        BitSet incoming = iprot.readBitSet(2);
        if (incoming.get(0)) {
          struct.userToken = iprot.readString();
          struct.setUserTokenIsSet(true);
        }
        if (incoming.get(1)) {
          struct.page = iprot.readI32();
          struct.setPageIsSet(true);
        }
      }
    }

  }

  public static class getUserList_result implements org.apache.thrift.TBase<getUserList_result, getUserList_result._Fields>, java.io.Serializable, Cloneable, Comparable<getUserList_result>   {
    private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getUserList_result");

    private static final org.apache.thrift.protocol.TField SUCCESS_FIELD_DESC = new org.apache.thrift.protocol.TField("success", org.apache.thrift.protocol.TType.LIST, (short)0);
    private static final org.apache.thrift.protocol.TField FAILURE_FIELD_DESC = new org.apache.thrift.protocol.TField("failure", org.apache.thrift.protocol.TType.STRUCT, (short)1);
    private static final org.apache.thrift.protocol.TField SERVER_ERROR_FIELD_DESC = new org.apache.thrift.protocol.TField("serverError", org.apache.thrift.protocol.TType.STRUCT, (short)2);

    private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
    static {
      schemes.put(StandardScheme.class, new getUserList_resultStandardSchemeFactory());
      schemes.put(TupleScheme.class, new getUserList_resultTupleSchemeFactory());
    }

    public List<UserInfo> success; // required
    public TAuthorizationException failure; // required
    public TInternalServerError serverError; // required

    /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
    public enum _Fields implements org.apache.thrift.TFieldIdEnum {
      SUCCESS((short)0, "success"),
      FAILURE((short)1, "failure"),
      SERVER_ERROR((short)2, "serverError");

      private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();

      static {
        for (_Fields field : EnumSet.allOf(_Fields.class)) {
          byName.put(field.getFieldName(), field);
        }
      }

      /**
       * Find the _Fields constant that matches fieldId, or null if its not found.
       */
      public static _Fields findByThriftId(int fieldId) {
        switch(fieldId) {
          case 0: // SUCCESS
            return SUCCESS;
          case 1: // FAILURE
            return FAILURE;
          case 2: // SERVER_ERROR
            return SERVER_ERROR;
          default:
            return null;
        }
      }

      /**
       * Find the _Fields constant that matches fieldId, throwing an exception
       * if it is not found.
       */
      public static _Fields findByThriftIdOrThrow(int fieldId) {
        _Fields fields = findByThriftId(fieldId);
        if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
        return fields;
      }

      /**
       * Find the _Fields constant that matches name, or null if its not found.
       */
      public static _Fields findByName(String name) {
        return byName.get(name);
      }

      private final short _thriftId;
      private final String _fieldName;

      _Fields(short thriftId, String fieldName) {
        _thriftId = thriftId;
        _fieldName = fieldName;
      }

      public short getThriftFieldId() {
        return _thriftId;
      }

      public String getFieldName() {
        return _fieldName;
      }
    }

    // isset id assignments
    public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
    static {
      Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
      tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, 
          new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST, 
              new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, UserInfo.class))));
      tmpMap.put(_Fields.FAILURE, new org.apache.thrift.meta_data.FieldMetaData("failure", org.apache.thrift.TFieldRequirementType.DEFAULT, 
          new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT)));
      tmpMap.put(_Fields.SERVER_ERROR, new org.apache.thrift.meta_data.FieldMetaData("serverError", org.apache.thrift.TFieldRequirementType.DEFAULT, 
          new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT)));
      metaDataMap = Collections.unmodifiableMap(tmpMap);
      org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getUserList_result.class, metaDataMap);
    }

    public getUserList_result() {
    }

    public getUserList_result(
      List<UserInfo> success,
      TAuthorizationException failure,
      TInternalServerError serverError)
    {
      this();
      this.success = success;
      this.failure = failure;
      this.serverError = serverError;
    }

    /**
     * Performs a deep copy on <i>other</i>.
     */
    public getUserList_result(getUserList_result other) {
      if (other.isSetSuccess()) {
        List<UserInfo> __this__success = new ArrayList<UserInfo>(other.success.size());
        for (UserInfo other_element : other.success) {
          __this__success.add(new UserInfo(other_element));
        }
        this.success = __this__success;
      }
      if (other.isSetFailure()) {
        this.failure = new TAuthorizationException(other.failure);
      }
      if (other.isSetServerError()) {
        this.serverError = new TInternalServerError(other.serverError);
      }
    }

    public getUserList_result deepCopy() {
      return new getUserList_result(this);
    }

    @Override
    public void clear() {
      this.success = null;
      this.failure = null;
      this.serverError = null;
    }

    public int getSuccessSize() {
      return (this.success == null) ? 0 : this.success.size();
    }

    public java.util.Iterator<UserInfo> getSuccessIterator() {
      return (this.success == null) ? null : this.success.iterator();
    }

    public void addToSuccess(UserInfo elem) {
      if (this.success == null) {
        this.success = new ArrayList<UserInfo>();
      }
      this.success.add(elem);
    }

    public List<UserInfo> getSuccess() {
      return this.success;
    }

    public getUserList_result setSuccess(List<UserInfo> success) {
      this.success = success;
      return this;
    }

    public void unsetSuccess() {
      this.success = null;
    }

    /** Returns true if field success is set (has been assigned a value) and false otherwise */
    public boolean isSetSuccess() {
      return this.success != null;
    }

    public void setSuccessIsSet(boolean value) {
      if (!value) {
        this.success = null;
      }
    }

    public TAuthorizationException getFailure() {
      return this.failure;
    }

    public getUserList_result setFailure(TAuthorizationException failure) {
      this.failure = failure;
      return this;
    }

    public void unsetFailure() {
      this.failure = null;
    }

    /** Returns true if field failure is set (has been assigned a value) and false otherwise */
    public boolean isSetFailure() {
      return this.failure != null;
    }

    public void setFailureIsSet(boolean value) {
      if (!value) {
        this.failure = null;
      }
    }

    public TInternalServerError getServerError() {
      return this.serverError;
    }

    public getUserList_result setServerError(TInternalServerError serverError) {
      this.serverError = serverError;
      return this;
    }

    public void unsetServerError() {
      this.serverError = null;
    }

    /** Returns true if field serverError is set (has been assigned a value) and false otherwise */
    public boolean isSetServerError() {
      return this.serverError != null;
    }

    public void setServerErrorIsSet(boolean value) {
      if (!value) {
        this.serverError = null;
      }
    }

    public void setFieldValue(_Fields field, Object value) {
      switch (field) {
      case SUCCESS:
        if (value == null) {
          unsetSuccess();
        } else {
          setSuccess((List<UserInfo>)value);
        }
        break;

      case FAILURE:
        if (value == null) {
          unsetFailure();
        } else {
          setFailure((TAuthorizationException)value);
        }
        break;

      case SERVER_ERROR:
        if (value == null) {
          unsetServerError();
        } else {
          setServerError((TInternalServerError)value);
        }
        break;

      }
    }

    public Object getFieldValue(_Fields field) {
      switch (field) {
      case SUCCESS:
        return getSuccess();

      case FAILURE:
        return getFailure();

      case SERVER_ERROR:
        return getServerError();

      }
      throw new IllegalStateException();
    }

    /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
    public boolean isSet(_Fields field) {
      if (field == null) {
        throw new IllegalArgumentException();
      }

      switch (field) {
      case SUCCESS:
        return isSetSuccess();
      case FAILURE:
        return isSetFailure();
      case SERVER_ERROR:
        return isSetServerError();
      }
      throw new IllegalStateException();
    }

    @Override
    public boolean equals(Object that) {
      if (that == null)
        return false;
      if (that instanceof getUserList_result)
        return this.equals((getUserList_result)that);
      return false;
    }

    public boolean equals(getUserList_result that) {
      if (that == null)
        return false;

      boolean this_present_success = true && this.isSetSuccess();
      boolean that_present_success = true && that.isSetSuccess();
      if (this_present_success || that_present_success) {
        if (!(this_present_success && that_present_success))
          return false;
        if (!this.success.equals(that.success))
          return false;
      }

      boolean this_present_failure = true && this.isSetFailure();
      boolean that_present_failure = true && that.isSetFailure();
      if (this_present_failure || that_present_failure) {
        if (!(this_present_failure && that_present_failure))
          return false;
        if (!this.failure.equals(that.failure))
          return false;
      }

      boolean this_present_serverError = true && this.isSetServerError();
      boolean that_present_serverError = true && that.isSetServerError();
      if (this_present_serverError || that_present_serverError) {
        if (!(this_present_serverError && that_present_serverError))
          return false;
        if (!this.serverError.equals(that.serverError))
          return false;
      }

      return true;
    }

    @Override
    public int hashCode() {
      return 0;
    }

    @Override
    public int compareTo(getUserList_result other) {
      if (!getClass().equals(other.getClass())) {
        return getClass().getName().compareTo(other.getClass().getName());
      }

      int lastComparison = 0;

      lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(other.isSetSuccess());
      if (lastComparison != 0) {
        return lastComparison;
      }
      if (isSetSuccess()) {
        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, other.success);
        if (lastComparison != 0) {
          return lastComparison;
        }
      }
      lastComparison = Boolean.valueOf(isSetFailure()).compareTo(other.isSetFailure());
      if (lastComparison != 0) {
        return lastComparison;
      }
      if (isSetFailure()) {
        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.failure, other.failure);
        if (lastComparison != 0) {
          return lastComparison;
        }
      }
      lastComparison = Boolean.valueOf(isSetServerError()).compareTo(other.isSetServerError());
      if (lastComparison != 0) {
        return lastComparison;
      }
      if (isSetServerError()) {
        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.serverError, other.serverError);
        if (lastComparison != 0) {
          return lastComparison;
        }
      }
      return 0;
    }

    public _Fields fieldForId(int fieldId) {
      return _Fields.findByThriftId(fieldId);
    }

    public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
      schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
    }

    public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
      schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
      }

    @Override
    public String toString() {
      StringBuilder sb = new StringBuilder("getUserList_result(");
      boolean first = true;

      sb.append("success:");
      if (this.success == null) {
        sb.append("null");
      } else {
        sb.append(this.success);
      }
      first = false;
      if (!first) sb.append(", ");
      sb.append("failure:");
      if (this.failure == null) {
        sb.append("null");
      } else {
        sb.append(this.failure);
      }
      first = false;
      if (!first) sb.append(", ");
      sb.append("serverError:");
      if (this.serverError == null) {
        sb.append("null");
      } else {
        sb.append(this.serverError);
      }
      first = false;
      sb.append(")");
      return sb.toString();
    }

    public void validate() throws org.apache.thrift.TException {
      // check for required fields
      // check for sub-struct validity
    }

    private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
      try {
        write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
      } catch (org.apache.thrift.TException te) {
        throw new java.io.IOException(te);
      }
    }

    private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
      try {
        read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
      } catch (org.apache.thrift.TException te) {
        throw new java.io.IOException(te);
      }
    }

    private static class getUserList_resultStandardSchemeFactory implements SchemeFactory {
      public getUserList_resultStandardScheme getScheme() {
        return new getUserList_resultStandardScheme();
      }
    }

    private static class getUserList_resultStandardScheme extends StandardScheme<getUserList_result> {

      public void read(org.apache.thrift.protocol.TProtocol iprot, getUserList_result struct) throws org.apache.thrift.TException {
        org.apache.thrift.protocol.TField schemeField;
        iprot.readStructBegin();
        while (true)
        {
          schemeField = iprot.readFieldBegin();
          if (schemeField.type == org.apache.thrift.protocol.TType.STOP) { 
            break;
          }
          switch (schemeField.id) {
            case 0: // SUCCESS
              if (schemeField.type == org.apache.thrift.protocol.TType.LIST) {
                {
                  org.apache.thrift.protocol.TList _list138 = iprot.readListBegin();
                  struct.success = new ArrayList<UserInfo>(_list138.size);
                  for (int _i139 = 0; _i139 < _list138.size; ++_i139)
                  {
                    UserInfo _elem140;
                    _elem140 = new UserInfo();
                    _elem140.read(iprot);
                    struct.success.add(_elem140);
                  }
                  iprot.readListEnd();
                }
                struct.setSuccessIsSet(true);
              } else { 
                org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
              }
              break;
            case 1: // FAILURE
              if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
                struct.failure = new TAuthorizationException();
                struct.failure.read(iprot);
                struct.setFailureIsSet(true);
              } else { 
                org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
              }
              break;
            case 2: // SERVER_ERROR
              if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
                struct.serverError = new TInternalServerError();
                struct.serverError.read(iprot);
                struct.setServerErrorIsSet(true);
              } else { 
                org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
              }
              break;
            default:
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
          }
          iprot.readFieldEnd();
        }
        iprot.readStructEnd();

        // check for required fields of primitive type, which can't be checked in the validate method
        struct.validate();
      }

      public void write(org.apache.thrift.protocol.TProtocol oprot, getUserList_result struct) throws org.apache.thrift.TException {
        struct.validate();

        oprot.writeStructBegin(STRUCT_DESC);
        if (struct.success != null) {
          oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
          {
            oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.success.size()));
            for (UserInfo _iter141 : struct.success)
            {
              _iter141.write(oprot);
            }
            oprot.writeListEnd();
          }
          oprot.writeFieldEnd();
        }
        if (struct.failure != null) {
          oprot.writeFieldBegin(FAILURE_FIELD_DESC);
          struct.failure.write(oprot);
          oprot.writeFieldEnd();
        }
        if (struct.serverError != null) {
          oprot.writeFieldBegin(SERVER_ERROR_FIELD_DESC);
          struct.serverError.write(oprot);
          oprot.writeFieldEnd();
        }
        oprot.writeFieldStop();
        oprot.writeStructEnd();
      }

    }

    private static class getUserList_resultTupleSchemeFactory implements SchemeFactory {
      public getUserList_resultTupleScheme getScheme() {
        return new getUserList_resultTupleScheme();
      }
    }

    private static class getUserList_resultTupleScheme extends TupleScheme<getUserList_result> {

      @Override
      public void write(org.apache.thrift.protocol.TProtocol prot, getUserList_result struct) throws org.apache.thrift.TException {
        TTupleProtocol oprot = (TTupleProtocol) prot;
        BitSet optionals = new BitSet();
        if (struct.isSetSuccess()) {
          optionals.set(0);
        }
        if (struct.isSetFailure()) {
          optionals.set(1);
        }
        if (struct.isSetServerError()) {
          optionals.set(2);
        }
        oprot.writeBitSet(optionals, 3);
        if (struct.isSetSuccess()) {
          {
            oprot.writeI32(struct.success.size());
            for (UserInfo _iter142 : struct.success)
            {
              _iter142.write(oprot);
            }
          }
        }
        if (struct.isSetFailure()) {
          struct.failure.write(oprot);
        }
        if (struct.isSetServerError()) {
          struct.serverError.write(oprot);
        }
      }

      @Override
      public void read(org.apache.thrift.protocol.TProtocol prot, getUserList_result struct) throws org.apache.thrift.TException {
        TTupleProtocol iprot = (TTupleProtocol) prot;
        BitSet incoming = iprot.readBitSet(3);
        if (incoming.get(0)) {
          {
            org.apache.thrift.protocol.TList _list143 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32());
            struct.success = new ArrayList<UserInfo>(_list143.size);
            for (int _i144 = 0; _i144 < _list143.size; ++_i144)
            {
              UserInfo _elem145;
              _elem145 = new UserInfo();
              _elem145.read(iprot);
              struct.success.add(_elem145);
            }
          }
          struct.setSuccessIsSet(true);
        }
        if (incoming.get(1)) {
          struct.failure = new TAuthorizationException();
          struct.failure.read(iprot);
          struct.setFailureIsSet(true);
        }
        if (incoming.get(2)) {
          struct.serverError = new TInternalServerError();
          struct.serverError.read(iprot);
          struct.setServerErrorIsSet(true);
        }
      }
    }

  }

  public static class getOperatingSystems_args implements org.apache.thrift.TBase<getOperatingSystems_args, getOperatingSystems_args._Fields>, java.io.Serializable, Cloneable, Comparable<getOperatingSystems_args>   {
    private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getOperatingSystems_args");


    private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
    static {
      schemes.put(StandardScheme.class, new getOperatingSystems_argsStandardSchemeFactory());
      schemes.put(TupleScheme.class, new getOperatingSystems_argsTupleSchemeFactory());
    }


    /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
    public enum _Fields implements org.apache.thrift.TFieldIdEnum {
;

      private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();

      static {
        for (_Fields field : EnumSet.allOf(_Fields.class)) {
          byName.put(field.getFieldName(), field);
        }
      }

      /**
       * Find the _Fields constant that matches fieldId, or null if its not found.
       */
      public static _Fields findByThriftId(int fieldId) {
        switch(fieldId) {
          default:
            return null;
        }
      }

      /**
       * Find the _Fields constant that matches fieldId, throwing an exception
       * if it is not found.
       */
      public static _Fields findByThriftIdOrThrow(int fieldId) {
        _Fields fields = findByThriftId(fieldId);
        if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
        return fields;
      }

      /**
       * Find the _Fields constant that matches name, or null if its not found.
       */
      public static _Fields findByName(String name) {
        return byName.get(name);
      }

      private final short _thriftId;
      private final String _fieldName;

      _Fields(short thriftId, String fieldName) {
        _thriftId = thriftId;
        _fieldName = fieldName;
      }

      public short getThriftFieldId() {
        return _thriftId;
      }

      public String getFieldName() {
        return _fieldName;
      }
    }
    public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
    static {
      Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
      metaDataMap = Collections.unmodifiableMap(tmpMap);
      org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getOperatingSystems_args.class, metaDataMap);
    }

    public getOperatingSystems_args() {
    }

    /**
     * Performs a deep copy on <i>other</i>.
     */
    public getOperatingSystems_args(getOperatingSystems_args other) {
    }

    public getOperatingSystems_args deepCopy() {
      return new getOperatingSystems_args(this);
    }

    @Override
    public void clear() {
    }

    public void setFieldValue(_Fields field, Object value) {
      switch (field) {
      }
    }

    public Object getFieldValue(_Fields field) {
      switch (field) {
      }
      throw new IllegalStateException();
    }

    /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
    public boolean isSet(_Fields field) {
      if (field == null) {
        throw new IllegalArgumentException();
      }

      switch (field) {
      }
      throw new IllegalStateException();
    }

    @Override
    public boolean equals(Object that) {
      if (that == null)
        return false;
      if (that instanceof getOperatingSystems_args)
        return this.equals((getOperatingSystems_args)that);
      return false;
    }

    public boolean equals(getOperatingSystems_args that) {
      if (that == null)
        return false;

      return true;
    }

    @Override
    public int hashCode() {
      return 0;
    }

    @Override
    public int compareTo(getOperatingSystems_args other) {
      if (!getClass().equals(other.getClass())) {
        return getClass().getName().compareTo(other.getClass().getName());
      }

      int lastComparison = 0;

      return 0;
    }

    public _Fields fieldForId(int fieldId) {
      return _Fields.findByThriftId(fieldId);
    }

    public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
      schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
    }

    public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
      schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
    }

    @Override
    public String toString() {
      StringBuilder sb = new StringBuilder("getOperatingSystems_args(");
      boolean first = true;

      sb.append(")");
      return sb.toString();
    }

    public void validate() throws org.apache.thrift.TException {
      // check for required fields
      // check for sub-struct validity
    }

    private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
      try {
        write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
      } catch (org.apache.thrift.TException te) {
        throw new java.io.IOException(te);
      }
    }

    private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
      try {
        read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
      } catch (org.apache.thrift.TException te) {
        throw new java.io.IOException(te);
      }
    }

    private static class getOperatingSystems_argsStandardSchemeFactory implements SchemeFactory {
      public getOperatingSystems_argsStandardScheme getScheme() {
        return new getOperatingSystems_argsStandardScheme();
      }
    }

    private static class getOperatingSystems_argsStandardScheme extends StandardScheme<getOperatingSystems_args> {

      public void read(org.apache.thrift.protocol.TProtocol iprot, getOperatingSystems_args struct) throws org.apache.thrift.TException {
        org.apache.thrift.protocol.TField schemeField;
        iprot.readStructBegin();
        while (true)
        {
          schemeField = iprot.readFieldBegin();
          if (schemeField.type == org.apache.thrift.protocol.TType.STOP) { 
            break;
          }
          switch (schemeField.id) {
            default:
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
          }
          iprot.readFieldEnd();
        }
        iprot.readStructEnd();

        // check for required fields of primitive type, which can't be checked in the validate method
        struct.validate();
      }

      public void write(org.apache.thrift.protocol.TProtocol oprot, getOperatingSystems_args struct) throws org.apache.thrift.TException {
        struct.validate();

        oprot.writeStructBegin(STRUCT_DESC);
        oprot.writeFieldStop();
        oprot.writeStructEnd();
      }

    }

    private static class getOperatingSystems_argsTupleSchemeFactory implements SchemeFactory {
      public getOperatingSystems_argsTupleScheme getScheme() {
        return new getOperatingSystems_argsTupleScheme();
      }
    }

    private static class getOperatingSystems_argsTupleScheme extends TupleScheme<getOperatingSystems_args> {

      @Override
      public void write(org.apache.thrift.protocol.TProtocol prot, getOperatingSystems_args struct) throws org.apache.thrift.TException {
        TTupleProtocol oprot = (TTupleProtocol) prot;
      }

      @Override
      public void read(org.apache.thrift.protocol.TProtocol prot, getOperatingSystems_args struct) throws org.apache.thrift.TException {
        TTupleProtocol iprot = (TTupleProtocol) prot;
      }
    }

  }

  public static class getOperatingSystems_result implements org.apache.thrift.TBase<getOperatingSystems_result, getOperatingSystems_result._Fields>, java.io.Serializable, Cloneable, Comparable<getOperatingSystems_result>   {
    private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getOperatingSystems_result");

    private static final org.apache.thrift.protocol.TField SUCCESS_FIELD_DESC = new org.apache.thrift.protocol.TField("success", org.apache.thrift.protocol.TType.LIST, (short)0);

    private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
    static {
      schemes.put(StandardScheme.class, new getOperatingSystems_resultStandardSchemeFactory());
      schemes.put(TupleScheme.class, new getOperatingSystems_resultTupleSchemeFactory());
    }

    public List<OperatingSystem> success; // required

    /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
    public enum _Fields implements org.apache.thrift.TFieldIdEnum {
      SUCCESS((short)0, "success");

      private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();

      static {
        for (_Fields field : EnumSet.allOf(_Fields.class)) {
          byName.put(field.getFieldName(), field);
        }
      }

      /**
       * Find the _Fields constant that matches fieldId, or null if its not found.
       */
      public static _Fields findByThriftId(int fieldId) {
        switch(fieldId) {
          case 0: // SUCCESS
            return SUCCESS;
          default:
            return null;
        }
      }

      /**
       * Find the _Fields constant that matches fieldId, throwing an exception
       * if it is not found.
       */
      public static _Fields findByThriftIdOrThrow(int fieldId) {
        _Fields fields = findByThriftId(fieldId);
        if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
        return fields;
      }

      /**
       * Find the _Fields constant that matches name, or null if its not found.
       */
      public static _Fields findByName(String name) {
        return byName.get(name);
      }

      private final short _thriftId;
      private final String _fieldName;

      _Fields(short thriftId, String fieldName) {
        _thriftId = thriftId;
        _fieldName = fieldName;
      }

      public short getThriftFieldId() {
        return _thriftId;
      }

      public String getFieldName() {
        return _fieldName;
      }
    }

    // isset id assignments
    public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
    static {
      Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
      tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, 
          new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST, 
              new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, OperatingSystem.class))));
      metaDataMap = Collections.unmodifiableMap(tmpMap);
      org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getOperatingSystems_result.class, metaDataMap);
    }

    public getOperatingSystems_result() {
    }

    public getOperatingSystems_result(
      List<OperatingSystem> success)
    {
      this();
      this.success = success;
    }

    /**
     * Performs a deep copy on <i>other</i>.
     */
    public getOperatingSystems_result(getOperatingSystems_result other) {
      if (other.isSetSuccess()) {
        List<OperatingSystem> __this__success = new ArrayList<OperatingSystem>(other.success.size());
        for (OperatingSystem other_element : other.success) {
          __this__success.add(new OperatingSystem(other_element));
        }
        this.success = __this__success;
      }
    }

    public getOperatingSystems_result deepCopy() {
      return new getOperatingSystems_result(this);
    }

    @Override
    public void clear() {
      this.success = null;
    }

    public int getSuccessSize() {
      return (this.success == null) ? 0 : this.success.size();
    }

    public java.util.Iterator<OperatingSystem> getSuccessIterator() {
      return (this.success == null) ? null : this.success.iterator();
    }

    public void addToSuccess(OperatingSystem elem) {
      if (this.success == null) {
        this.success = new ArrayList<OperatingSystem>();
      }
      this.success.add(elem);
    }

    public List<OperatingSystem> getSuccess() {
      return this.success;
    }

    public getOperatingSystems_result setSuccess(List<OperatingSystem> success) {
      this.success = success;
      return this;
    }

    public void unsetSuccess() {
      this.success = null;
    }

    /** Returns true if field success is set (has been assigned a value) and false otherwise */
    public boolean isSetSuccess() {
      return this.success != null;
    }

    public void setSuccessIsSet(boolean value) {
      if (!value) {
        this.success = null;
      }
    }

    public void setFieldValue(_Fields field, Object value) {
      switch (field) {
      case SUCCESS:
        if (value == null) {
          unsetSuccess();
        } else {
          setSuccess((List<OperatingSystem>)value);
        }
        break;

      }
    }

    public Object getFieldValue(_Fields field) {
      switch (field) {
      case SUCCESS:
        return getSuccess();

      }
      throw new IllegalStateException();
    }

    /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
    public boolean isSet(_Fields field) {
      if (field == null) {
        throw new IllegalArgumentException();
      }

      switch (field) {
      case SUCCESS:
        return isSetSuccess();
      }
      throw new IllegalStateException();
    }

    @Override
    public boolean equals(Object that) {
      if (that == null)
        return false;
      if (that instanceof getOperatingSystems_result)
        return this.equals((getOperatingSystems_result)that);
      return false;
    }

    public boolean equals(getOperatingSystems_result that) {
      if (that == null)
        return false;

      boolean this_present_success = true && this.isSetSuccess();
      boolean that_present_success = true && that.isSetSuccess();
      if (this_present_success || that_present_success) {
        if (!(this_present_success && that_present_success))
          return false;
        if (!this.success.equals(that.success))
          return false;
      }

      return true;
    }

    @Override
    public int hashCode() {
      return 0;
    }

    @Override
    public int compareTo(getOperatingSystems_result other) {
      if (!getClass().equals(other.getClass())) {
        return getClass().getName().compareTo(other.getClass().getName());
      }

      int lastComparison = 0;

      lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(other.isSetSuccess());
      if (lastComparison != 0) {
        return lastComparison;
      }
      if (isSetSuccess()) {
        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, other.success);
        if (lastComparison != 0) {
          return lastComparison;
        }
      }
      return 0;
    }

    public _Fields fieldForId(int fieldId) {
      return _Fields.findByThriftId(fieldId);
    }

    public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
      schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
    }

    public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
      schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
      }

    @Override
    public String toString() {
      StringBuilder sb = new StringBuilder("getOperatingSystems_result(");
      boolean first = true;

      sb.append("success:");
      if (this.success == null) {
        sb.append("null");
      } else {
        sb.append(this.success);
      }
      first = false;
      sb.append(")");
      return sb.toString();
    }

    public void validate() throws org.apache.thrift.TException {
      // check for required fields
      // check for sub-struct validity
    }

    private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
      try {
        write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
      } catch (org.apache.thrift.TException te) {
        throw new java.io.IOException(te);
      }
    }

    private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
      try {
        read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
      } catch (org.apache.thrift.TException te) {
        throw new java.io.IOException(te);
      }
    }

    private static class getOperatingSystems_resultStandardSchemeFactory implements SchemeFactory {
      public getOperatingSystems_resultStandardScheme getScheme() {
        return new getOperatingSystems_resultStandardScheme();
      }
    }

    private static class getOperatingSystems_resultStandardScheme extends StandardScheme<getOperatingSystems_result> {

      public void read(org.apache.thrift.protocol.TProtocol iprot, getOperatingSystems_result struct) throws org.apache.thrift.TException {
        org.apache.thrift.protocol.TField schemeField;
        iprot.readStructBegin();
        while (true)
        {
          schemeField = iprot.readFieldBegin();
          if (schemeField.type == org.apache.thrift.protocol.TType.STOP) { 
            break;
          }
          switch (schemeField.id) {
            case 0: // SUCCESS
              if (schemeField.type == org.apache.thrift.protocol.TType.LIST) {
                {
                  org.apache.thrift.protocol.TList _list146 = iprot.readListBegin();
                  struct.success = new ArrayList<OperatingSystem>(_list146.size);
                  for (int _i147 = 0; _i147 < _list146.size; ++_i147)
                  {
                    OperatingSystem _elem148;
                    _elem148 = new OperatingSystem();
                    _elem148.read(iprot);
                    struct.success.add(_elem148);
                  }
                  iprot.readListEnd();
                }
                struct.setSuccessIsSet(true);
              } else { 
                org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
              }
              break;
            default:
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
          }
          iprot.readFieldEnd();
        }
        iprot.readStructEnd();

        // check for required fields of primitive type, which can't be checked in the validate method
        struct.validate();
      }

      public void write(org.apache.thrift.protocol.TProtocol oprot, getOperatingSystems_result struct) throws org.apache.thrift.TException {
        struct.validate();

        oprot.writeStructBegin(STRUCT_DESC);
        if (struct.success != null) {
          oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
          {
            oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.success.size()));
            for (OperatingSystem _iter149 : struct.success)
            {
              _iter149.write(oprot);
            }
            oprot.writeListEnd();
          }
          oprot.writeFieldEnd();
        }
        oprot.writeFieldStop();
        oprot.writeStructEnd();
      }

    }

    private static class getOperatingSystems_resultTupleSchemeFactory implements SchemeFactory {
      public getOperatingSystems_resultTupleScheme getScheme() {
        return new getOperatingSystems_resultTupleScheme();
      }
    }

    private static class getOperatingSystems_resultTupleScheme extends TupleScheme<getOperatingSystems_result> {

      @Override
      public void write(org.apache.thrift.protocol.TProtocol prot, getOperatingSystems_result struct) throws org.apache.thrift.TException {
        TTupleProtocol oprot = (TTupleProtocol) prot;
        BitSet optionals = new BitSet();
        if (struct.isSetSuccess()) {
          optionals.set(0);
        }
        oprot.writeBitSet(optionals, 1);
        if (struct.isSetSuccess()) {
          {
            oprot.writeI32(struct.success.size());
            for (OperatingSystem _iter150 : struct.success)
            {
              _iter150.write(oprot);
            }
          }
        }
      }

      @Override
      public void read(org.apache.thrift.protocol.TProtocol prot, getOperatingSystems_result struct) throws org.apache.thrift.TException {
        TTupleProtocol iprot = (TTupleProtocol) prot;
        BitSet incoming = iprot.readBitSet(1);
        if (incoming.get(0)) {
          {
            org.apache.thrift.protocol.TList _list151 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32());
            struct.success = new ArrayList<OperatingSystem>(_list151.size);
            for (int _i152 = 0; _i152 < _list151.size; ++_i152)
            {
              OperatingSystem _elem153;
              _elem153 = new OperatingSystem();
              _elem153.read(iprot);
              struct.success.add(_elem153);
            }
          }
          struct.setSuccessIsSet(true);
        }
      }
    }

  }

  public static class getVirtualizers_args implements org.apache.thrift.TBase<getVirtualizers_args, getVirtualizers_args._Fields>, java.io.Serializable, Cloneable, Comparable<getVirtualizers_args>   {
    private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getVirtualizers_args");


    private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
    static {
      schemes.put(StandardScheme.class, new getVirtualizers_argsStandardSchemeFactory());
      schemes.put(TupleScheme.class, new getVirtualizers_argsTupleSchemeFactory());
    }


    /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
    public enum _Fields implements org.apache.thrift.TFieldIdEnum {
;

      private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();

      static {
        for (_Fields field : EnumSet.allOf(_Fields.class)) {
          byName.put(field.getFieldName(), field);
        }
      }

      /**
       * Find the _Fields constant that matches fieldId, or null if its not found.
       */
      public static _Fields findByThriftId(int fieldId) {
        switch(fieldId) {
          default:
            return null;
        }
      }

      /**
       * Find the _Fields constant that matches fieldId, throwing an exception
       * if it is not found.
       */
      public static _Fields findByThriftIdOrThrow(int fieldId) {
        _Fields fields = findByThriftId(fieldId);
        if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
        return fields;
      }

      /**
       * Find the _Fields constant that matches name, or null if its not found.
       */
      public static _Fields findByName(String name) {
        return byName.get(name);
      }

      private final short _thriftId;
      private final String _fieldName;

      _Fields(short thriftId, String fieldName) {
        _thriftId = thriftId;
        _fieldName = fieldName;
      }

      public short getThriftFieldId() {
        return _thriftId;
      }

      public String getFieldName() {
        return _fieldName;
      }
    }
    public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
    static {
      Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
      metaDataMap = Collections.unmodifiableMap(tmpMap);
      org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getVirtualizers_args.class, metaDataMap);
    }

    public getVirtualizers_args() {
    }

    /**
     * Performs a deep copy on <i>other</i>.
     */
    public getVirtualizers_args(getVirtualizers_args other) {
    }

    public getVirtualizers_args deepCopy() {
      return new getVirtualizers_args(this);
    }

    @Override
    public void clear() {
    }

    public void setFieldValue(_Fields field, Object value) {
      switch (field) {
      }
    }

    public Object getFieldValue(_Fields field) {
      switch (field) {
      }
      throw new IllegalStateException();
    }

    /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
    public boolean isSet(_Fields field) {
      if (field == null) {
        throw new IllegalArgumentException();
      }

      switch (field) {
      }
      throw new IllegalStateException();
    }

    @Override
    public boolean equals(Object that) {
      if (that == null)
        return false;
      if (that instanceof getVirtualizers_args)
        return this.equals((getVirtualizers_args)that);
      return false;
    }

    public boolean equals(getVirtualizers_args that) {
      if (that == null)
        return false;

      return true;
    }

    @Override
    public int hashCode() {
      return 0;
    }

    @Override
    public int compareTo(getVirtualizers_args other) {
      if (!getClass().equals(other.getClass())) {
        return getClass().getName().compareTo(other.getClass().getName());
      }

      int lastComparison = 0;

      return 0;
    }

    public _Fields fieldForId(int fieldId) {
      return _Fields.findByThriftId(fieldId);
    }

    public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
      schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
    }

    public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
      schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
    }

    @Override
    public String toString() {
      StringBuilder sb = new StringBuilder("getVirtualizers_args(");
      boolean first = true;

      sb.append(")");
      return sb.toString();
    }

    public void validate() throws org.apache.thrift.TException {
      // check for required fields
      // check for sub-struct validity
    }

    private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
      try {
        write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
      } catch (org.apache.thrift.TException te) {
        throw new java.io.IOException(te);
      }
    }

    private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
      try {
        read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
      } catch (org.apache.thrift.TException te) {
        throw new java.io.IOException(te);
      }
    }

    private static class getVirtualizers_argsStandardSchemeFactory implements SchemeFactory {
      public getVirtualizers_argsStandardScheme getScheme() {
        return new getVirtualizers_argsStandardScheme();
      }
    }

    private static class getVirtualizers_argsStandardScheme extends StandardScheme<getVirtualizers_args> {

      public void read(org.apache.thrift.protocol.TProtocol iprot, getVirtualizers_args struct) throws org.apache.thrift.TException {
        org.apache.thrift.protocol.TField schemeField;
        iprot.readStructBegin();
        while (true)
        {
          schemeField = iprot.readFieldBegin();
          if (schemeField.type == org.apache.thrift.protocol.TType.STOP) { 
            break;
          }
          switch (schemeField.id) {
            default:
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
          }
          iprot.readFieldEnd();
        }
        iprot.readStructEnd();

        // check for required fields of primitive type, which can't be checked in the validate method
        struct.validate();
      }

      public void write(org.apache.thrift.protocol.TProtocol oprot, getVirtualizers_args struct) throws org.apache.thrift.TException {
        struct.validate();

        oprot.writeStructBegin(STRUCT_DESC);
        oprot.writeFieldStop();
        oprot.writeStructEnd();
      }

    }

    private static class getVirtualizers_argsTupleSchemeFactory implements SchemeFactory {
      public getVirtualizers_argsTupleScheme getScheme() {
        return new getVirtualizers_argsTupleScheme();
      }
    }

    private static class getVirtualizers_argsTupleScheme extends TupleScheme<getVirtualizers_args> {

      @Override
      public void write(org.apache.thrift.protocol.TProtocol prot, getVirtualizers_args struct) throws org.apache.thrift.TException {
        TTupleProtocol oprot = (TTupleProtocol) prot;
      }

      @Override
      public void read(org.apache.thrift.protocol.TProtocol prot, getVirtualizers_args struct) throws org.apache.thrift.TException {
        TTupleProtocol iprot = (TTupleProtocol) prot;
      }
    }

  }

  public static class getVirtualizers_result implements org.apache.thrift.TBase<getVirtualizers_result, getVirtualizers_result._Fields>, java.io.Serializable, Cloneable, Comparable<getVirtualizers_result>   {
    private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getVirtualizers_result");

    private static final org.apache.thrift.protocol.TField SUCCESS_FIELD_DESC = new org.apache.thrift.protocol.TField("success", org.apache.thrift.protocol.TType.LIST, (short)0);

    private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
    static {
      schemes.put(StandardScheme.class, new getVirtualizers_resultStandardSchemeFactory());
      schemes.put(TupleScheme.class, new getVirtualizers_resultTupleSchemeFactory());
    }

    public List<Virtualizer> success; // required

    /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
    public enum _Fields implements org.apache.thrift.TFieldIdEnum {
      SUCCESS((short)0, "success");

      private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();

      static {
        for (_Fields field : EnumSet.allOf(_Fields.class)) {
          byName.put(field.getFieldName(), field);
        }
      }

      /**
       * Find the _Fields constant that matches fieldId, or null if its not found.
       */
      public static _Fields findByThriftId(int fieldId) {
        switch(fieldId) {
          case 0: // SUCCESS
            return SUCCESS;
          default:
            return null;
        }
      }

      /**
       * Find the _Fields constant that matches fieldId, throwing an exception
       * if it is not found.
       */
      public static _Fields findByThriftIdOrThrow(int fieldId) {
        _Fields fields = findByThriftId(fieldId);
        if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
        return fields;
      }

      /**
       * Find the _Fields constant that matches name, or null if its not found.
       */
      public static _Fields findByName(String name) {
        return byName.get(name);
      }

      private final short _thriftId;
      private final String _fieldName;

      _Fields(short thriftId, String fieldName) {
        _thriftId = thriftId;
        _fieldName = fieldName;
      }

      public short getThriftFieldId() {
        return _thriftId;
      }

      public String getFieldName() {
        return _fieldName;
      }
    }

    // isset id assignments
    public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
    static {
      Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
      tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, 
          new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST, 
              new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, Virtualizer.class))));
      metaDataMap = Collections.unmodifiableMap(tmpMap);
      org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getVirtualizers_result.class, metaDataMap);
    }

    public getVirtualizers_result() {
    }

    public getVirtualizers_result(
      List<Virtualizer> success)
    {
      this();
      this.success = success;
    }

    /**
     * Performs a deep copy on <i>other</i>.
     */
    public getVirtualizers_result(getVirtualizers_result other) {
      if (other.isSetSuccess()) {
        List<Virtualizer> __this__success = new ArrayList<Virtualizer>(other.success.size());
        for (Virtualizer other_element : other.success) {
          __this__success.add(new Virtualizer(other_element));
        }
        this.success = __this__success;
      }
    }

    public getVirtualizers_result deepCopy() {
      return new getVirtualizers_result(this);
    }

    @Override
    public void clear() {
      this.success = null;
    }

    public int getSuccessSize() {
      return (this.success == null) ? 0 : this.success.size();
    }

    public java.util.Iterator<Virtualizer> getSuccessIterator() {
      return (this.success == null) ? null : this.success.iterator();
    }

    public void addToSuccess(Virtualizer elem) {
      if (this.success == null) {
        this.success = new ArrayList<Virtualizer>();
      }
      this.success.add(elem);
    }

    public List<Virtualizer> getSuccess() {
      return this.success;
    }

    public getVirtualizers_result setSuccess(List<Virtualizer> success) {
      this.success = success;
      return this;
    }

    public void unsetSuccess() {
      this.success = null;
    }

    /** Returns true if field success is set (has been assigned a value) and false otherwise */
    public boolean isSetSuccess() {
      return this.success != null;
    }

    public void setSuccessIsSet(boolean value) {
      if (!value) {
        this.success = null;
      }
    }

    public void setFieldValue(_Fields field, Object value) {
      switch (field) {
      case SUCCESS:
        if (value == null) {
          unsetSuccess();
        } else {
          setSuccess((List<Virtualizer>)value);
        }
        break;

      }
    }

    public Object getFieldValue(_Fields field) {
      switch (field) {
      case SUCCESS:
        return getSuccess();

      }
      throw new IllegalStateException();
    }

    /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
    public boolean isSet(_Fields field) {
      if (field == null) {
        throw new IllegalArgumentException();
      }

      switch (field) {
      case SUCCESS:
        return isSetSuccess();
      }
      throw new IllegalStateException();
    }

    @Override
    public boolean equals(Object that) {
      if (that == null)
        return false;
      if (that instanceof getVirtualizers_result)
        return this.equals((getVirtualizers_result)that);
      return false;
    }

    public boolean equals(getVirtualizers_result that) {
      if (that == null)
        return false;

      boolean this_present_success = true && this.isSetSuccess();
      boolean that_present_success = true && that.isSetSuccess();
      if (this_present_success || that_present_success) {
        if (!(this_present_success && that_present_success))
          return false;
        if (!this.success.equals(that.success))
          return false;
      }

      return true;
    }

    @Override
    public int hashCode() {
      return 0;
    }

    @Override
    public int compareTo(getVirtualizers_result other) {
      if (!getClass().equals(other.getClass())) {
        return getClass().getName().compareTo(other.getClass().getName());
      }

      int lastComparison = 0;

      lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(other.isSetSuccess());
      if (lastComparison != 0) {
        return lastComparison;
      }
      if (isSetSuccess()) {
        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, other.success);
        if (lastComparison != 0) {
          return lastComparison;
        }
      }
      return 0;
    }

    public _Fields fieldForId(int fieldId) {
      return _Fields.findByThriftId(fieldId);
    }

    public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
      schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
    }

    public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
      schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
      }

    @Override
    public String toString() {
      StringBuilder sb = new StringBuilder("getVirtualizers_result(");
      boolean first = true;

      sb.append("success:");
      if (this.success == null) {
        sb.append("null");
      } else {
        sb.append(this.success);
      }
      first = false;
      sb.append(")");
      return sb.toString();
    }

    public void validate() throws org.apache.thrift.TException {
      // check for required fields
      // check for sub-struct validity
    }

    private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
      try {
        write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
      } catch (org.apache.thrift.TException te) {
        throw new java.io.IOException(te);
      }
    }

    private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
      try {
        read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
      } catch (org.apache.thrift.TException te) {
        throw new java.io.IOException(te);
      }
    }

    private static class getVirtualizers_resultStandardSchemeFactory implements SchemeFactory {
      public getVirtualizers_resultStandardScheme getScheme() {
        return new getVirtualizers_resultStandardScheme();
      }
    }

    private static class getVirtualizers_resultStandardScheme extends StandardScheme<getVirtualizers_result> {

      public void read(org.apache.thrift.protocol.TProtocol iprot, getVirtualizers_result struct) throws org.apache.thrift.TException {
        org.apache.thrift.protocol.TField schemeField;
        iprot.readStructBegin();
        while (true)
        {
          schemeField = iprot.readFieldBegin();
          if (schemeField.type == org.apache.thrift.protocol.TType.STOP) { 
            break;
          }
          switch (schemeField.id) {
            case 0: // SUCCESS
              if (schemeField.type == org.apache.thrift.protocol.TType.LIST) {
                {
                  org.apache.thrift.protocol.TList _list154 = iprot.readListBegin();
                  struct.success = new ArrayList<Virtualizer>(_list154.size);
                  for (int _i155 = 0; _i155 < _list154.size; ++_i155)
                  {
                    Virtualizer _elem156;
                    _elem156 = new Virtualizer();
                    _elem156.read(iprot);
                    struct.success.add(_elem156);
                  }
                  iprot.readListEnd();
                }
                struct.setSuccessIsSet(true);
              } else { 
                org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
              }
              break;
            default:
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
          }
          iprot.readFieldEnd();
        }
        iprot.readStructEnd();

        // check for required fields of primitive type, which can't be checked in the validate method
        struct.validate();
      }

      public void write(org.apache.thrift.protocol.TProtocol oprot, getVirtualizers_result struct) throws org.apache.thrift.TException {
        struct.validate();

        oprot.writeStructBegin(STRUCT_DESC);
        if (struct.success != null) {
          oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
          {
            oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.success.size()));
            for (Virtualizer _iter157 : struct.success)
            {
              _iter157.write(oprot);
            }
            oprot.writeListEnd();
          }
          oprot.writeFieldEnd();
        }
        oprot.writeFieldStop();
        oprot.writeStructEnd();
      }

    }

    private static class getVirtualizers_resultTupleSchemeFactory implements SchemeFactory {
      public getVirtualizers_resultTupleScheme getScheme() {
        return new getVirtualizers_resultTupleScheme();
      }
    }

    private static class getVirtualizers_resultTupleScheme extends TupleScheme<getVirtualizers_result> {

      @Override
      public void write(org.apache.thrift.protocol.TProtocol prot, getVirtualizers_result struct) throws org.apache.thrift.TException {
        TTupleProtocol oprot = (TTupleProtocol) prot;
        BitSet optionals = new BitSet();
        if (struct.isSetSuccess()) {
          optionals.set(0);
        }
        oprot.writeBitSet(optionals, 1);
        if (struct.isSetSuccess()) {
          {
            oprot.writeI32(struct.success.size());
            for (Virtualizer _iter158 : struct.success)
            {
              _iter158.write(oprot);
            }
          }
        }
      }

      @Override
      public void read(org.apache.thrift.protocol.TProtocol prot, getVirtualizers_result struct) throws org.apache.thrift.TException {
        TTupleProtocol iprot = (TTupleProtocol) prot;
        BitSet incoming = iprot.readBitSet(1);
        if (incoming.get(0)) {
          {
            org.apache.thrift.protocol.TList _list159 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32());
            struct.success = new ArrayList<Virtualizer>(_list159.size);
            for (int _i160 = 0; _i160 < _list159.size; ++_i160)
            {
              Virtualizer _elem161;
              _elem161 = new Virtualizer();
              _elem161.read(iprot);
              struct.success.add(_elem161);
            }
          }
          struct.setSuccessIsSet(true);
        }
      }
    }

  }

  public static class getAllOrganizations_args implements org.apache.thrift.TBase<getAllOrganizations_args, getAllOrganizations_args._Fields>, java.io.Serializable, Cloneable, Comparable<getAllOrganizations_args>   {
    private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getAllOrganizations_args");


    private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
    static {
      schemes.put(StandardScheme.class, new getAllOrganizations_argsStandardSchemeFactory());
      schemes.put(TupleScheme.class, new getAllOrganizations_argsTupleSchemeFactory());
    }


    /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
    public enum _Fields implements org.apache.thrift.TFieldIdEnum {
;

      private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();

      static {
        for (_Fields field : EnumSet.allOf(_Fields.class)) {
          byName.put(field.getFieldName(), field);
        }
      }

      /**
       * Find the _Fields constant that matches fieldId, or null if its not found.
       */
      public static _Fields findByThriftId(int fieldId) {
        switch(fieldId) {
          default:
            return null;
        }
      }

      /**
       * Find the _Fields constant that matches fieldId, throwing an exception
       * if it is not found.
       */
      public static _Fields findByThriftIdOrThrow(int fieldId) {
        _Fields fields = findByThriftId(fieldId);
        if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
        return fields;
      }

      /**
       * Find the _Fields constant that matches name, or null if its not found.
       */
      public static _Fields findByName(String name) {
        return byName.get(name);
      }

      private final short _thriftId;
      private final String _fieldName;

      _Fields(short thriftId, String fieldName) {
        _thriftId = thriftId;
        _fieldName = fieldName;
      }

      public short getThriftFieldId() {
        return _thriftId;
      }

      public String getFieldName() {
        return _fieldName;
      }
    }
    public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
    static {
      Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
      metaDataMap = Collections.unmodifiableMap(tmpMap);
      org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getAllOrganizations_args.class, metaDataMap);
    }

    public getAllOrganizations_args() {
    }

    /**
     * Performs a deep copy on <i>other</i>.
     */
    public getAllOrganizations_args(getAllOrganizations_args other) {
    }

    public getAllOrganizations_args deepCopy() {
      return new getAllOrganizations_args(this);
    }

    @Override
    public void clear() {
    }

    public void setFieldValue(_Fields field, Object value) {
      switch (field) {
      }
    }

    public Object getFieldValue(_Fields field) {
      switch (field) {
      }
      throw new IllegalStateException();
    }

    /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
    public boolean isSet(_Fields field) {
      if (field == null) {
        throw new IllegalArgumentException();
      }

      switch (field) {
      }
      throw new IllegalStateException();
    }

    @Override
    public boolean equals(Object that) {
      if (that == null)
        return false;
      if (that instanceof getAllOrganizations_args)
        return this.equals((getAllOrganizations_args)that);
      return false;
    }

    public boolean equals(getAllOrganizations_args that) {
      if (that == null)
        return false;

      return true;
    }

    @Override
    public int hashCode() {
      return 0;
    }

    @Override
    public int compareTo(getAllOrganizations_args other) {
      if (!getClass().equals(other.getClass())) {
        return getClass().getName().compareTo(other.getClass().getName());
      }

      int lastComparison = 0;

      return 0;
    }

    public _Fields fieldForId(int fieldId) {
      return _Fields.findByThriftId(fieldId);
    }

    public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
      schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
    }

    public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
      schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
    }

    @Override
    public String toString() {
      StringBuilder sb = new StringBuilder("getAllOrganizations_args(");
      boolean first = true;

      sb.append(")");
      return sb.toString();
    }

    public void validate() throws org.apache.thrift.TException {
      // check for required fields
      // check for sub-struct validity
    }

    private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
      try {
        write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
      } catch (org.apache.thrift.TException te) {
        throw new java.io.IOException(te);
      }
    }

    private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
      try {
        read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
      } catch (org.apache.thrift.TException te) {
        throw new java.io.IOException(te);
      }
    }

    private static class getAllOrganizations_argsStandardSchemeFactory implements SchemeFactory {
      public getAllOrganizations_argsStandardScheme getScheme() {
        return new getAllOrganizations_argsStandardScheme();
      }
    }

    private static class getAllOrganizations_argsStandardScheme extends StandardScheme<getAllOrganizations_args> {

      public void read(org.apache.thrift.protocol.TProtocol iprot, getAllOrganizations_args struct) throws org.apache.thrift.TException {
        org.apache.thrift.protocol.TField schemeField;
        iprot.readStructBegin();
        while (true)
        {
          schemeField = iprot.readFieldBegin();
          if (schemeField.type == org.apache.thrift.protocol.TType.STOP) { 
            break;
          }
          switch (schemeField.id) {
            default:
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
          }
          iprot.readFieldEnd();
        }
        iprot.readStructEnd();

        // check for required fields of primitive type, which can't be checked in the validate method
        struct.validate();
      }

      public void write(org.apache.thrift.protocol.TProtocol oprot, getAllOrganizations_args struct) throws org.apache.thrift.TException {
        struct.validate();

        oprot.writeStructBegin(STRUCT_DESC);
        oprot.writeFieldStop();
        oprot.writeStructEnd();
      }

    }

    private static class getAllOrganizations_argsTupleSchemeFactory implements SchemeFactory {
      public getAllOrganizations_argsTupleScheme getScheme() {
        return new getAllOrganizations_argsTupleScheme();
      }
    }

    private static class getAllOrganizations_argsTupleScheme extends TupleScheme<getAllOrganizations_args> {

      @Override
      public void write(org.apache.thrift.protocol.TProtocol prot, getAllOrganizations_args struct) throws org.apache.thrift.TException {
        TTupleProtocol oprot = (TTupleProtocol) prot;
      }

      @Override
      public void read(org.apache.thrift.protocol.TProtocol prot, getAllOrganizations_args struct) throws org.apache.thrift.TException {
        TTupleProtocol iprot = (TTupleProtocol) prot;
      }
    }

  }

  public static class getAllOrganizations_result implements org.apache.thrift.TBase<getAllOrganizations_result, getAllOrganizations_result._Fields>, java.io.Serializable, Cloneable, Comparable<getAllOrganizations_result>   {
    private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getAllOrganizations_result");

    private static final org.apache.thrift.protocol.TField SUCCESS_FIELD_DESC = new org.apache.thrift.protocol.TField("success", org.apache.thrift.protocol.TType.LIST, (short)0);

    private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
    static {
      schemes.put(StandardScheme.class, new getAllOrganizations_resultStandardSchemeFactory());
      schemes.put(TupleScheme.class, new getAllOrganizations_resultTupleSchemeFactory());
    }

    public List<Organization> success; // required

    /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
    public enum _Fields implements org.apache.thrift.TFieldIdEnum {
      SUCCESS((short)0, "success");

      private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();

      static {
        for (_Fields field : EnumSet.allOf(_Fields.class)) {
          byName.put(field.getFieldName(), field);
        }
      }

      /**
       * Find the _Fields constant that matches fieldId, or null if its not found.
       */
      public static _Fields findByThriftId(int fieldId) {
        switch(fieldId) {
          case 0: // SUCCESS
            return SUCCESS;
          default:
            return null;
        }
      }

      /**
       * Find the _Fields constant that matches fieldId, throwing an exception
       * if it is not found.
       */
      public static _Fields findByThriftIdOrThrow(int fieldId) {
        _Fields fields = findByThriftId(fieldId);
        if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
        return fields;
      }

      /**
       * Find the _Fields constant that matches name, or null if its not found.
       */
      public static _Fields findByName(String name) {
        return byName.get(name);
      }

      private final short _thriftId;
      private final String _fieldName;

      _Fields(short thriftId, String fieldName) {
        _thriftId = thriftId;
        _fieldName = fieldName;
      }

      public short getThriftFieldId() {
        return _thriftId;
      }

      public String getFieldName() {
        return _fieldName;
      }
    }

    // isset id assignments
    public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
    static {
      Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
      tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, 
          new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST, 
              new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, Organization.class))));
      metaDataMap = Collections.unmodifiableMap(tmpMap);
      org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getAllOrganizations_result.class, metaDataMap);
    }

    public getAllOrganizations_result() {
    }

    public getAllOrganizations_result(
      List<Organization> success)
    {
      this();
      this.success = success;
    }

    /**
     * Performs a deep copy on <i>other</i>.
     */
    public getAllOrganizations_result(getAllOrganizations_result other) {
      if (other.isSetSuccess()) {
        List<Organization> __this__success = new ArrayList<Organization>(other.success.size());
        for (Organization other_element : other.success) {
          __this__success.add(new Organization(other_element));
        }
        this.success = __this__success;
      }
    }

    public getAllOrganizations_result deepCopy() {
      return new getAllOrganizations_result(this);
    }

    @Override
    public void clear() {
      this.success = null;
    }

    public int getSuccessSize() {
      return (this.success == null) ? 0 : this.success.size();
    }

    public java.util.Iterator<Organization> getSuccessIterator() {
      return (this.success == null) ? null : this.success.iterator();
    }

    public void addToSuccess(Organization elem) {
      if (this.success == null) {
        this.success = new ArrayList<Organization>();
      }
      this.success.add(elem);
    }

    public List<Organization> getSuccess() {
      return this.success;
    }

    public getAllOrganizations_result setSuccess(List<Organization> success) {
      this.success = success;
      return this;
    }

    public void unsetSuccess() {
      this.success = null;
    }

    /** Returns true if field success is set (has been assigned a value) and false otherwise */
    public boolean isSetSuccess() {
      return this.success != null;
    }

    public void setSuccessIsSet(boolean value) {
      if (!value) {
        this.success = null;
      }
    }

    public void setFieldValue(_Fields field, Object value) {
      switch (field) {
      case SUCCESS:
        if (value == null) {
          unsetSuccess();
        } else {
          setSuccess((List<Organization>)value);
        }
        break;

      }
    }

    public Object getFieldValue(_Fields field) {
      switch (field) {
      case SUCCESS:
        return getSuccess();

      }
      throw new IllegalStateException();
    }

    /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
    public boolean isSet(_Fields field) {
      if (field == null) {
        throw new IllegalArgumentException();
      }

      switch (field) {
      case SUCCESS:
        return isSetSuccess();
      }
      throw new IllegalStateException();
    }

    @Override
    public boolean equals(Object that) {
      if (that == null)
        return false;
      if (that instanceof getAllOrganizations_result)
        return this.equals((getAllOrganizations_result)that);
      return false;
    }

    public boolean equals(getAllOrganizations_result that) {
      if (that == null)
        return false;

      boolean this_present_success = true && this.isSetSuccess();
      boolean that_present_success = true && that.isSetSuccess();
      if (this_present_success || that_present_success) {
        if (!(this_present_success && that_present_success))
          return false;
        if (!this.success.equals(that.success))
          return false;
      }

      return true;
    }

    @Override
    public int hashCode() {
      return 0;
    }

    @Override
    public int compareTo(getAllOrganizations_result other) {
      if (!getClass().equals(other.getClass())) {
        return getClass().getName().compareTo(other.getClass().getName());
      }

      int lastComparison = 0;

      lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(other.isSetSuccess());
      if (lastComparison != 0) {
        return lastComparison;
      }
      if (isSetSuccess()) {
        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, other.success);
        if (lastComparison != 0) {
          return lastComparison;
        }
      }
      return 0;
    }

    public _Fields fieldForId(int fieldId) {
      return _Fields.findByThriftId(fieldId);
    }

    public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
      schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
    }

    public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
      schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
      }

    @Override
    public String toString() {
      StringBuilder sb = new StringBuilder("getAllOrganizations_result(");
      boolean first = true;

      sb.append("success:");
      if (this.success == null) {
        sb.append("null");
      } else {
        sb.append(this.success);
      }
      first = false;
      sb.append(")");
      return sb.toString();
    }

    public void validate() throws org.apache.thrift.TException {
      // check for required fields
      // check for sub-struct validity
    }

    private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
      try {
        write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
      } catch (org.apache.thrift.TException te) {
        throw new java.io.IOException(te);
      }
    }

    private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
      try {
        read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
      } catch (org.apache.thrift.TException te) {
        throw new java.io.IOException(te);
      }
    }

    private static class getAllOrganizations_resultStandardSchemeFactory implements SchemeFactory {
      public getAllOrganizations_resultStandardScheme getScheme() {
        return new getAllOrganizations_resultStandardScheme();
      }
    }

    private static class getAllOrganizations_resultStandardScheme extends StandardScheme<getAllOrganizations_result> {

      public void read(org.apache.thrift.protocol.TProtocol iprot, getAllOrganizations_result struct) throws org.apache.thrift.TException {
        org.apache.thrift.protocol.TField schemeField;
        iprot.readStructBegin();
        while (true)
        {
          schemeField = iprot.readFieldBegin();
          if (schemeField.type == org.apache.thrift.protocol.TType.STOP) { 
            break;
          }
          switch (schemeField.id) {
            case 0: // SUCCESS
              if (schemeField.type == org.apache.thrift.protocol.TType.LIST) {
                {
                  org.apache.thrift.protocol.TList _list162 = iprot.readListBegin();
                  struct.success = new ArrayList<Organization>(_list162.size);
                  for (int _i163 = 0; _i163 < _list162.size; ++_i163)
                  {
                    Organization _elem164;
                    _elem164 = new Organization();
                    _elem164.read(iprot);
                    struct.success.add(_elem164);
                  }
                  iprot.readListEnd();
                }
                struct.setSuccessIsSet(true);
              } else { 
                org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
              }
              break;
            default:
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
          }
          iprot.readFieldEnd();
        }
        iprot.readStructEnd();

        // check for required fields of primitive type, which can't be checked in the validate method
        struct.validate();
      }

      public void write(org.apache.thrift.protocol.TProtocol oprot, getAllOrganizations_result struct) throws org.apache.thrift.TException {
        struct.validate();

        oprot.writeStructBegin(STRUCT_DESC);
        if (struct.success != null) {
          oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
          {
            oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.success.size()));
            for (Organization _iter165 : struct.success)
            {
              _iter165.write(oprot);
            }
            oprot.writeListEnd();
          }
          oprot.writeFieldEnd();
        }
        oprot.writeFieldStop();
        oprot.writeStructEnd();
      }

    }

    private static class getAllOrganizations_resultTupleSchemeFactory implements SchemeFactory {
      public getAllOrganizations_resultTupleScheme getScheme() {
        return new getAllOrganizations_resultTupleScheme();
      }
    }

    private static class getAllOrganizations_resultTupleScheme extends TupleScheme<getAllOrganizations_result> {

      @Override
      public void write(org.apache.thrift.protocol.TProtocol prot, getAllOrganizations_result struct) throws org.apache.thrift.TException {
        TTupleProtocol oprot = (TTupleProtocol) prot;
        BitSet optionals = new BitSet();
        if (struct.isSetSuccess()) {
          optionals.set(0);
        }
        oprot.writeBitSet(optionals, 1);
        if (struct.isSetSuccess()) {
          {
            oprot.writeI32(struct.success.size());
            for (Organization _iter166 : struct.success)
            {
              _iter166.write(oprot);
            }
          }
        }
      }

      @Override
      public void read(org.apache.thrift.protocol.TProtocol prot, getAllOrganizations_result struct) throws org.apache.thrift.TException {
        TTupleProtocol iprot = (TTupleProtocol) prot;
        BitSet incoming = iprot.readBitSet(1);
        if (incoming.get(0)) {
          {
            org.apache.thrift.protocol.TList _list167 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32());
            struct.success = new ArrayList<Organization>(_list167.size);
            for (int _i168 = 0; _i168 < _list167.size; ++_i168)
            {
              Organization _elem169;
              _elem169 = new Organization();
              _elem169.read(iprot);
              struct.success.add(_elem169);
            }
          }
          struct.setSuccessIsSet(true);
        }
      }
    }

  }

  public static class getImageList_args implements org.apache.thrift.TBase<getImageList_args, getImageList_args._Fields>, java.io.Serializable, Cloneable, Comparable<getImageList_args>   {
    private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getImageList_args");

    private static final org.apache.thrift.protocol.TField USER_TOKEN_FIELD_DESC = new org.apache.thrift.protocol.TField("userToken", org.apache.thrift.protocol.TType.STRING, (short)1);
    private static final org.apache.thrift.protocol.TField TAG_SEARCH_FIELD_DESC = new org.apache.thrift.protocol.TField("tagSearch", org.apache.thrift.protocol.TType.LIST, (short)2);
    private static final org.apache.thrift.protocol.TField PAGE_FIELD_DESC = new org.apache.thrift.protocol.TField("page", org.apache.thrift.protocol.TType.I32, (short)3);

    private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
    static {
      schemes.put(StandardScheme.class, new getImageList_argsStandardSchemeFactory());
      schemes.put(TupleScheme.class, new getImageList_argsTupleSchemeFactory());
    }

    public String userToken; // required
    public List<String> tagSearch; // required
    public int page; // required

    /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
    public enum _Fields implements org.apache.thrift.TFieldIdEnum {
      USER_TOKEN((short)1, "userToken"),
      TAG_SEARCH((short)2, "tagSearch"),
      PAGE((short)3, "page");

      private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();

      static {
        for (_Fields field : EnumSet.allOf(_Fields.class)) {
          byName.put(field.getFieldName(), field);
        }
      }

      /**
       * Find the _Fields constant that matches fieldId, or null if its not found.
       */
      public static _Fields findByThriftId(int fieldId) {
        switch(fieldId) {
          case 1: // USER_TOKEN
            return USER_TOKEN;
          case 2: // TAG_SEARCH
            return TAG_SEARCH;
          case 3: // PAGE
            return PAGE;
          default:
            return null;
        }
      }

      /**
       * Find the _Fields constant that matches fieldId, throwing an exception
       * if it is not found.
       */
      public static _Fields findByThriftIdOrThrow(int fieldId) {
        _Fields fields = findByThriftId(fieldId);
        if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
        return fields;
      }

      /**
       * Find the _Fields constant that matches name, or null if its not found.
       */
      public static _Fields findByName(String name) {
        return byName.get(name);
      }

      private final short _thriftId;
      private final String _fieldName;

      _Fields(short thriftId, String fieldName) {
        _thriftId = thriftId;
        _fieldName = fieldName;
      }

      public short getThriftFieldId() {
        return _thriftId;
      }

      public String getFieldName() {
        return _fieldName;
      }
    }

    // isset id assignments
    private static final int __PAGE_ISSET_ID = 0;
    private byte __isset_bitfield = 0;
    public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
    static {
      Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
      tmpMap.put(_Fields.USER_TOKEN, new org.apache.thrift.meta_data.FieldMetaData("userToken", org.apache.thrift.TFieldRequirementType.DEFAULT, 
          new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING          , "Token")));
      tmpMap.put(_Fields.TAG_SEARCH, new org.apache.thrift.meta_data.FieldMetaData("tagSearch", org.apache.thrift.TFieldRequirementType.DEFAULT, 
          new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST, 
              new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))));
      tmpMap.put(_Fields.PAGE, new org.apache.thrift.meta_data.FieldMetaData("page", org.apache.thrift.TFieldRequirementType.DEFAULT, 
          new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32)));
      metaDataMap = Collections.unmodifiableMap(tmpMap);
      org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getImageList_args.class, metaDataMap);
    }

    public getImageList_args() {
    }

    public getImageList_args(
      String userToken,
      List<String> tagSearch,
      int page)
    {
      this();
      this.userToken = userToken;
      this.tagSearch = tagSearch;
      this.page = page;
      setPageIsSet(true);
    }

    /**
     * Performs a deep copy on <i>other</i>.
     */
    public getImageList_args(getImageList_args other) {
      __isset_bitfield = other.__isset_bitfield;
      if (other.isSetUserToken()) {
        this.userToken = other.userToken;
      }
      if (other.isSetTagSearch()) {
        List<String> __this__tagSearch = new ArrayList<String>(other.tagSearch);
        this.tagSearch = __this__tagSearch;
      }
      this.page = other.page;
    }

    public getImageList_args deepCopy() {
      return new getImageList_args(this);
    }

    @Override
    public void clear() {
      this.userToken = null;
      this.tagSearch = null;
      setPageIsSet(false);
      this.page = 0;
    }

    public String getUserToken() {
      return this.userToken;
    }

    public getImageList_args setUserToken(String userToken) {
      this.userToken = userToken;
      return this;
    }

    public void unsetUserToken() {
      this.userToken = null;
    }

    /** Returns true if field userToken is set (has been assigned a value) and false otherwise */
    public boolean isSetUserToken() {
      return this.userToken != null;
    }

    public void setUserTokenIsSet(boolean value) {
      if (!value) {
        this.userToken = null;
      }
    }

    public int getTagSearchSize() {
      return (this.tagSearch == null) ? 0 : this.tagSearch.size();
    }

    public java.util.Iterator<String> getTagSearchIterator() {
      return (this.tagSearch == null) ? null : this.tagSearch.iterator();
    }

    public void addToTagSearch(String elem) {
      if (this.tagSearch == null) {
        this.tagSearch = new ArrayList<String>();
      }
      this.tagSearch.add(elem);
    }

    public List<String> getTagSearch() {
      return this.tagSearch;
    }

    public getImageList_args setTagSearch(List<String> tagSearch) {
      this.tagSearch = tagSearch;
      return this;
    }

    public void unsetTagSearch() {
      this.tagSearch = null;
    }

    /** Returns true if field tagSearch is set (has been assigned a value) and false otherwise */
    public boolean isSetTagSearch() {
      return this.tagSearch != null;
    }

    public void setTagSearchIsSet(boolean value) {
      if (!value) {
        this.tagSearch = null;
      }
    }

    public int getPage() {
      return this.page;
    }

    public getImageList_args setPage(int page) {
      this.page = page;
      setPageIsSet(true);
      return this;
    }

    public void unsetPage() {
      __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __PAGE_ISSET_ID);
    }

    /** Returns true if field page is set (has been assigned a value) and false otherwise */
    public boolean isSetPage() {
      return EncodingUtils.testBit(__isset_bitfield, __PAGE_ISSET_ID);
    }

    public void setPageIsSet(boolean value) {
      __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __PAGE_ISSET_ID, value);
    }

    public void setFieldValue(_Fields field, Object value) {
      switch (field) {
      case USER_TOKEN:
        if (value == null) {
          unsetUserToken();
        } else {
          setUserToken((String)value);
        }
        break;

      case TAG_SEARCH:
        if (value == null) {
          unsetTagSearch();
        } else {
          setTagSearch((List<String>)value);
        }
        break;

      case PAGE:
        if (value == null) {
          unsetPage();
        } else {
          setPage((Integer)value);
        }
        break;

      }
    }

    public Object getFieldValue(_Fields field) {
      switch (field) {
      case USER_TOKEN:
        return getUserToken();

      case TAG_SEARCH:
        return getTagSearch();

      case PAGE:
        return Integer.valueOf(getPage());

      }
      throw new IllegalStateException();
    }

    /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
    public boolean isSet(_Fields field) {
      if (field == null) {
        throw new IllegalArgumentException();
      }

      switch (field) {
      case USER_TOKEN:
        return isSetUserToken();
      case TAG_SEARCH:
        return isSetTagSearch();
      case PAGE:
        return isSetPage();
      }
      throw new IllegalStateException();
    }

    @Override
    public boolean equals(Object that) {
      if (that == null)
        return false;
      if (that instanceof getImageList_args)
        return this.equals((getImageList_args)that);
      return false;
    }

    public boolean equals(getImageList_args that) {
      if (that == null)
        return false;

      boolean this_present_userToken = true && this.isSetUserToken();
      boolean that_present_userToken = true && that.isSetUserToken();
      if (this_present_userToken || that_present_userToken) {
        if (!(this_present_userToken && that_present_userToken))
          return false;
        if (!this.userToken.equals(that.userToken))
          return false;
      }

      boolean this_present_tagSearch = true && this.isSetTagSearch();
      boolean that_present_tagSearch = true && that.isSetTagSearch();
      if (this_present_tagSearch || that_present_tagSearch) {
        if (!(this_present_tagSearch && that_present_tagSearch))
          return false;
        if (!this.tagSearch.equals(that.tagSearch))
          return false;
      }

      boolean this_present_page = true;
      boolean that_present_page = true;
      if (this_present_page || that_present_page) {
        if (!(this_present_page && that_present_page))
          return false;
        if (this.page != that.page)
          return false;
      }

      return true;
    }

    @Override
    public int hashCode() {
      return 0;
    }

    @Override
    public int compareTo(getImageList_args other) {
      if (!getClass().equals(other.getClass())) {
        return getClass().getName().compareTo(other.getClass().getName());
      }

      int lastComparison = 0;

      lastComparison = Boolean.valueOf(isSetUserToken()).compareTo(other.isSetUserToken());
      if (lastComparison != 0) {
        return lastComparison;
      }
      if (isSetUserToken()) {
        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.userToken, other.userToken);
        if (lastComparison != 0) {
          return lastComparison;
        }
      }
      lastComparison = Boolean.valueOf(isSetTagSearch()).compareTo(other.isSetTagSearch());
      if (lastComparison != 0) {
        return lastComparison;
      }
      if (isSetTagSearch()) {
        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.tagSearch, other.tagSearch);
        if (lastComparison != 0) {
          return lastComparison;
        }
      }
      lastComparison = Boolean.valueOf(isSetPage()).compareTo(other.isSetPage());
      if (lastComparison != 0) {
        return lastComparison;
      }
      if (isSetPage()) {
        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.page, other.page);
        if (lastComparison != 0) {
          return lastComparison;
        }
      }
      return 0;
    }

    public _Fields fieldForId(int fieldId) {
      return _Fields.findByThriftId(fieldId);
    }

    public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
      schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
    }

    public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
      schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
    }

    @Override
    public String toString() {
      StringBuilder sb = new StringBuilder("getImageList_args(");
      boolean first = true;

      sb.append("userToken:");
      if (this.userToken == null) {
        sb.append("null");
      } else {
        sb.append(this.userToken);
      }
      first = false;
      if (!first) sb.append(", ");
      sb.append("tagSearch:");
      if (this.tagSearch == null) {
        sb.append("null");
      } else {
        sb.append(this.tagSearch);
      }
      first = false;
      if (!first) sb.append(", ");
      sb.append("page:");
      sb.append(this.page);
      first = false;
      sb.append(")");
      return sb.toString();
    }

    public void validate() throws org.apache.thrift.TException {
      // check for required fields
      // check for sub-struct validity
    }

    private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
      try {
        write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
      } catch (org.apache.thrift.TException te) {
        throw new java.io.IOException(te);
      }
    }

    private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
      try {
        // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor.
        __isset_bitfield = 0;
        read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
      } catch (org.apache.thrift.TException te) {
        throw new java.io.IOException(te);
      }
    }

    private static class getImageList_argsStandardSchemeFactory implements SchemeFactory {
      public getImageList_argsStandardScheme getScheme() {
        return new getImageList_argsStandardScheme();
      }
    }

    private static class getImageList_argsStandardScheme extends StandardScheme<getImageList_args> {

      public void read(org.apache.thrift.protocol.TProtocol iprot, getImageList_args struct) throws org.apache.thrift.TException {
        org.apache.thrift.protocol.TField schemeField;
        iprot.readStructBegin();
        while (true)
        {
          schemeField = iprot.readFieldBegin();
          if (schemeField.type == org.apache.thrift.protocol.TType.STOP) { 
            break;
          }
          switch (schemeField.id) {
            case 1: // USER_TOKEN
              if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
                struct.userToken = iprot.readString();
                struct.setUserTokenIsSet(true);
              } else { 
                org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
              }
              break;
            case 2: // TAG_SEARCH
              if (schemeField.type == org.apache.thrift.protocol.TType.LIST) {
                {
                  org.apache.thrift.protocol.TList _list170 = iprot.readListBegin();
                  struct.tagSearch = new ArrayList<String>(_list170.size);
                  for (int _i171 = 0; _i171 < _list170.size; ++_i171)
                  {
                    String _elem172;
                    _elem172 = iprot.readString();
                    struct.tagSearch.add(_elem172);
                  }
                  iprot.readListEnd();
                }
                struct.setTagSearchIsSet(true);
              } else { 
                org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
              }
              break;
            case 3: // PAGE
              if (schemeField.type == org.apache.thrift.protocol.TType.I32) {
                struct.page = iprot.readI32();
                struct.setPageIsSet(true);
              } else { 
                org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
              }
              break;
            default:
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
          }
          iprot.readFieldEnd();
        }
        iprot.readStructEnd();

        // check for required fields of primitive type, which can't be checked in the validate method
        struct.validate();
      }

      public void write(org.apache.thrift.protocol.TProtocol oprot, getImageList_args struct) throws org.apache.thrift.TException {
        struct.validate();

        oprot.writeStructBegin(STRUCT_DESC);
        if (struct.userToken != null) {
          oprot.writeFieldBegin(USER_TOKEN_FIELD_DESC);
          oprot.writeString(struct.userToken);
          oprot.writeFieldEnd();
        }
        if (struct.tagSearch != null) {
          oprot.writeFieldBegin(TAG_SEARCH_FIELD_DESC);
          {
            oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.tagSearch.size()));
            for (String _iter173 : struct.tagSearch)
            {
              oprot.writeString(_iter173);
            }
            oprot.writeListEnd();
          }
          oprot.writeFieldEnd();
        }
        oprot.writeFieldBegin(PAGE_FIELD_DESC);
        oprot.writeI32(struct.page);
        oprot.writeFieldEnd();
        oprot.writeFieldStop();
        oprot.writeStructEnd();
      }

    }

    private static class getImageList_argsTupleSchemeFactory implements SchemeFactory {
      public getImageList_argsTupleScheme getScheme() {
        return new getImageList_argsTupleScheme();
      }
    }

    private static class getImageList_argsTupleScheme extends TupleScheme<getImageList_args> {

      @Override
      public void write(org.apache.thrift.protocol.TProtocol prot, getImageList_args struct) throws org.apache.thrift.TException {
        TTupleProtocol oprot = (TTupleProtocol) prot;
        BitSet optionals = new BitSet();
        if (struct.isSetUserToken()) {
          optionals.set(0);
        }
        if (struct.isSetTagSearch()) {
          optionals.set(1);
        }
        if (struct.isSetPage()) {
          optionals.set(2);
        }
        oprot.writeBitSet(optionals, 3);
        if (struct.isSetUserToken()) {
          oprot.writeString(struct.userToken);
        }
        if (struct.isSetTagSearch()) {
          {
            oprot.writeI32(struct.tagSearch.size());
            for (String _iter174 : struct.tagSearch)
            {
              oprot.writeString(_iter174);
            }
          }
        }
        if (struct.isSetPage()) {
          oprot.writeI32(struct.page);
        }
      }

      @Override
      public void read(org.apache.thrift.protocol.TProtocol prot, getImageList_args struct) throws org.apache.thrift.TException {
        TTupleProtocol iprot = (TTupleProtocol) prot;
        BitSet incoming = iprot.readBitSet(3);
        if (incoming.get(0)) {
          struct.userToken = iprot.readString();
          struct.setUserTokenIsSet(true);
        }
        if (incoming.get(1)) {
          {
            org.apache.thrift.protocol.TList _list175 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32());
            struct.tagSearch = new ArrayList<String>(_list175.size);
            for (int _i176 = 0; _i176 < _list175.size; ++_i176)
            {
              String _elem177;
              _elem177 = iprot.readString();
              struct.tagSearch.add(_elem177);
            }
          }
          struct.setTagSearchIsSet(true);
        }
        if (incoming.get(2)) {
          struct.page = iprot.readI32();
          struct.setPageIsSet(true);
        }
      }
    }

  }

  public static class getImageList_result implements org.apache.thrift.TBase<getImageList_result, getImageList_result._Fields>, java.io.Serializable, Cloneable, Comparable<getImageList_result>   {
    private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getImageList_result");

    private static final org.apache.thrift.protocol.TField SUCCESS_FIELD_DESC = new org.apache.thrift.protocol.TField("success", org.apache.thrift.protocol.TType.LIST, (short)0);
    private static final org.apache.thrift.protocol.TField AUTH_ERROR_FIELD_DESC = new org.apache.thrift.protocol.TField("authError", org.apache.thrift.protocol.TType.STRUCT, (short)1);
    private static final org.apache.thrift.protocol.TField SERVER_ERROR_FIELD_DESC = new org.apache.thrift.protocol.TField("serverError", org.apache.thrift.protocol.TType.STRUCT, (short)2);

    private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
    static {
      schemes.put(StandardScheme.class, new getImageList_resultStandardSchemeFactory());
      schemes.put(TupleScheme.class, new getImageList_resultTupleSchemeFactory());
    }

    public List<ImageSummaryRead> success; // required
    public TAuthorizationException authError; // required
    public TInternalServerError serverError; // required

    /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
    public enum _Fields implements org.apache.thrift.TFieldIdEnum {
      SUCCESS((short)0, "success"),
      AUTH_ERROR((short)1, "authError"),
      SERVER_ERROR((short)2, "serverError");

      private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();

      static {
        for (_Fields field : EnumSet.allOf(_Fields.class)) {
          byName.put(field.getFieldName(), field);
        }
      }

      /**
       * Find the _Fields constant that matches fieldId, or null if its not found.
       */
      public static _Fields findByThriftId(int fieldId) {
        switch(fieldId) {
          case 0: // SUCCESS
            return SUCCESS;
          case 1: // AUTH_ERROR
            return AUTH_ERROR;
          case 2: // SERVER_ERROR
            return SERVER_ERROR;
          default:
            return null;
        }
      }

      /**
       * Find the _Fields constant that matches fieldId, throwing an exception
       * if it is not found.
       */
      public static _Fields findByThriftIdOrThrow(int fieldId) {
        _Fields fields = findByThriftId(fieldId);
        if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
        return fields;
      }

      /**
       * Find the _Fields constant that matches name, or null if its not found.
       */
      public static _Fields findByName(String name) {
        return byName.get(name);
      }

      private final short _thriftId;
      private final String _fieldName;

      _Fields(short thriftId, String fieldName) {
        _thriftId = thriftId;
        _fieldName = fieldName;
      }

      public short getThriftFieldId() {
        return _thriftId;
      }

      public String getFieldName() {
        return _fieldName;
      }
    }

    // isset id assignments
    public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
    static {
      Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
      tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, 
          new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST, 
              new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, ImageSummaryRead.class))));
      tmpMap.put(_Fields.AUTH_ERROR, new org.apache.thrift.meta_data.FieldMetaData("authError", org.apache.thrift.TFieldRequirementType.DEFAULT, 
          new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT)));
      tmpMap.put(_Fields.SERVER_ERROR, new org.apache.thrift.meta_data.FieldMetaData("serverError", org.apache.thrift.TFieldRequirementType.DEFAULT, 
          new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT)));
      metaDataMap = Collections.unmodifiableMap(tmpMap);
      org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getImageList_result.class, metaDataMap);
    }

    public getImageList_result() {
    }

    public getImageList_result(
      List<ImageSummaryRead> success,
      TAuthorizationException authError,
      TInternalServerError serverError)
    {
      this();
      this.success = success;
      this.authError = authError;
      this.serverError = serverError;
    }

    /**
     * Performs a deep copy on <i>other</i>.
     */
    public getImageList_result(getImageList_result other) {
      if (other.isSetSuccess()) {
        List<ImageSummaryRead> __this__success = new ArrayList<ImageSummaryRead>(other.success.size());
        for (ImageSummaryRead other_element : other.success) {
          __this__success.add(new ImageSummaryRead(other_element));
        }
        this.success = __this__success;
      }
      if (other.isSetAuthError()) {
        this.authError = new TAuthorizationException(other.authError);
      }
      if (other.isSetServerError()) {
        this.serverError = new TInternalServerError(other.serverError);
      }
    }

    public getImageList_result deepCopy() {
      return new getImageList_result(this);
    }

    @Override
    public void clear() {
      this.success = null;
      this.authError = null;
      this.serverError = null;
    }

    public int getSuccessSize() {
      return (this.success == null) ? 0 : this.success.size();
    }

    public java.util.Iterator<ImageSummaryRead> getSuccessIterator() {
      return (this.success == null) ? null : this.success.iterator();
    }

    public void addToSuccess(ImageSummaryRead elem) {
      if (this.success == null) {
        this.success = new ArrayList<ImageSummaryRead>();
      }
      this.success.add(elem);
    }

    public List<ImageSummaryRead> getSuccess() {
      return this.success;
    }

    public getImageList_result setSuccess(List<ImageSummaryRead> success) {
      this.success = success;
      return this;
    }

    public void unsetSuccess() {
      this.success = null;
    }

    /** Returns true if field success is set (has been assigned a value) and false otherwise */
    public boolean isSetSuccess() {
      return this.success != null;
    }

    public void setSuccessIsSet(boolean value) {
      if (!value) {
        this.success = null;
      }
    }

    public TAuthorizationException getAuthError() {
      return this.authError;
    }

    public getImageList_result setAuthError(TAuthorizationException authError) {
      this.authError = authError;
      return this;
    }

    public void unsetAuthError() {
      this.authError = null;
    }

    /** Returns true if field authError is set (has been assigned a value) and false otherwise */
    public boolean isSetAuthError() {
      return this.authError != null;
    }

    public void setAuthErrorIsSet(boolean value) {
      if (!value) {
        this.authError = null;
      }
    }

    public TInternalServerError getServerError() {
      return this.serverError;
    }

    public getImageList_result setServerError(TInternalServerError serverError) {
      this.serverError = serverError;
      return this;
    }

    public void unsetServerError() {
      this.serverError = null;
    }

    /** Returns true if field serverError is set (has been assigned a value) and false otherwise */
    public boolean isSetServerError() {
      return this.serverError != null;
    }

    public void setServerErrorIsSet(boolean value) {
      if (!value) {
        this.serverError = null;
      }
    }

    public void setFieldValue(_Fields field, Object value) {
      switch (field) {
      case SUCCESS:
        if (value == null) {
          unsetSuccess();
        } else {
          setSuccess((List<ImageSummaryRead>)value);
        }
        break;

      case AUTH_ERROR:
        if (value == null) {
          unsetAuthError();
        } else {
          setAuthError((TAuthorizationException)value);
        }
        break;

      case SERVER_ERROR:
        if (value == null) {
          unsetServerError();
        } else {
          setServerError((TInternalServerError)value);
        }
        break;

      }
    }

    public Object getFieldValue(_Fields field) {
      switch (field) {
      case SUCCESS:
        return getSuccess();

      case AUTH_ERROR:
        return getAuthError();

      case SERVER_ERROR:
        return getServerError();

      }
      throw new IllegalStateException();
    }

    /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
    public boolean isSet(_Fields field) {
      if (field == null) {
        throw new IllegalArgumentException();
      }

      switch (field) {
      case SUCCESS:
        return isSetSuccess();
      case AUTH_ERROR:
        return isSetAuthError();
      case SERVER_ERROR:
        return isSetServerError();
      }
      throw new IllegalStateException();
    }

    @Override
    public boolean equals(Object that) {
      if (that == null)
        return false;
      if (that instanceof getImageList_result)
        return this.equals((getImageList_result)that);
      return false;
    }

    public boolean equals(getImageList_result that) {
      if (that == null)
        return false;

      boolean this_present_success = true && this.isSetSuccess();
      boolean that_present_success = true && that.isSetSuccess();
      if (this_present_success || that_present_success) {
        if (!(this_present_success && that_present_success))
          return false;
        if (!this.success.equals(that.success))
          return false;
      }

      boolean this_present_authError = true && this.isSetAuthError();
      boolean that_present_authError = true && that.isSetAuthError();
      if (this_present_authError || that_present_authError) {
        if (!(this_present_authError && that_present_authError))
          return false;
        if (!this.authError.equals(that.authError))
          return false;
      }

      boolean this_present_serverError = true && this.isSetServerError();
      boolean that_present_serverError = true && that.isSetServerError();
      if (this_present_serverError || that_present_serverError) {
        if (!(this_present_serverError && that_present_serverError))
          return false;
        if (!this.serverError.equals(that.serverError))
          return false;
      }

      return true;
    }

    @Override
    public int hashCode() {
      return 0;
    }

    @Override
    public int compareTo(getImageList_result other) {
      if (!getClass().equals(other.getClass())) {
        return getClass().getName().compareTo(other.getClass().getName());
      }

      int lastComparison = 0;

      lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(other.isSetSuccess());
      if (lastComparison != 0) {
        return lastComparison;
      }
      if (isSetSuccess()) {
        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, other.success);
        if (lastComparison != 0) {
          return lastComparison;
        }
      }
      lastComparison = Boolean.valueOf(isSetAuthError()).compareTo(other.isSetAuthError());
      if (lastComparison != 0) {
        return lastComparison;
      }
      if (isSetAuthError()) {
        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.authError, other.authError);
        if (lastComparison != 0) {
          return lastComparison;
        }
      }
      lastComparison = Boolean.valueOf(isSetServerError()).compareTo(other.isSetServerError());
      if (lastComparison != 0) {
        return lastComparison;
      }
      if (isSetServerError()) {
        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.serverError, other.serverError);
        if (lastComparison != 0) {
          return lastComparison;
        }
      }
      return 0;
    }

    public _Fields fieldForId(int fieldId) {
      return _Fields.findByThriftId(fieldId);
    }

    public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
      schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
    }

    public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
      schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
      }

    @Override
    public String toString() {
      StringBuilder sb = new StringBuilder("getImageList_result(");
      boolean first = true;

      sb.append("success:");
      if (this.success == null) {
        sb.append("null");
      } else {
        sb.append(this.success);
      }
      first = false;
      if (!first) sb.append(", ");
      sb.append("authError:");
      if (this.authError == null) {
        sb.append("null");
      } else {
        sb.append(this.authError);
      }
      first = false;
      if (!first) sb.append(", ");
      sb.append("serverError:");
      if (this.serverError == null) {
        sb.append("null");
      } else {
        sb.append(this.serverError);
      }
      first = false;
      sb.append(")");
      return sb.toString();
    }

    public void validate() throws org.apache.thrift.TException {
      // check for required fields
      // check for sub-struct validity
    }

    private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
      try {
        write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
      } catch (org.apache.thrift.TException te) {
        throw new java.io.IOException(te);
      }
    }

    private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
      try {
        read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
      } catch (org.apache.thrift.TException te) {
        throw new java.io.IOException(te);
      }
    }

    private static class getImageList_resultStandardSchemeFactory implements SchemeFactory {
      public getImageList_resultStandardScheme getScheme() {
        return new getImageList_resultStandardScheme();
      }
    }

    private static class getImageList_resultStandardScheme extends StandardScheme<getImageList_result> {

      public void read(org.apache.thrift.protocol.TProtocol iprot, getImageList_result struct) throws org.apache.thrift.TException {
        org.apache.thrift.protocol.TField schemeField;
        iprot.readStructBegin();
        while (true)
        {
          schemeField = iprot.readFieldBegin();
          if (schemeField.type == org.apache.thrift.protocol.TType.STOP) { 
            break;
          }
          switch (schemeField.id) {
            case 0: // SUCCESS
              if (schemeField.type == org.apache.thrift.protocol.TType.LIST) {
                {
                  org.apache.thrift.protocol.TList _list178 = iprot.readListBegin();
                  struct.success = new ArrayList<ImageSummaryRead>(_list178.size);
                  for (int _i179 = 0; _i179 < _list178.size; ++_i179)
                  {
                    ImageSummaryRead _elem180;
                    _elem180 = new ImageSummaryRead();
                    _elem180.read(iprot);
                    struct.success.add(_elem180);
                  }
                  iprot.readListEnd();
                }
                struct.setSuccessIsSet(true);
              } else { 
                org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
              }
              break;
            case 1: // AUTH_ERROR
              if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
                struct.authError = new TAuthorizationException();
                struct.authError.read(iprot);
                struct.setAuthErrorIsSet(true);
              } else { 
                org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
              }
              break;
            case 2: // SERVER_ERROR
              if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
                struct.serverError = new TInternalServerError();
                struct.serverError.read(iprot);
                struct.setServerErrorIsSet(true);
              } else { 
                org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
              }
              break;
            default:
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
          }
          iprot.readFieldEnd();
        }
        iprot.readStructEnd();

        // check for required fields of primitive type, which can't be checked in the validate method
        struct.validate();
      }

      public void write(org.apache.thrift.protocol.TProtocol oprot, getImageList_result struct) throws org.apache.thrift.TException {
        struct.validate();

        oprot.writeStructBegin(STRUCT_DESC);
        if (struct.success != null) {
          oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
          {
            oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.success.size()));
            for (ImageSummaryRead _iter181 : struct.success)
            {
              _iter181.write(oprot);
            }
            oprot.writeListEnd();
          }
          oprot.writeFieldEnd();
        }
        if (struct.authError != null) {
          oprot.writeFieldBegin(AUTH_ERROR_FIELD_DESC);
          struct.authError.write(oprot);
          oprot.writeFieldEnd();
        }
        if (struct.serverError != null) {
          oprot.writeFieldBegin(SERVER_ERROR_FIELD_DESC);
          struct.serverError.write(oprot);
          oprot.writeFieldEnd();
        }
        oprot.writeFieldStop();
        oprot.writeStructEnd();
      }

    }

    private static class getImageList_resultTupleSchemeFactory implements SchemeFactory {
      public getImageList_resultTupleScheme getScheme() {
        return new getImageList_resultTupleScheme();
      }
    }

    private static class getImageList_resultTupleScheme extends TupleScheme<getImageList_result> {

      @Override
      public void write(org.apache.thrift.protocol.TProtocol prot, getImageList_result struct) throws org.apache.thrift.TException {
        TTupleProtocol oprot = (TTupleProtocol) prot;
        BitSet optionals = new BitSet();
        if (struct.isSetSuccess()) {
          optionals.set(0);
        }
        if (struct.isSetAuthError()) {
          optionals.set(1);
        }
        if (struct.isSetServerError()) {
          optionals.set(2);
        }
        oprot.writeBitSet(optionals, 3);
        if (struct.isSetSuccess()) {
          {
            oprot.writeI32(struct.success.size());
            for (ImageSummaryRead _iter182 : struct.success)
            {
              _iter182.write(oprot);
            }
          }
        }
        if (struct.isSetAuthError()) {
          struct.authError.write(oprot);
        }
        if (struct.isSetServerError()) {
          struct.serverError.write(oprot);
        }
      }

      @Override
      public void read(org.apache.thrift.protocol.TProtocol prot, getImageList_result struct) throws org.apache.thrift.TException {
        TTupleProtocol iprot = (TTupleProtocol) prot;
        BitSet incoming = iprot.readBitSet(3);
        if (incoming.get(0)) {
          {
            org.apache.thrift.protocol.TList _list183 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32());
            struct.success = new ArrayList<ImageSummaryRead>(_list183.size);
            for (int _i184 = 0; _i184 < _list183.size; ++_i184)
            {
              ImageSummaryRead _elem185;
              _elem185 = new ImageSummaryRead();
              _elem185.read(iprot);
              struct.success.add(_elem185);
            }
          }
          struct.setSuccessIsSet(true);
        }
        if (incoming.get(1)) {
          struct.authError = new TAuthorizationException();
          struct.authError.read(iprot);
          struct.setAuthErrorIsSet(true);
        }
        if (incoming.get(2)) {
          struct.serverError = new TInternalServerError();
          struct.serverError.read(iprot);
          struct.setServerErrorIsSet(true);
        }
      }
    }

  }

  public static class getImageDetails_args implements org.apache.thrift.TBase<getImageDetails_args, getImageDetails_args._Fields>, java.io.Serializable, Cloneable, Comparable<getImageDetails_args>   {
    private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getImageDetails_args");

    private static final org.apache.thrift.protocol.TField USER_TOKEN_FIELD_DESC = new org.apache.thrift.protocol.TField("userToken", org.apache.thrift.protocol.TType.STRING, (short)1);
    private static final org.apache.thrift.protocol.TField IMAGE_BASE_ID_FIELD_DESC = new org.apache.thrift.protocol.TField("imageBaseId", org.apache.thrift.protocol.TType.STRING, (short)2);

    private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
    static {
      schemes.put(StandardScheme.class, new getImageDetails_argsStandardSchemeFactory());
      schemes.put(TupleScheme.class, new getImageDetails_argsTupleSchemeFactory());
    }

    public String userToken; // required
    public String imageBaseId; // required

    /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
    public enum _Fields implements org.apache.thrift.TFieldIdEnum {
      USER_TOKEN((short)1, "userToken"),
      IMAGE_BASE_ID((short)2, "imageBaseId");

      private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();

      static {
        for (_Fields field : EnumSet.allOf(_Fields.class)) {
          byName.put(field.getFieldName(), field);
        }
      }

      /**
       * Find the _Fields constant that matches fieldId, or null if its not found.
       */
      public static _Fields findByThriftId(int fieldId) {
        switch(fieldId) {
          case 1: // USER_TOKEN
            return USER_TOKEN;
          case 2: // IMAGE_BASE_ID
            return IMAGE_BASE_ID;
          default:
            return null;
        }
      }

      /**
       * Find the _Fields constant that matches fieldId, throwing an exception
       * if it is not found.
       */
      public static _Fields findByThriftIdOrThrow(int fieldId) {
        _Fields fields = findByThriftId(fieldId);
        if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
        return fields;
      }

      /**
       * Find the _Fields constant that matches name, or null if its not found.
       */
      public static _Fields findByName(String name) {
        return byName.get(name);
      }

      private final short _thriftId;
      private final String _fieldName;

      _Fields(short thriftId, String fieldName) {
        _thriftId = thriftId;
        _fieldName = fieldName;
      }

      public short getThriftFieldId() {
        return _thriftId;
      }

      public String getFieldName() {
        return _fieldName;
      }
    }

    // isset id assignments
    public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
    static {
      Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
      tmpMap.put(_Fields.USER_TOKEN, new org.apache.thrift.meta_data.FieldMetaData("userToken", org.apache.thrift.TFieldRequirementType.DEFAULT, 
          new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING          , "Token")));
      tmpMap.put(_Fields.IMAGE_BASE_ID, new org.apache.thrift.meta_data.FieldMetaData("imageBaseId", org.apache.thrift.TFieldRequirementType.DEFAULT, 
          new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING          , "UUID")));
      metaDataMap = Collections.unmodifiableMap(tmpMap);
      org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getImageDetails_args.class, metaDataMap);
    }

    public getImageDetails_args() {
    }

    public getImageDetails_args(
      String userToken,
      String imageBaseId)
    {
      this();
      this.userToken = userToken;
      this.imageBaseId = imageBaseId;
    }

    /**
     * Performs a deep copy on <i>other</i>.
     */
    public getImageDetails_args(getImageDetails_args other) {
      if (other.isSetUserToken()) {
        this.userToken = other.userToken;
      }
      if (other.isSetImageBaseId()) {
        this.imageBaseId = other.imageBaseId;
      }
    }

    public getImageDetails_args deepCopy() {
      return new getImageDetails_args(this);
    }

    @Override
    public void clear() {
      this.userToken = null;
      this.imageBaseId = null;
    }

    public String getUserToken() {
      return this.userToken;
    }

    public getImageDetails_args setUserToken(String userToken) {
      this.userToken = userToken;
      return this;
    }

    public void unsetUserToken() {
      this.userToken = null;
    }

    /** Returns true if field userToken is set (has been assigned a value) and false otherwise */
    public boolean isSetUserToken() {
      return this.userToken != null;
    }

    public void setUserTokenIsSet(boolean value) {
      if (!value) {
        this.userToken = null;
      }
    }

    public String getImageBaseId() {
      return this.imageBaseId;
    }

    public getImageDetails_args setImageBaseId(String imageBaseId) {
      this.imageBaseId = imageBaseId;
      return this;
    }

    public void unsetImageBaseId() {
      this.imageBaseId = null;
    }

    /** Returns true if field imageBaseId is set (has been assigned a value) and false otherwise */
    public boolean isSetImageBaseId() {
      return this.imageBaseId != null;
    }

    public void setImageBaseIdIsSet(boolean value) {
      if (!value) {
        this.imageBaseId = null;
      }
    }

    public void setFieldValue(_Fields field, Object value) {
      switch (field) {
      case USER_TOKEN:
        if (value == null) {
          unsetUserToken();
        } else {
          setUserToken((String)value);
        }
        break;

      case IMAGE_BASE_ID:
        if (value == null) {
          unsetImageBaseId();
        } else {
          setImageBaseId((String)value);
        }
        break;

      }
    }

    public Object getFieldValue(_Fields field) {
      switch (field) {
      case USER_TOKEN:
        return getUserToken();

      case IMAGE_BASE_ID:
        return getImageBaseId();

      }
      throw new IllegalStateException();
    }

    /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
    public boolean isSet(_Fields field) {
      if (field == null) {
        throw new IllegalArgumentException();
      }

      switch (field) {
      case USER_TOKEN:
        return isSetUserToken();
      case IMAGE_BASE_ID:
        return isSetImageBaseId();
      }
      throw new IllegalStateException();
    }

    @Override
    public boolean equals(Object that) {
      if (that == null)
        return false;
      if (that instanceof getImageDetails_args)
        return this.equals((getImageDetails_args)that);
      return false;
    }

    public boolean equals(getImageDetails_args that) {
      if (that == null)
        return false;

      boolean this_present_userToken = true && this.isSetUserToken();
      boolean that_present_userToken = true && that.isSetUserToken();
      if (this_present_userToken || that_present_userToken) {
        if (!(this_present_userToken && that_present_userToken))
          return false;
        if (!this.userToken.equals(that.userToken))
          return false;
      }

      boolean this_present_imageBaseId = true && this.isSetImageBaseId();
      boolean that_present_imageBaseId = true && that.isSetImageBaseId();
      if (this_present_imageBaseId || that_present_imageBaseId) {
        if (!(this_present_imageBaseId && that_present_imageBaseId))
          return false;
        if (!this.imageBaseId.equals(that.imageBaseId))
          return false;
      }

      return true;
    }

    @Override
    public int hashCode() {
      return 0;
    }

    @Override
    public int compareTo(getImageDetails_args other) {
      if (!getClass().equals(other.getClass())) {
        return getClass().getName().compareTo(other.getClass().getName());
      }

      int lastComparison = 0;

      lastComparison = Boolean.valueOf(isSetUserToken()).compareTo(other.isSetUserToken());
      if (lastComparison != 0) {
        return lastComparison;
      }
      if (isSetUserToken()) {
        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.userToken, other.userToken);
        if (lastComparison != 0) {
          return lastComparison;
        }
      }
      lastComparison = Boolean.valueOf(isSetImageBaseId()).compareTo(other.isSetImageBaseId());
      if (lastComparison != 0) {
        return lastComparison;
      }
      if (isSetImageBaseId()) {
        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.imageBaseId, other.imageBaseId);
        if (lastComparison != 0) {
          return lastComparison;
        }
      }
      return 0;
    }

    public _Fields fieldForId(int fieldId) {
      return _Fields.findByThriftId(fieldId);
    }

    public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
      schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
    }

    public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
      schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
    }

    @Override
    public String toString() {
      StringBuilder sb = new StringBuilder("getImageDetails_args(");
      boolean first = true;

      sb.append("userToken:");
      if (this.userToken == null) {
        sb.append("null");
      } else {
        sb.append(this.userToken);
      }
      first = false;
      if (!first) sb.append(", ");
      sb.append("imageBaseId:");
      if (this.imageBaseId == null) {
        sb.append("null");
      } else {
        sb.append(this.imageBaseId);
      }
      first = false;
      sb.append(")");
      return sb.toString();
    }

    public void validate() throws org.apache.thrift.TException {
      // check for required fields
      // check for sub-struct validity
    }

    private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
      try {
        write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
      } catch (org.apache.thrift.TException te) {
        throw new java.io.IOException(te);
      }
    }

    private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
      try {
        read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
      } catch (org.apache.thrift.TException te) {
        throw new java.io.IOException(te);
      }
    }

    private static class getImageDetails_argsStandardSchemeFactory implements SchemeFactory {
      public getImageDetails_argsStandardScheme getScheme() {
        return new getImageDetails_argsStandardScheme();
      }
    }

    private static class getImageDetails_argsStandardScheme extends StandardScheme<getImageDetails_args> {

      public void read(org.apache.thrift.protocol.TProtocol iprot, getImageDetails_args struct) throws org.apache.thrift.TException {
        org.apache.thrift.protocol.TField schemeField;
        iprot.readStructBegin();
        while (true)
        {
          schemeField = iprot.readFieldBegin();
          if (schemeField.type == org.apache.thrift.protocol.TType.STOP) { 
            break;
          }
          switch (schemeField.id) {
            case 1: // USER_TOKEN
              if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
                struct.userToken = iprot.readString();
                struct.setUserTokenIsSet(true);
              } else { 
                org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
              }
              break;
            case 2: // IMAGE_BASE_ID
              if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
                struct.imageBaseId = iprot.readString();
                struct.setImageBaseIdIsSet(true);
              } else { 
                org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
              }
              break;
            default:
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
          }
          iprot.readFieldEnd();
        }
        iprot.readStructEnd();

        // check for required fields of primitive type, which can't be checked in the validate method
        struct.validate();
      }

      public void write(org.apache.thrift.protocol.TProtocol oprot, getImageDetails_args struct) throws org.apache.thrift.TException {
        struct.validate();

        oprot.writeStructBegin(STRUCT_DESC);
        if (struct.userToken != null) {
          oprot.writeFieldBegin(USER_TOKEN_FIELD_DESC);
          oprot.writeString(struct.userToken);
          oprot.writeFieldEnd();
        }
        if (struct.imageBaseId != null) {
          oprot.writeFieldBegin(IMAGE_BASE_ID_FIELD_DESC);
          oprot.writeString(struct.imageBaseId);
          oprot.writeFieldEnd();
        }
        oprot.writeFieldStop();
        oprot.writeStructEnd();
      }

    }

    private static class getImageDetails_argsTupleSchemeFactory implements SchemeFactory {
      public getImageDetails_argsTupleScheme getScheme() {
        return new getImageDetails_argsTupleScheme();
      }
    }

    private static class getImageDetails_argsTupleScheme extends TupleScheme<getImageDetails_args> {

      @Override
      public void write(org.apache.thrift.protocol.TProtocol prot, getImageDetails_args struct) throws org.apache.thrift.TException {
        TTupleProtocol oprot = (TTupleProtocol) prot;
        BitSet optionals = new BitSet();
        if (struct.isSetUserToken()) {
          optionals.set(0);
        }
        if (struct.isSetImageBaseId()) {
          optionals.set(1);
        }
        oprot.writeBitSet(optionals, 2);
        if (struct.isSetUserToken()) {
          oprot.writeString(struct.userToken);
        }
        if (struct.isSetImageBaseId()) {
          oprot.writeString(struct.imageBaseId);
        }
      }

      @Override
      public void read(org.apache.thrift.protocol.TProtocol prot, getImageDetails_args struct) throws org.apache.thrift.TException {
        TTupleProtocol iprot = (TTupleProtocol) prot;
        BitSet incoming = iprot.readBitSet(2);
        if (incoming.get(0)) {
          struct.userToken = iprot.readString();
          struct.setUserTokenIsSet(true);
        }
        if (incoming.get(1)) {
          struct.imageBaseId = iprot.readString();
          struct.setImageBaseIdIsSet(true);
        }
      }
    }

  }

  public static class getImageDetails_result implements org.apache.thrift.TBase<getImageDetails_result, getImageDetails_result._Fields>, java.io.Serializable, Cloneable, Comparable<getImageDetails_result>   {
    private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getImageDetails_result");

    private static final org.apache.thrift.protocol.TField SUCCESS_FIELD_DESC = new org.apache.thrift.protocol.TField("success", org.apache.thrift.protocol.TType.STRUCT, (short)0);
    private static final org.apache.thrift.protocol.TField AUTH_ERROR_FIELD_DESC = new org.apache.thrift.protocol.TField("authError", org.apache.thrift.protocol.TType.STRUCT, (short)1);
    private static final org.apache.thrift.protocol.TField NOT_FOUND_FIELD_DESC = new org.apache.thrift.protocol.TField("notFound", org.apache.thrift.protocol.TType.STRUCT, (short)2);
    private static final org.apache.thrift.protocol.TField SERVER_ERROR_FIELD_DESC = new org.apache.thrift.protocol.TField("serverError", org.apache.thrift.protocol.TType.STRUCT, (short)3);

    private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
    static {
      schemes.put(StandardScheme.class, new getImageDetails_resultStandardSchemeFactory());
      schemes.put(TupleScheme.class, new getImageDetails_resultTupleSchemeFactory());
    }

    public ImageDetailsRead success; // required
    public TAuthorizationException authError; // required
    public TNotFoundException notFound; // required
    public TInternalServerError serverError; // required

    /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
    public enum _Fields implements org.apache.thrift.TFieldIdEnum {
      SUCCESS((short)0, "success"),
      AUTH_ERROR((short)1, "authError"),
      NOT_FOUND((short)2, "notFound"),
      SERVER_ERROR((short)3, "serverError");

      private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();

      static {
        for (_Fields field : EnumSet.allOf(_Fields.class)) {
          byName.put(field.getFieldName(), field);
        }
      }

      /**
       * Find the _Fields constant that matches fieldId, or null if its not found.
       */
      public static _Fields findByThriftId(int fieldId) {
        switch(fieldId) {
          case 0: // SUCCESS
            return SUCCESS;
          case 1: // AUTH_ERROR
            return AUTH_ERROR;
          case 2: // NOT_FOUND
            return NOT_FOUND;
          case 3: // SERVER_ERROR
            return SERVER_ERROR;
          default:
            return null;
        }
      }

      /**
       * Find the _Fields constant that matches fieldId, throwing an exception
       * if it is not found.
       */
      public static _Fields findByThriftIdOrThrow(int fieldId) {
        _Fields fields = findByThriftId(fieldId);
        if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
        return fields;
      }

      /**
       * Find the _Fields constant that matches name, or null if its not found.
       */
      public static _Fields findByName(String name) {
        return byName.get(name);
      }

      private final short _thriftId;
      private final String _fieldName;

      _Fields(short thriftId, String fieldName) {
        _thriftId = thriftId;
        _fieldName = fieldName;
      }

      public short getThriftFieldId() {
        return _thriftId;
      }

      public String getFieldName() {
        return _fieldName;
      }
    }

    // isset id assignments
    public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
    static {
      Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
      tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, 
          new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, ImageDetailsRead.class)));
      tmpMap.put(_Fields.AUTH_ERROR, new org.apache.thrift.meta_data.FieldMetaData("authError", org.apache.thrift.TFieldRequirementType.DEFAULT, 
          new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT)));
      tmpMap.put(_Fields.NOT_FOUND, new org.apache.thrift.meta_data.FieldMetaData("notFound", org.apache.thrift.TFieldRequirementType.DEFAULT, 
          new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT)));
      tmpMap.put(_Fields.SERVER_ERROR, new org.apache.thrift.meta_data.FieldMetaData("serverError", org.apache.thrift.TFieldRequirementType.DEFAULT, 
          new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT)));
      metaDataMap = Collections.unmodifiableMap(tmpMap);
      org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getImageDetails_result.class, metaDataMap);
    }

    public getImageDetails_result() {
    }

    public getImageDetails_result(
      ImageDetailsRead success,
      TAuthorizationException authError,
      TNotFoundException notFound,
      TInternalServerError serverError)
    {
      this();
      this.success = success;
      this.authError = authError;
      this.notFound = notFound;
      this.serverError = serverError;
    }

    /**
     * Performs a deep copy on <i>other</i>.
     */
    public getImageDetails_result(getImageDetails_result other) {
      if (other.isSetSuccess()) {
        this.success = new ImageDetailsRead(other.success);
      }
      if (other.isSetAuthError()) {
        this.authError = new TAuthorizationException(other.authError);
      }
      if (other.isSetNotFound()) {
        this.notFound = new TNotFoundException(other.notFound);
      }
      if (other.isSetServerError()) {
        this.serverError = new TInternalServerError(other.serverError);
      }
    }

    public getImageDetails_result deepCopy() {
      return new getImageDetails_result(this);
    }

    @Override
    public void clear() {
      this.success = null;
      this.authError = null;
      this.notFound = null;
      this.serverError = null;
    }

    public ImageDetailsRead getSuccess() {
      return this.success;
    }

    public getImageDetails_result setSuccess(ImageDetailsRead success) {
      this.success = success;
      return this;
    }

    public void unsetSuccess() {
      this.success = null;
    }

    /** Returns true if field success is set (has been assigned a value) and false otherwise */
    public boolean isSetSuccess() {
      return this.success != null;
    }

    public void setSuccessIsSet(boolean value) {
      if (!value) {
        this.success = null;
      }
    }

    public TAuthorizationException getAuthError() {
      return this.authError;
    }

    public getImageDetails_result setAuthError(TAuthorizationException authError) {
      this.authError = authError;
      return this;
    }

    public void unsetAuthError() {
      this.authError = null;
    }

    /** Returns true if field authError is set (has been assigned a value) and false otherwise */
    public boolean isSetAuthError() {
      return this.authError != null;
    }

    public void setAuthErrorIsSet(boolean value) {
      if (!value) {
        this.authError = null;
      }
    }

    public TNotFoundException getNotFound() {
      return this.notFound;
    }

    public getImageDetails_result setNotFound(TNotFoundException notFound) {
      this.notFound = notFound;
      return this;
    }

    public void unsetNotFound() {
      this.notFound = null;
    }

    /** Returns true if field notFound is set (has been assigned a value) and false otherwise */
    public boolean isSetNotFound() {
      return this.notFound != null;
    }

    public void setNotFoundIsSet(boolean value) {
      if (!value) {
        this.notFound = null;
      }
    }

    public TInternalServerError getServerError() {
      return this.serverError;
    }

    public getImageDetails_result setServerError(TInternalServerError serverError) {
      this.serverError = serverError;
      return this;
    }

    public void unsetServerError() {
      this.serverError = null;
    }

    /** Returns true if field serverError is set (has been assigned a value) and false otherwise */
    public boolean isSetServerError() {
      return this.serverError != null;
    }

    public void setServerErrorIsSet(boolean value) {
      if (!value) {
        this.serverError = null;
      }
    }

    public void setFieldValue(_Fields field, Object value) {
      switch (field) {
      case SUCCESS:
        if (value == null) {
          unsetSuccess();
        } else {
          setSuccess((ImageDetailsRead)value);
        }
        break;

      case AUTH_ERROR:
        if (value == null) {
          unsetAuthError();
        } else {
          setAuthError((TAuthorizationException)value);
        }
        break;

      case NOT_FOUND:
        if (value == null) {
          unsetNotFound();
        } else {
          setNotFound((TNotFoundException)value);
        }
        break;

      case SERVER_ERROR:
        if (value == null) {
          unsetServerError();
        } else {
          setServerError((TInternalServerError)value);
        }
        break;

      }
    }

    public Object getFieldValue(_Fields field) {
      switch (field) {
      case SUCCESS:
        return getSuccess();

      case AUTH_ERROR:
        return getAuthError();

      case NOT_FOUND:
        return getNotFound();

      case SERVER_ERROR:
        return getServerError();

      }
      throw new IllegalStateException();
    }

    /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
    public boolean isSet(_Fields field) {
      if (field == null) {
        throw new IllegalArgumentException();
      }

      switch (field) {
      case SUCCESS:
        return isSetSuccess();
      case AUTH_ERROR:
        return isSetAuthError();
      case NOT_FOUND:
        return isSetNotFound();
      case SERVER_ERROR:
        return isSetServerError();
      }
      throw new IllegalStateException();
    }

    @Override
    public boolean equals(Object that) {
      if (that == null)
        return false;
      if (that instanceof getImageDetails_result)
        return this.equals((getImageDetails_result)that);
      return false;
    }

    public boolean equals(getImageDetails_result that) {
      if (that == null)
        return false;

      boolean this_present_success = true && this.isSetSuccess();
      boolean that_present_success = true && that.isSetSuccess();
      if (this_present_success || that_present_success) {
        if (!(this_present_success && that_present_success))
          return false;
        if (!this.success.equals(that.success))
          return false;
      }

      boolean this_present_authError = true && this.isSetAuthError();
      boolean that_present_authError = true && that.isSetAuthError();
      if (this_present_authError || that_present_authError) {
        if (!(this_present_authError && that_present_authError))
          return false;
        if (!this.authError.equals(that.authError))
          return false;
      }

      boolean this_present_notFound = true && this.isSetNotFound();
      boolean that_present_notFound = true && that.isSetNotFound();
      if (this_present_notFound || that_present_notFound) {
        if (!(this_present_notFound && that_present_notFound))
          return false;
        if (!this.notFound.equals(that.notFound))
          return false;
      }

      boolean this_present_serverError = true && this.isSetServerError();
      boolean that_present_serverError = true && that.isSetServerError();
      if (this_present_serverError || that_present_serverError) {
        if (!(this_present_serverError && that_present_serverError))
          return false;
        if (!this.serverError.equals(that.serverError))
          return false;
      }

      return true;
    }

    @Override
    public int hashCode() {
      return 0;
    }

    @Override
    public int compareTo(getImageDetails_result other) {
      if (!getClass().equals(other.getClass())) {
        return getClass().getName().compareTo(other.getClass().getName());
      }

      int lastComparison = 0;

      lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(other.isSetSuccess());
      if (lastComparison != 0) {
        return lastComparison;
      }
      if (isSetSuccess()) {
        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, other.success);
        if (lastComparison != 0) {
          return lastComparison;
        }
      }
      lastComparison = Boolean.valueOf(isSetAuthError()).compareTo(other.isSetAuthError());
      if (lastComparison != 0) {
        return lastComparison;
      }
      if (isSetAuthError()) {
        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.authError, other.authError);
        if (lastComparison != 0) {
          return lastComparison;
        }
      }
      lastComparison = Boolean.valueOf(isSetNotFound()).compareTo(other.isSetNotFound());
      if (lastComparison != 0) {
        return lastComparison;
      }
      if (isSetNotFound()) {
        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.notFound, other.notFound);
        if (lastComparison != 0) {
          return lastComparison;
        }
      }
      lastComparison = Boolean.valueOf(isSetServerError()).compareTo(other.isSetServerError());
      if (lastComparison != 0) {
        return lastComparison;
      }
      if (isSetServerError()) {
        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.serverError, other.serverError);
        if (lastComparison != 0) {
          return lastComparison;
        }
      }
      return 0;
    }

    public _Fields fieldForId(int fieldId) {
      return _Fields.findByThriftId(fieldId);
    }

    public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
      schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
    }

    public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
      schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
      }

    @Override
    public String toString() {
      StringBuilder sb = new StringBuilder("getImageDetails_result(");
      boolean first = true;

      sb.append("success:");
      if (this.success == null) {
        sb.append("null");
      } else {
        sb.append(this.success);
      }
      first = false;
      if (!first) sb.append(", ");
      sb.append("authError:");
      if (this.authError == null) {
        sb.append("null");
      } else {
        sb.append(this.authError);
      }
      first = false;
      if (!first) sb.append(", ");
      sb.append("notFound:");
      if (this.notFound == null) {
        sb.append("null");
      } else {
        sb.append(this.notFound);
      }
      first = false;
      if (!first) sb.append(", ");
      sb.append("serverError:");
      if (this.serverError == null) {
        sb.append("null");
      } else {
        sb.append(this.serverError);
      }
      first = false;
      sb.append(")");
      return sb.toString();
    }

    public void validate() throws org.apache.thrift.TException {
      // check for required fields
      // check for sub-struct validity
      if (success != null) {
        success.validate();
      }
    }

    private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
      try {
        write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
      } catch (org.apache.thrift.TException te) {
        throw new java.io.IOException(te);
      }
    }

    private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
      try {
        read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
      } catch (org.apache.thrift.TException te) {
        throw new java.io.IOException(te);
      }
    }

    private static class getImageDetails_resultStandardSchemeFactory implements SchemeFactory {
      public getImageDetails_resultStandardScheme getScheme() {
        return new getImageDetails_resultStandardScheme();
      }
    }

    private static class getImageDetails_resultStandardScheme extends StandardScheme<getImageDetails_result> {

      public void read(org.apache.thrift.protocol.TProtocol iprot, getImageDetails_result struct) throws org.apache.thrift.TException {
        org.apache.thrift.protocol.TField schemeField;
        iprot.readStructBegin();
        while (true)
        {
          schemeField = iprot.readFieldBegin();
          if (schemeField.type == org.apache.thrift.protocol.TType.STOP) { 
            break;
          }
          switch (schemeField.id) {
            case 0: // SUCCESS
              if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
                struct.success = new ImageDetailsRead();
                struct.success.read(iprot);
                struct.setSuccessIsSet(true);
              } else { 
                org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
              }
              break;
            case 1: // AUTH_ERROR
              if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
                struct.authError = new TAuthorizationException();
                struct.authError.read(iprot);
                struct.setAuthErrorIsSet(true);
              } else { 
                org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
              }
              break;
            case 2: // NOT_FOUND
              if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
                struct.notFound = new TNotFoundException();
                struct.notFound.read(iprot);
                struct.setNotFoundIsSet(true);
              } else { 
                org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
              }
              break;
            case 3: // SERVER_ERROR
              if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
                struct.serverError = new TInternalServerError();
                struct.serverError.read(iprot);
                struct.setServerErrorIsSet(true);
              } else { 
                org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
              }
              break;
            default:
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
          }
          iprot.readFieldEnd();
        }
        iprot.readStructEnd();

        // check for required fields of primitive type, which can't be checked in the validate method
        struct.validate();
      }

      public void write(org.apache.thrift.protocol.TProtocol oprot, getImageDetails_result struct) throws org.apache.thrift.TException {
        struct.validate();

        oprot.writeStructBegin(STRUCT_DESC);
        if (struct.success != null) {
          oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
          struct.success.write(oprot);
          oprot.writeFieldEnd();
        }
        if (struct.authError != null) {
          oprot.writeFieldBegin(AUTH_ERROR_FIELD_DESC);
          struct.authError.write(oprot);
          oprot.writeFieldEnd();
        }
        if (struct.notFound != null) {
          oprot.writeFieldBegin(NOT_FOUND_FIELD_DESC);
          struct.notFound.write(oprot);
          oprot.writeFieldEnd();
        }
        if (struct.serverError != null) {
          oprot.writeFieldBegin(SERVER_ERROR_FIELD_DESC);
          struct.serverError.write(oprot);
          oprot.writeFieldEnd();
        }
        oprot.writeFieldStop();
        oprot.writeStructEnd();
      }

    }

    private static class getImageDetails_resultTupleSchemeFactory implements SchemeFactory {
      public getImageDetails_resultTupleScheme getScheme() {
        return new getImageDetails_resultTupleScheme();
      }
    }

    private static class getImageDetails_resultTupleScheme extends TupleScheme<getImageDetails_result> {

      @Override
      public void write(org.apache.thrift.protocol.TProtocol prot, getImageDetails_result struct) throws org.apache.thrift.TException {
        TTupleProtocol oprot = (TTupleProtocol) prot;
        BitSet optionals = new BitSet();
        if (struct.isSetSuccess()) {
          optionals.set(0);
        }
        if (struct.isSetAuthError()) {
          optionals.set(1);
        }
        if (struct.isSetNotFound()) {
          optionals.set(2);
        }
        if (struct.isSetServerError()) {
          optionals.set(3);
        }
        oprot.writeBitSet(optionals, 4);
        if (struct.isSetSuccess()) {
          struct.success.write(oprot);
        }
        if (struct.isSetAuthError()) {
          struct.authError.write(oprot);
        }
        if (struct.isSetNotFound()) {
          struct.notFound.write(oprot);
        }
        if (struct.isSetServerError()) {
          struct.serverError.write(oprot);
        }
      }

      @Override
      public void read(org.apache.thrift.protocol.TProtocol prot, getImageDetails_result struct) throws org.apache.thrift.TException {
        TTupleProtocol iprot = (TTupleProtocol) prot;
        BitSet incoming = iprot.readBitSet(4);
        if (incoming.get(0)) {
          struct.success = new ImageDetailsRead();
          struct.success.read(iprot);
          struct.setSuccessIsSet(true);
        }
        if (incoming.get(1)) {
          struct.authError = new TAuthorizationException();
          struct.authError.read(iprot);
          struct.setAuthErrorIsSet(true);
        }
        if (incoming.get(2)) {
          struct.notFound = new TNotFoundException();
          struct.notFound.read(iprot);
          struct.setNotFoundIsSet(true);
        }
        if (incoming.get(3)) {
          struct.serverError = new TInternalServerError();
          struct.serverError.read(iprot);
          struct.setServerErrorIsSet(true);
        }
      }
    }

  }

  public static class createImage_args implements org.apache.thrift.TBase<createImage_args, createImage_args._Fields>, java.io.Serializable, Cloneable, Comparable<createImage_args>   {
    private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("createImage_args");

    private static final org.apache.thrift.protocol.TField USER_TOKEN_FIELD_DESC = new org.apache.thrift.protocol.TField("userToken", org.apache.thrift.protocol.TType.STRING, (short)1);
    private static final org.apache.thrift.protocol.TField IMAGE_NAME_FIELD_DESC = new org.apache.thrift.protocol.TField("imageName", org.apache.thrift.protocol.TType.STRING, (short)2);

    private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
    static {
      schemes.put(StandardScheme.class, new createImage_argsStandardSchemeFactory());
      schemes.put(TupleScheme.class, new createImage_argsTupleSchemeFactory());
    }

    public String userToken; // required
    public String imageName; // required

    /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
    public enum _Fields implements org.apache.thrift.TFieldIdEnum {
      USER_TOKEN((short)1, "userToken"),
      IMAGE_NAME((short)2, "imageName");

      private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();

      static {
        for (_Fields field : EnumSet.allOf(_Fields.class)) {
          byName.put(field.getFieldName(), field);
        }
      }

      /**
       * Find the _Fields constant that matches fieldId, or null if its not found.
       */
      public static _Fields findByThriftId(int fieldId) {
        switch(fieldId) {
          case 1: // USER_TOKEN
            return USER_TOKEN;
          case 2: // IMAGE_NAME
            return IMAGE_NAME;
          default:
            return null;
        }
      }

      /**
       * Find the _Fields constant that matches fieldId, throwing an exception
       * if it is not found.
       */
      public static _Fields findByThriftIdOrThrow(int fieldId) {
        _Fields fields = findByThriftId(fieldId);
        if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
        return fields;
      }

      /**
       * Find the _Fields constant that matches name, or null if its not found.
       */
      public static _Fields findByName(String name) {
        return byName.get(name);
      }

      private final short _thriftId;
      private final String _fieldName;

      _Fields(short thriftId, String fieldName) {
        _thriftId = thriftId;
        _fieldName = fieldName;
      }

      public short getThriftFieldId() {
        return _thriftId;
      }

      public String getFieldName() {
        return _fieldName;
      }
    }

    // isset id assignments
    public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
    static {
      Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
      tmpMap.put(_Fields.USER_TOKEN, new org.apache.thrift.meta_data.FieldMetaData("userToken", org.apache.thrift.TFieldRequirementType.DEFAULT, 
          new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING          , "Token")));
      tmpMap.put(_Fields.IMAGE_NAME, new org.apache.thrift.meta_data.FieldMetaData("imageName", org.apache.thrift.TFieldRequirementType.DEFAULT, 
          new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING)));
      metaDataMap = Collections.unmodifiableMap(tmpMap);
      org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(createImage_args.class, metaDataMap);
    }

    public createImage_args() {
    }

    public createImage_args(
      String userToken,
      String imageName)
    {
      this();
      this.userToken = userToken;
      this.imageName = imageName;
    }

    /**
     * Performs a deep copy on <i>other</i>.
     */
    public createImage_args(createImage_args other) {
      if (other.isSetUserToken()) {
        this.userToken = other.userToken;
      }
      if (other.isSetImageName()) {
        this.imageName = other.imageName;
      }
    }

    public createImage_args deepCopy() {
      return new createImage_args(this);
    }

    @Override
    public void clear() {
      this.userToken = null;
      this.imageName = null;
    }

    public String getUserToken() {
      return this.userToken;
    }

    public createImage_args setUserToken(String userToken) {
      this.userToken = userToken;
      return this;
    }

    public void unsetUserToken() {
      this.userToken = null;
    }

    /** Returns true if field userToken is set (has been assigned a value) and false otherwise */
    public boolean isSetUserToken() {
      return this.userToken != null;
    }

    public void setUserTokenIsSet(boolean value) {
      if (!value) {
        this.userToken = null;
      }
    }

    public String getImageName() {
      return this.imageName;
    }

    public createImage_args setImageName(String imageName) {
      this.imageName = imageName;
      return this;
    }

    public void unsetImageName() {
      this.imageName = null;
    }

    /** Returns true if field imageName is set (has been assigned a value) and false otherwise */
    public boolean isSetImageName() {
      return this.imageName != null;
    }

    public void setImageNameIsSet(boolean value) {
      if (!value) {
        this.imageName = null;
      }
    }

    public void setFieldValue(_Fields field, Object value) {
      switch (field) {
      case USER_TOKEN:
        if (value == null) {
          unsetUserToken();
        } else {
          setUserToken((String)value);
        }
        break;

      case IMAGE_NAME:
        if (value == null) {
          unsetImageName();
        } else {
          setImageName((String)value);
        }
        break;

      }
    }

    public Object getFieldValue(_Fields field) {
      switch (field) {
      case USER_TOKEN:
        return getUserToken();

      case IMAGE_NAME:
        return getImageName();

      }
      throw new IllegalStateException();
    }

    /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
    public boolean isSet(_Fields field) {
      if (field == null) {
        throw new IllegalArgumentException();
      }

      switch (field) {
      case USER_TOKEN:
        return isSetUserToken();
      case IMAGE_NAME:
        return isSetImageName();
      }
      throw new IllegalStateException();
    }

    @Override
    public boolean equals(Object that) {
      if (that == null)
        return false;
      if (that instanceof createImage_args)
        return this.equals((createImage_args)that);
      return false;
    }

    public boolean equals(createImage_args that) {
      if (that == null)
        return false;

      boolean this_present_userToken = true && this.isSetUserToken();
      boolean that_present_userToken = true && that.isSetUserToken();
      if (this_present_userToken || that_present_userToken) {
        if (!(this_present_userToken && that_present_userToken))
          return false;
        if (!this.userToken.equals(that.userToken))
          return false;
      }

      boolean this_present_imageName = true && this.isSetImageName();
      boolean that_present_imageName = true && that.isSetImageName();
      if (this_present_imageName || that_present_imageName) {
        if (!(this_present_imageName && that_present_imageName))
          return false;
        if (!this.imageName.equals(that.imageName))
          return false;
      }

      return true;
    }

    @Override
    public int hashCode() {
      return 0;
    }

    @Override
    public int compareTo(createImage_args other) {
      if (!getClass().equals(other.getClass())) {
        return getClass().getName().compareTo(other.getClass().getName());
      }

      int lastComparison = 0;

      lastComparison = Boolean.valueOf(isSetUserToken()).compareTo(other.isSetUserToken());
      if (lastComparison != 0) {
        return lastComparison;
      }
      if (isSetUserToken()) {
        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.userToken, other.userToken);
        if (lastComparison != 0) {
          return lastComparison;
        }
      }
      lastComparison = Boolean.valueOf(isSetImageName()).compareTo(other.isSetImageName());
      if (lastComparison != 0) {
        return lastComparison;
      }
      if (isSetImageName()) {
        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.imageName, other.imageName);
        if (lastComparison != 0) {
          return lastComparison;
        }
      }
      return 0;
    }

    public _Fields fieldForId(int fieldId) {
      return _Fields.findByThriftId(fieldId);
    }

    public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
      schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
    }

    public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
      schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
    }

    @Override
    public String toString() {
      StringBuilder sb = new StringBuilder("createImage_args(");
      boolean first = true;

      sb.append("userToken:");
      if (this.userToken == null) {
        sb.append("null");
      } else {
        sb.append(this.userToken);
      }
      first = false;
      if (!first) sb.append(", ");
      sb.append("imageName:");
      if (this.imageName == null) {
        sb.append("null");
      } else {
        sb.append(this.imageName);
      }
      first = false;
      sb.append(")");
      return sb.toString();
    }

    public void validate() throws org.apache.thrift.TException {
      // check for required fields
      // check for sub-struct validity
    }

    private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
      try {
        write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
      } catch (org.apache.thrift.TException te) {
        throw new java.io.IOException(te);
      }
    }

    private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
      try {
        read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
      } catch (org.apache.thrift.TException te) {
        throw new java.io.IOException(te);
      }
    }

    private static class createImage_argsStandardSchemeFactory implements SchemeFactory {
      public createImage_argsStandardScheme getScheme() {
        return new createImage_argsStandardScheme();
      }
    }

    private static class createImage_argsStandardScheme extends StandardScheme<createImage_args> {

      public void read(org.apache.thrift.protocol.TProtocol iprot, createImage_args struct) throws org.apache.thrift.TException {
        org.apache.thrift.protocol.TField schemeField;
        iprot.readStructBegin();
        while (true)
        {
          schemeField = iprot.readFieldBegin();
          if (schemeField.type == org.apache.thrift.protocol.TType.STOP) { 
            break;
          }
          switch (schemeField.id) {
            case 1: // USER_TOKEN
              if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
                struct.userToken = iprot.readString();
                struct.setUserTokenIsSet(true);
              } else { 
                org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
              }
              break;
            case 2: // IMAGE_NAME
              if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
                struct.imageName = iprot.readString();
                struct.setImageNameIsSet(true);
              } else { 
                org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
              }
              break;
            default:
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
          }
          iprot.readFieldEnd();
        }
        iprot.readStructEnd();

        // check for required fields of primitive type, which can't be checked in the validate method
        struct.validate();
      }

      public void write(org.apache.thrift.protocol.TProtocol oprot, createImage_args struct) throws org.apache.thrift.TException {
        struct.validate();

        oprot.writeStructBegin(STRUCT_DESC);
        if (struct.userToken != null) {
          oprot.writeFieldBegin(USER_TOKEN_FIELD_DESC);
          oprot.writeString(struct.userToken);
          oprot.writeFieldEnd();
        }
        if (struct.imageName != null) {
          oprot.writeFieldBegin(IMAGE_NAME_FIELD_DESC);
          oprot.writeString(struct.imageName);
          oprot.writeFieldEnd();
        }
        oprot.writeFieldStop();
        oprot.writeStructEnd();
      }

    }

    private static class createImage_argsTupleSchemeFactory implements SchemeFactory {
      public createImage_argsTupleScheme getScheme() {
        return new createImage_argsTupleScheme();
      }
    }

    private static class createImage_argsTupleScheme extends TupleScheme<createImage_args> {

      @Override
      public void write(org.apache.thrift.protocol.TProtocol prot, createImage_args struct) throws org.apache.thrift.TException {
        TTupleProtocol oprot = (TTupleProtocol) prot;
        BitSet optionals = new BitSet();
        if (struct.isSetUserToken()) {
          optionals.set(0);
        }
        if (struct.isSetImageName()) {
          optionals.set(1);
        }
        oprot.writeBitSet(optionals, 2);
        if (struct.isSetUserToken()) {
          oprot.writeString(struct.userToken);
        }
        if (struct.isSetImageName()) {
          oprot.writeString(struct.imageName);
        }
      }

      @Override
      public void read(org.apache.thrift.protocol.TProtocol prot, createImage_args struct) throws org.apache.thrift.TException {
        TTupleProtocol iprot = (TTupleProtocol) prot;
        BitSet incoming = iprot.readBitSet(2);
        if (incoming.get(0)) {
          struct.userToken = iprot.readString();
          struct.setUserTokenIsSet(true);
        }
        if (incoming.get(1)) {
          struct.imageName = iprot.readString();
          struct.setImageNameIsSet(true);
        }
      }
    }

  }

  public static class createImage_result implements org.apache.thrift.TBase<createImage_result, createImage_result._Fields>, java.io.Serializable, Cloneable, Comparable<createImage_result>   {
    private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("createImage_result");

    private static final org.apache.thrift.protocol.TField SUCCESS_FIELD_DESC = new org.apache.thrift.protocol.TField("success", org.apache.thrift.protocol.TType.STRING, (short)0);
    private static final org.apache.thrift.protocol.TField AUTH_ERROR_FIELD_DESC = new org.apache.thrift.protocol.TField("authError", org.apache.thrift.protocol.TType.STRUCT, (short)1);
    private static final org.apache.thrift.protocol.TField IMG_ERROR_FIELD_DESC = new org.apache.thrift.protocol.TField("imgError", org.apache.thrift.protocol.TType.STRUCT, (short)2);
    private static final org.apache.thrift.protocol.TField SERVER_ERROR_FIELD_DESC = new org.apache.thrift.protocol.TField("serverError", org.apache.thrift.protocol.TType.STRUCT, (short)3);

    private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
    static {
      schemes.put(StandardScheme.class, new createImage_resultStandardSchemeFactory());
      schemes.put(TupleScheme.class, new createImage_resultTupleSchemeFactory());
    }

    public String success; // required
    public TAuthorizationException authError; // required
    public TImageDataException imgError; // required
    public TInternalServerError serverError; // required

    /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
    public enum _Fields implements org.apache.thrift.TFieldIdEnum {
      SUCCESS((short)0, "success"),
      AUTH_ERROR((short)1, "authError"),
      IMG_ERROR((short)2, "imgError"),
      SERVER_ERROR((short)3, "serverError");

      private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();

      static {
        for (_Fields field : EnumSet.allOf(_Fields.class)) {
          byName.put(field.getFieldName(), field);
        }
      }

      /**
       * Find the _Fields constant that matches fieldId, or null if its not found.
       */
      public static _Fields findByThriftId(int fieldId) {
        switch(fieldId) {
          case 0: // SUCCESS
            return SUCCESS;
          case 1: // AUTH_ERROR
            return AUTH_ERROR;
          case 2: // IMG_ERROR
            return IMG_ERROR;
          case 3: // SERVER_ERROR
            return SERVER_ERROR;
          default:
            return null;
        }
      }

      /**
       * Find the _Fields constant that matches fieldId, throwing an exception
       * if it is not found.
       */
      public static _Fields findByThriftIdOrThrow(int fieldId) {
        _Fields fields = findByThriftId(fieldId);
        if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
        return fields;
      }

      /**
       * Find the _Fields constant that matches name, or null if its not found.
       */
      public static _Fields findByName(String name) {
        return byName.get(name);
      }

      private final short _thriftId;
      private final String _fieldName;

      _Fields(short thriftId, String fieldName) {
        _thriftId = thriftId;
        _fieldName = fieldName;
      }

      public short getThriftFieldId() {
        return _thriftId;
      }

      public String getFieldName() {
        return _fieldName;
      }
    }

    // isset id assignments
    public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
    static {
      Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
      tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, 
          new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING          , "UUID")));
      tmpMap.put(_Fields.AUTH_ERROR, new org.apache.thrift.meta_data.FieldMetaData("authError", org.apache.thrift.TFieldRequirementType.DEFAULT, 
          new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT)));
      tmpMap.put(_Fields.IMG_ERROR, new org.apache.thrift.meta_data.FieldMetaData("imgError", org.apache.thrift.TFieldRequirementType.DEFAULT, 
          new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT)));
      tmpMap.put(_Fields.SERVER_ERROR, new org.apache.thrift.meta_data.FieldMetaData("serverError", org.apache.thrift.TFieldRequirementType.DEFAULT, 
          new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT)));
      metaDataMap = Collections.unmodifiableMap(tmpMap);
      org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(createImage_result.class, metaDataMap);
    }

    public createImage_result() {
    }

    public createImage_result(
      String success,
      TAuthorizationException authError,
      TImageDataException imgError,
      TInternalServerError serverError)
    {
      this();
      this.success = success;
      this.authError = authError;
      this.imgError = imgError;
      this.serverError = serverError;
    }

    /**
     * Performs a deep copy on <i>other</i>.
     */
    public createImage_result(createImage_result other) {
      if (other.isSetSuccess()) {
        this.success = other.success;
      }
      if (other.isSetAuthError()) {
        this.authError = new TAuthorizationException(other.authError);
      }
      if (other.isSetImgError()) {
        this.imgError = new TImageDataException(other.imgError);
      }
      if (other.isSetServerError()) {
        this.serverError = new TInternalServerError(other.serverError);
      }
    }

    public createImage_result deepCopy() {
      return new createImage_result(this);
    }

    @Override
    public void clear() {
      this.success = null;
      this.authError = null;
      this.imgError = null;
      this.serverError = null;
    }

    public String getSuccess() {
      return this.success;
    }

    public createImage_result setSuccess(String success) {
      this.success = success;
      return this;
    }

    public void unsetSuccess() {
      this.success = null;
    }

    /** Returns true if field success is set (has been assigned a value) and false otherwise */
    public boolean isSetSuccess() {
      return this.success != null;
    }

    public void setSuccessIsSet(boolean value) {
      if (!value) {
        this.success = null;
      }
    }

    public TAuthorizationException getAuthError() {
      return this.authError;
    }

    public createImage_result setAuthError(TAuthorizationException authError) {
      this.authError = authError;
      return this;
    }

    public void unsetAuthError() {
      this.authError = null;
    }

    /** Returns true if field authError is set (has been assigned a value) and false otherwise */
    public boolean isSetAuthError() {
      return this.authError != null;
    }

    public void setAuthErrorIsSet(boolean value) {
      if (!value) {
        this.authError = null;
      }
    }

    public TImageDataException getImgError() {
      return this.imgError;
    }

    public createImage_result setImgError(TImageDataException imgError) {
      this.imgError = imgError;
      return this;
    }

    public void unsetImgError() {
      this.imgError = null;
    }

    /** Returns true if field imgError is set (has been assigned a value) and false otherwise */
    public boolean isSetImgError() {
      return this.imgError != null;
    }

    public void setImgErrorIsSet(boolean value) {
      if (!value) {
        this.imgError = null;
      }
    }

    public TInternalServerError getServerError() {
      return this.serverError;
    }

    public createImage_result setServerError(TInternalServerError serverError) {
      this.serverError = serverError;
      return this;
    }

    public void unsetServerError() {
      this.serverError = null;
    }

    /** Returns true if field serverError is set (has been assigned a value) and false otherwise */
    public boolean isSetServerError() {
      return this.serverError != null;
    }

    public void setServerErrorIsSet(boolean value) {
      if (!value) {
        this.serverError = null;
      }
    }

    public void setFieldValue(_Fields field, Object value) {
      switch (field) {
      case SUCCESS:
        if (value == null) {
          unsetSuccess();
        } else {
          setSuccess((String)value);
        }
        break;

      case AUTH_ERROR:
        if (value == null) {
          unsetAuthError();
        } else {
          setAuthError((TAuthorizationException)value);
        }
        break;

      case IMG_ERROR:
        if (value == null) {
          unsetImgError();
        } else {
          setImgError((TImageDataException)value);
        }
        break;

      case SERVER_ERROR:
        if (value == null) {
          unsetServerError();
        } else {
          setServerError((TInternalServerError)value);
        }
        break;

      }
    }

    public Object getFieldValue(_Fields field) {
      switch (field) {
      case SUCCESS:
        return getSuccess();

      case AUTH_ERROR:
        return getAuthError();

      case IMG_ERROR:
        return getImgError();

      case SERVER_ERROR:
        return getServerError();

      }
      throw new IllegalStateException();
    }

    /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
    public boolean isSet(_Fields field) {
      if (field == null) {
        throw new IllegalArgumentException();
      }

      switch (field) {
      case SUCCESS:
        return isSetSuccess();
      case AUTH_ERROR:
        return isSetAuthError();
      case IMG_ERROR:
        return isSetImgError();
      case SERVER_ERROR:
        return isSetServerError();
      }
      throw new IllegalStateException();
    }

    @Override
    public boolean equals(Object that) {
      if (that == null)
        return false;
      if (that instanceof createImage_result)
        return this.equals((createImage_result)that);
      return false;
    }

    public boolean equals(createImage_result that) {
      if (that == null)
        return false;

      boolean this_present_success = true && this.isSetSuccess();
      boolean that_present_success = true && that.isSetSuccess();
      if (this_present_success || that_present_success) {
        if (!(this_present_success && that_present_success))
          return false;
        if (!this.success.equals(that.success))
          return false;
      }

      boolean this_present_authError = true && this.isSetAuthError();
      boolean that_present_authError = true && that.isSetAuthError();
      if (this_present_authError || that_present_authError) {
        if (!(this_present_authError && that_present_authError))
          return false;
        if (!this.authError.equals(that.authError))
          return false;
      }

      boolean this_present_imgError = true && this.isSetImgError();
      boolean that_present_imgError = true && that.isSetImgError();
      if (this_present_imgError || that_present_imgError) {
        if (!(this_present_imgError && that_present_imgError))
          return false;
        if (!this.imgError.equals(that.imgError))
          return false;
      }

      boolean this_present_serverError = true && this.isSetServerError();
      boolean that_present_serverError = true && that.isSetServerError();
      if (this_present_serverError || that_present_serverError) {
        if (!(this_present_serverError && that_present_serverError))
          return false;
        if (!this.serverError.equals(that.serverError))
          return false;
      }

      return true;
    }

    @Override
    public int hashCode() {
      return 0;
    }

    @Override
    public int compareTo(createImage_result other) {
      if (!getClass().equals(other.getClass())) {
        return getClass().getName().compareTo(other.getClass().getName());
      }

      int lastComparison = 0;

      lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(other.isSetSuccess());
      if (lastComparison != 0) {
        return lastComparison;
      }
      if (isSetSuccess()) {
        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, other.success);
        if (lastComparison != 0) {
          return lastComparison;
        }
      }
      lastComparison = Boolean.valueOf(isSetAuthError()).compareTo(other.isSetAuthError());
      if (lastComparison != 0) {
        return lastComparison;
      }
      if (isSetAuthError()) {
        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.authError, other.authError);
        if (lastComparison != 0) {
          return lastComparison;
        }
      }
      lastComparison = Boolean.valueOf(isSetImgError()).compareTo(other.isSetImgError());
      if (lastComparison != 0) {
        return lastComparison;
      }
      if (isSetImgError()) {
        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.imgError, other.imgError);
        if (lastComparison != 0) {
          return lastComparison;
        }
      }
      lastComparison = Boolean.valueOf(isSetServerError()).compareTo(other.isSetServerError());
      if (lastComparison != 0) {
        return lastComparison;
      }
      if (isSetServerError()) {
        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.serverError, other.serverError);
        if (lastComparison != 0) {
          return lastComparison;
        }
      }
      return 0;
    }

    public _Fields fieldForId(int fieldId) {
      return _Fields.findByThriftId(fieldId);
    }

    public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
      schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
    }

    public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
      schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
      }

    @Override
    public String toString() {
      StringBuilder sb = new StringBuilder("createImage_result(");
      boolean first = true;

      sb.append("success:");
      if (this.success == null) {
        sb.append("null");
      } else {
        sb.append(this.success);
      }
      first = false;
      if (!first) sb.append(", ");
      sb.append("authError:");
      if (this.authError == null) {
        sb.append("null");
      } else {
        sb.append(this.authError);
      }
      first = false;
      if (!first) sb.append(", ");
      sb.append("imgError:");
      if (this.imgError == null) {
        sb.append("null");
      } else {
        sb.append(this.imgError);
      }
      first = false;
      if (!first) sb.append(", ");
      sb.append("serverError:");
      if (this.serverError == null) {
        sb.append("null");
      } else {
        sb.append(this.serverError);
      }
      first = false;
      sb.append(")");
      return sb.toString();
    }

    public void validate() throws org.apache.thrift.TException {
      // check for required fields
      // check for sub-struct validity
    }

    private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
      try {
        write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
      } catch (org.apache.thrift.TException te) {
        throw new java.io.IOException(te);
      }
    }

    private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
      try {
        read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
      } catch (org.apache.thrift.TException te) {
        throw new java.io.IOException(te);
      }
    }

    private static class createImage_resultStandardSchemeFactory implements SchemeFactory {
      public createImage_resultStandardScheme getScheme() {
        return new createImage_resultStandardScheme();
      }
    }

    private static class createImage_resultStandardScheme extends StandardScheme<createImage_result> {

      public void read(org.apache.thrift.protocol.TProtocol iprot, createImage_result struct) throws org.apache.thrift.TException {
        org.apache.thrift.protocol.TField schemeField;
        iprot.readStructBegin();
        while (true)
        {
          schemeField = iprot.readFieldBegin();
          if (schemeField.type == org.apache.thrift.protocol.TType.STOP) { 
            break;
          }
          switch (schemeField.id) {
            case 0: // SUCCESS
              if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
                struct.success = iprot.readString();
                struct.setSuccessIsSet(true);
              } else { 
                org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
              }
              break;
            case 1: // AUTH_ERROR
              if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
                struct.authError = new TAuthorizationException();
                struct.authError.read(iprot);
                struct.setAuthErrorIsSet(true);
              } else { 
                org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
              }
              break;
            case 2: // IMG_ERROR
              if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
                struct.imgError = new TImageDataException();
                struct.imgError.read(iprot);
                struct.setImgErrorIsSet(true);
              } else { 
                org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
              }
              break;
            case 3: // SERVER_ERROR
              if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
                struct.serverError = new TInternalServerError();
                struct.serverError.read(iprot);
                struct.setServerErrorIsSet(true);
              } else { 
                org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
              }
              break;
            default:
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
          }
          iprot.readFieldEnd();
        }
        iprot.readStructEnd();

        // check for required fields of primitive type, which can't be checked in the validate method
        struct.validate();
      }

      public void write(org.apache.thrift.protocol.TProtocol oprot, createImage_result struct) throws org.apache.thrift.TException {
        struct.validate();

        oprot.writeStructBegin(STRUCT_DESC);
        if (struct.success != null) {
          oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
          oprot.writeString(struct.success);
          oprot.writeFieldEnd();
        }
        if (struct.authError != null) {
          oprot.writeFieldBegin(AUTH_ERROR_FIELD_DESC);
          struct.authError.write(oprot);
          oprot.writeFieldEnd();
        }
        if (struct.imgError != null) {
          oprot.writeFieldBegin(IMG_ERROR_FIELD_DESC);
          struct.imgError.write(oprot);
          oprot.writeFieldEnd();
        }
        if (struct.serverError != null) {
          oprot.writeFieldBegin(SERVER_ERROR_FIELD_DESC);
          struct.serverError.write(oprot);
          oprot.writeFieldEnd();
        }
        oprot.writeFieldStop();
        oprot.writeStructEnd();
      }

    }

    private static class createImage_resultTupleSchemeFactory implements SchemeFactory {
      public createImage_resultTupleScheme getScheme() {
        return new createImage_resultTupleScheme();
      }
    }

    private static class createImage_resultTupleScheme extends TupleScheme<createImage_result> {

      @Override
      public void write(org.apache.thrift.protocol.TProtocol prot, createImage_result struct) throws org.apache.thrift.TException {
        TTupleProtocol oprot = (TTupleProtocol) prot;
        BitSet optionals = new BitSet();
        if (struct.isSetSuccess()) {
          optionals.set(0);
        }
        if (struct.isSetAuthError()) {
          optionals.set(1);
        }
        if (struct.isSetImgError()) {
          optionals.set(2);
        }
        if (struct.isSetServerError()) {
          optionals.set(3);
        }
        oprot.writeBitSet(optionals, 4);
        if (struct.isSetSuccess()) {
          oprot.writeString(struct.success);
        }
        if (struct.isSetAuthError()) {
          struct.authError.write(oprot);
        }
        if (struct.isSetImgError()) {
          struct.imgError.write(oprot);
        }
        if (struct.isSetServerError()) {
          struct.serverError.write(oprot);
        }
      }

      @Override
      public void read(org.apache.thrift.protocol.TProtocol prot, createImage_result struct) throws org.apache.thrift.TException {
        TTupleProtocol iprot = (TTupleProtocol) prot;
        BitSet incoming = iprot.readBitSet(4);
        if (incoming.get(0)) {
          struct.success = iprot.readString();
          struct.setSuccessIsSet(true);
        }
        if (incoming.get(1)) {
          struct.authError = new TAuthorizationException();
          struct.authError.read(iprot);
          struct.setAuthErrorIsSet(true);
        }
        if (incoming.get(2)) {
          struct.imgError = new TImageDataException();
          struct.imgError.read(iprot);
          struct.setImgErrorIsSet(true);
        }
        if (incoming.get(3)) {
          struct.serverError = new TInternalServerError();
          struct.serverError.read(iprot);
          struct.setServerErrorIsSet(true);
        }
      }
    }

  }

  public static class updateImageBase_args implements org.apache.thrift.TBase<updateImageBase_args, updateImageBase_args._Fields>, java.io.Serializable, Cloneable, Comparable<updateImageBase_args>   {
    private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("updateImageBase_args");

    private static final org.apache.thrift.protocol.TField USER_TOKEN_FIELD_DESC = new org.apache.thrift.protocol.TField("userToken", org.apache.thrift.protocol.TType.STRING, (short)1);
    private static final org.apache.thrift.protocol.TField IMAGE_BASE_ID_FIELD_DESC = new org.apache.thrift.protocol.TField("imageBaseId", org.apache.thrift.protocol.TType.STRING, (short)2);
    private static final org.apache.thrift.protocol.TField IMAGE_FIELD_DESC = new org.apache.thrift.protocol.TField("image", org.apache.thrift.protocol.TType.STRUCT, (short)3);

    private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
    static {
      schemes.put(StandardScheme.class, new updateImageBase_argsStandardSchemeFactory());
      schemes.put(TupleScheme.class, new updateImageBase_argsTupleSchemeFactory());
    }

    public String userToken; // required
    public String imageBaseId; // required
    public ImageBaseWrite image; // required

    /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
    public enum _Fields implements org.apache.thrift.TFieldIdEnum {
      USER_TOKEN((short)1, "userToken"),
      IMAGE_BASE_ID((short)2, "imageBaseId"),
      IMAGE((short)3, "image");

      private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();

      static {
        for (_Fields field : EnumSet.allOf(_Fields.class)) {
          byName.put(field.getFieldName(), field);
        }
      }

      /**
       * Find the _Fields constant that matches fieldId, or null if its not found.
       */
      public static _Fields findByThriftId(int fieldId) {
        switch(fieldId) {
          case 1: // USER_TOKEN
            return USER_TOKEN;
          case 2: // IMAGE_BASE_ID
            return IMAGE_BASE_ID;
          case 3: // IMAGE
            return IMAGE;
          default:
            return null;
        }
      }

      /**
       * Find the _Fields constant that matches fieldId, throwing an exception
       * if it is not found.
       */
      public static _Fields findByThriftIdOrThrow(int fieldId) {
        _Fields fields = findByThriftId(fieldId);
        if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
        return fields;
      }

      /**
       * Find the _Fields constant that matches name, or null if its not found.
       */
      public static _Fields findByName(String name) {
        return byName.get(name);
      }

      private final short _thriftId;
      private final String _fieldName;

      _Fields(short thriftId, String fieldName) {
        _thriftId = thriftId;
        _fieldName = fieldName;
      }

      public short getThriftFieldId() {
        return _thriftId;
      }

      public String getFieldName() {
        return _fieldName;
      }
    }

    // isset id assignments
    public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
    static {
      Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
      tmpMap.put(_Fields.USER_TOKEN, new org.apache.thrift.meta_data.FieldMetaData("userToken", org.apache.thrift.TFieldRequirementType.DEFAULT, 
          new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING          , "Token")));
      tmpMap.put(_Fields.IMAGE_BASE_ID, new org.apache.thrift.meta_data.FieldMetaData("imageBaseId", org.apache.thrift.TFieldRequirementType.DEFAULT, 
          new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING          , "UUID")));
      tmpMap.put(_Fields.IMAGE, new org.apache.thrift.meta_data.FieldMetaData("image", org.apache.thrift.TFieldRequirementType.DEFAULT, 
          new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, ImageBaseWrite.class)));
      metaDataMap = Collections.unmodifiableMap(tmpMap);
      org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(updateImageBase_args.class, metaDataMap);
    }

    public updateImageBase_args() {
    }

    public updateImageBase_args(
      String userToken,
      String imageBaseId,
      ImageBaseWrite image)
    {
      this();
      this.userToken = userToken;
      this.imageBaseId = imageBaseId;
      this.image = image;
    }

    /**
     * Performs a deep copy on <i>other</i>.
     */
    public updateImageBase_args(updateImageBase_args other) {
      if (other.isSetUserToken()) {
        this.userToken = other.userToken;
      }
      if (other.isSetImageBaseId()) {
        this.imageBaseId = other.imageBaseId;
      }
      if (other.isSetImage()) {
        this.image = new ImageBaseWrite(other.image);
      }
    }

    public updateImageBase_args deepCopy() {
      return new updateImageBase_args(this);
    }

    @Override
    public void clear() {
      this.userToken = null;
      this.imageBaseId = null;
      this.image = null;
    }

    public String getUserToken() {
      return this.userToken;
    }

    public updateImageBase_args setUserToken(String userToken) {
      this.userToken = userToken;
      return this;
    }

    public void unsetUserToken() {
      this.userToken = null;
    }

    /** Returns true if field userToken is set (has been assigned a value) and false otherwise */
    public boolean isSetUserToken() {
      return this.userToken != null;
    }

    public void setUserTokenIsSet(boolean value) {
      if (!value) {
        this.userToken = null;
      }
    }

    public String getImageBaseId() {
      return this.imageBaseId;
    }

    public updateImageBase_args setImageBaseId(String imageBaseId) {
      this.imageBaseId = imageBaseId;
      return this;
    }

    public void unsetImageBaseId() {
      this.imageBaseId = null;
    }

    /** Returns true if field imageBaseId is set (has been assigned a value) and false otherwise */
    public boolean isSetImageBaseId() {
      return this.imageBaseId != null;
    }

    public void setImageBaseIdIsSet(boolean value) {
      if (!value) {
        this.imageBaseId = null;
      }
    }

    public ImageBaseWrite getImage() {
      return this.image;
    }

    public updateImageBase_args setImage(ImageBaseWrite image) {
      this.image = image;
      return this;
    }

    public void unsetImage() {
      this.image = null;
    }

    /** Returns true if field image is set (has been assigned a value) and false otherwise */
    public boolean isSetImage() {
      return this.image != null;
    }

    public void setImageIsSet(boolean value) {
      if (!value) {
        this.image = null;
      }
    }

    public void setFieldValue(_Fields field, Object value) {
      switch (field) {
      case USER_TOKEN:
        if (value == null) {
          unsetUserToken();
        } else {
          setUserToken((String)value);
        }
        break;

      case IMAGE_BASE_ID:
        if (value == null) {
          unsetImageBaseId();
        } else {
          setImageBaseId((String)value);
        }
        break;

      case IMAGE:
        if (value == null) {
          unsetImage();
        } else {
          setImage((ImageBaseWrite)value);
        }
        break;

      }
    }

    public Object getFieldValue(_Fields field) {
      switch (field) {
      case USER_TOKEN:
        return getUserToken();

      case IMAGE_BASE_ID:
        return getImageBaseId();

      case IMAGE:
        return getImage();

      }
      throw new IllegalStateException();
    }

    /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
    public boolean isSet(_Fields field) {
      if (field == null) {
        throw new IllegalArgumentException();
      }

      switch (field) {
      case USER_TOKEN:
        return isSetUserToken();
      case IMAGE_BASE_ID:
        return isSetImageBaseId();
      case IMAGE:
        return isSetImage();
      }
      throw new IllegalStateException();
    }

    @Override
    public boolean equals(Object that) {
      if (that == null)
        return false;
      if (that instanceof updateImageBase_args)
        return this.equals((updateImageBase_args)that);
      return false;
    }

    public boolean equals(updateImageBase_args that) {
      if (that == null)
        return false;

      boolean this_present_userToken = true && this.isSetUserToken();
      boolean that_present_userToken = true && that.isSetUserToken();
      if (this_present_userToken || that_present_userToken) {
        if (!(this_present_userToken && that_present_userToken))
          return false;
        if (!this.userToken.equals(that.userToken))
          return false;
      }

      boolean this_present_imageBaseId = true && this.isSetImageBaseId();
      boolean that_present_imageBaseId = true && that.isSetImageBaseId();
      if (this_present_imageBaseId || that_present_imageBaseId) {
        if (!(this_present_imageBaseId && that_present_imageBaseId))
          return false;
        if (!this.imageBaseId.equals(that.imageBaseId))
          return false;
      }

      boolean this_present_image = true && this.isSetImage();
      boolean that_present_image = true && that.isSetImage();
      if (this_present_image || that_present_image) {
        if (!(this_present_image && that_present_image))
          return false;
        if (!this.image.equals(that.image))
          return false;
      }

      return true;
    }

    @Override
    public int hashCode() {
      return 0;
    }

    @Override
    public int compareTo(updateImageBase_args other) {
      if (!getClass().equals(other.getClass())) {
        return getClass().getName().compareTo(other.getClass().getName());
      }

      int lastComparison = 0;

      lastComparison = Boolean.valueOf(isSetUserToken()).compareTo(other.isSetUserToken());
      if (lastComparison != 0) {
        return lastComparison;
      }
      if (isSetUserToken()) {
        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.userToken, other.userToken);
        if (lastComparison != 0) {
          return lastComparison;
        }
      }
      lastComparison = Boolean.valueOf(isSetImageBaseId()).compareTo(other.isSetImageBaseId());
      if (lastComparison != 0) {
        return lastComparison;
      }
      if (isSetImageBaseId()) {
        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.imageBaseId, other.imageBaseId);
        if (lastComparison != 0) {
          return lastComparison;
        }
      }
      lastComparison = Boolean.valueOf(isSetImage()).compareTo(other.isSetImage());
      if (lastComparison != 0) {
        return lastComparison;
      }
      if (isSetImage()) {
        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.image, other.image);
        if (lastComparison != 0) {
          return lastComparison;
        }
      }
      return 0;
    }

    public _Fields fieldForId(int fieldId) {
      return _Fields.findByThriftId(fieldId);
    }

    public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
      schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
    }

    public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
      schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
    }

    @Override
    public String toString() {
      StringBuilder sb = new StringBuilder("updateImageBase_args(");
      boolean first = true;

      sb.append("userToken:");
      if (this.userToken == null) {
        sb.append("null");
      } else {
        sb.append(this.userToken);
      }
      first = false;
      if (!first) sb.append(", ");
      sb.append("imageBaseId:");
      if (this.imageBaseId == null) {
        sb.append("null");
      } else {
        sb.append(this.imageBaseId);
      }
      first = false;
      if (!first) sb.append(", ");
      sb.append("image:");
      if (this.image == null) {
        sb.append("null");
      } else {
        sb.append(this.image);
      }
      first = false;
      sb.append(")");
      return sb.toString();
    }

    public void validate() throws org.apache.thrift.TException {
      // check for required fields
      // check for sub-struct validity
      if (image != null) {
        image.validate();
      }
    }

    private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
      try {
        write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
      } catch (org.apache.thrift.TException te) {
        throw new java.io.IOException(te);
      }
    }

    private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
      try {
        read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
      } catch (org.apache.thrift.TException te) {
        throw new java.io.IOException(te);
      }
    }

    private static class updateImageBase_argsStandardSchemeFactory implements SchemeFactory {
      public updateImageBase_argsStandardScheme getScheme() {
        return new updateImageBase_argsStandardScheme();
      }
    }

    private static class updateImageBase_argsStandardScheme extends StandardScheme<updateImageBase_args> {

      public void read(org.apache.thrift.protocol.TProtocol iprot, updateImageBase_args struct) throws org.apache.thrift.TException {
        org.apache.thrift.protocol.TField schemeField;
        iprot.readStructBegin();
        while (true)
        {
          schemeField = iprot.readFieldBegin();
          if (schemeField.type == org.apache.thrift.protocol.TType.STOP) { 
            break;
          }
          switch (schemeField.id) {
            case 1: // USER_TOKEN
              if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
                struct.userToken = iprot.readString();
                struct.setUserTokenIsSet(true);
              } else { 
                org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
              }
              break;
            case 2: // IMAGE_BASE_ID
              if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
                struct.imageBaseId = iprot.readString();
                struct.setImageBaseIdIsSet(true);
              } else { 
                org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
              }
              break;
            case 3: // IMAGE
              if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
                struct.image = new ImageBaseWrite();
                struct.image.read(iprot);
                struct.setImageIsSet(true);
              } else { 
                org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
              }
              break;
            default:
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
          }
          iprot.readFieldEnd();
        }
        iprot.readStructEnd();

        // check for required fields of primitive type, which can't be checked in the validate method
        struct.validate();
      }

      public void write(org.apache.thrift.protocol.TProtocol oprot, updateImageBase_args struct) throws org.apache.thrift.TException {
        struct.validate();

        oprot.writeStructBegin(STRUCT_DESC);
        if (struct.userToken != null) {
          oprot.writeFieldBegin(USER_TOKEN_FIELD_DESC);
          oprot.writeString(struct.userToken);
          oprot.writeFieldEnd();
        }
        if (struct.imageBaseId != null) {
          oprot.writeFieldBegin(IMAGE_BASE_ID_FIELD_DESC);
          oprot.writeString(struct.imageBaseId);
          oprot.writeFieldEnd();
        }
        if (struct.image != null) {
          oprot.writeFieldBegin(IMAGE_FIELD_DESC);
          struct.image.write(oprot);
          oprot.writeFieldEnd();
        }
        oprot.writeFieldStop();
        oprot.writeStructEnd();
      }

    }

    private static class updateImageBase_argsTupleSchemeFactory implements SchemeFactory {
      public updateImageBase_argsTupleScheme getScheme() {
        return new updateImageBase_argsTupleScheme();
      }
    }

    private static class updateImageBase_argsTupleScheme extends TupleScheme<updateImageBase_args> {

      @Override
      public void write(org.apache.thrift.protocol.TProtocol prot, updateImageBase_args struct) throws org.apache.thrift.TException {
        TTupleProtocol oprot = (TTupleProtocol) prot;
        BitSet optionals = new BitSet();
        if (struct.isSetUserToken()) {
          optionals.set(0);
        }
        if (struct.isSetImageBaseId()) {
          optionals.set(1);
        }
        if (struct.isSetImage()) {
          optionals.set(2);
        }
        oprot.writeBitSet(optionals, 3);
        if (struct.isSetUserToken()) {
          oprot.writeString(struct.userToken);
        }
        if (struct.isSetImageBaseId()) {
          oprot.writeString(struct.imageBaseId);
        }
        if (struct.isSetImage()) {
          struct.image.write(oprot);
        }
      }

      @Override
      public void read(org.apache.thrift.protocol.TProtocol prot, updateImageBase_args struct) throws org.apache.thrift.TException {
        TTupleProtocol iprot = (TTupleProtocol) prot;
        BitSet incoming = iprot.readBitSet(3);
        if (incoming.get(0)) {
          struct.userToken = iprot.readString();
          struct.setUserTokenIsSet(true);
        }
        if (incoming.get(1)) {
          struct.imageBaseId = iprot.readString();
          struct.setImageBaseIdIsSet(true);
        }
        if (incoming.get(2)) {
          struct.image = new ImageBaseWrite();
          struct.image.read(iprot);
          struct.setImageIsSet(true);
        }
      }
    }

  }

  public static class updateImageBase_result implements org.apache.thrift.TBase<updateImageBase_result, updateImageBase_result._Fields>, java.io.Serializable, Cloneable, Comparable<updateImageBase_result>   {
    private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("updateImageBase_result");

    private static final org.apache.thrift.protocol.TField AUTH_ERROR_FIELD_DESC = new org.apache.thrift.protocol.TField("authError", org.apache.thrift.protocol.TType.STRUCT, (short)1);
    private static final org.apache.thrift.protocol.TField NOT_FOUND_FIELD_DESC = new org.apache.thrift.protocol.TField("notFound", org.apache.thrift.protocol.TType.STRUCT, (short)2);
    private static final org.apache.thrift.protocol.TField IMG_ERROR_FIELD_DESC = new org.apache.thrift.protocol.TField("imgError", org.apache.thrift.protocol.TType.STRUCT, (short)3);
    private static final org.apache.thrift.protocol.TField SERVER_ERROR_FIELD_DESC = new org.apache.thrift.protocol.TField("serverError", org.apache.thrift.protocol.TType.STRUCT, (short)4);

    private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
    static {
      schemes.put(StandardScheme.class, new updateImageBase_resultStandardSchemeFactory());
      schemes.put(TupleScheme.class, new updateImageBase_resultTupleSchemeFactory());
    }

    public TAuthorizationException authError; // required
    public TNotFoundException notFound; // required
    public TImageDataException imgError; // required
    public TInternalServerError serverError; // required

    /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
    public enum _Fields implements org.apache.thrift.TFieldIdEnum {
      AUTH_ERROR((short)1, "authError"),
      NOT_FOUND((short)2, "notFound"),
      IMG_ERROR((short)3, "imgError"),
      SERVER_ERROR((short)4, "serverError");

      private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();

      static {
        for (_Fields field : EnumSet.allOf(_Fields.class)) {
          byName.put(field.getFieldName(), field);
        }
      }

      /**
       * Find the _Fields constant that matches fieldId, or null if its not found.
       */
      public static _Fields findByThriftId(int fieldId) {
        switch(fieldId) {
          case 1: // AUTH_ERROR
            return AUTH_ERROR;
          case 2: // NOT_FOUND
            return NOT_FOUND;
          case 3: // IMG_ERROR
            return IMG_ERROR;
          case 4: // SERVER_ERROR
            return SERVER_ERROR;
          default:
            return null;
        }
      }

      /**
       * Find the _Fields constant that matches fieldId, throwing an exception
       * if it is not found.
       */
      public static _Fields findByThriftIdOrThrow(int fieldId) {
        _Fields fields = findByThriftId(fieldId);
        if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
        return fields;
      }

      /**
       * Find the _Fields constant that matches name, or null if its not found.
       */
      public static _Fields findByName(String name) {
        return byName.get(name);
      }

      private final short _thriftId;
      private final String _fieldName;

      _Fields(short thriftId, String fieldName) {
        _thriftId = thriftId;
        _fieldName = fieldName;
      }

      public short getThriftFieldId() {
        return _thriftId;
      }

      public String getFieldName() {
        return _fieldName;
      }
    }

    // isset id assignments
    public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
    static {
      Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
      tmpMap.put(_Fields.AUTH_ERROR, new org.apache.thrift.meta_data.FieldMetaData("authError", org.apache.thrift.TFieldRequirementType.DEFAULT, 
          new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT)));
      tmpMap.put(_Fields.NOT_FOUND, new org.apache.thrift.meta_data.FieldMetaData("notFound", org.apache.thrift.TFieldRequirementType.DEFAULT, 
          new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT)));
      tmpMap.put(_Fields.IMG_ERROR, new org.apache.thrift.meta_data.FieldMetaData("imgError", org.apache.thrift.TFieldRequirementType.DEFAULT, 
          new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT)));
      tmpMap.put(_Fields.SERVER_ERROR, new org.apache.thrift.meta_data.FieldMetaData("serverError", org.apache.thrift.TFieldRequirementType.DEFAULT, 
          new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT)));
      metaDataMap = Collections.unmodifiableMap(tmpMap);
      org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(updateImageBase_result.class, metaDataMap);
    }

    public updateImageBase_result() {
    }

    public updateImageBase_result(
      TAuthorizationException authError,
      TNotFoundException notFound,
      TImageDataException imgError,
      TInternalServerError serverError)
    {
      this();
      this.authError = authError;
      this.notFound = notFound;
      this.imgError = imgError;
      this.serverError = serverError;
    }

    /**
     * Performs a deep copy on <i>other</i>.
     */
    public updateImageBase_result(updateImageBase_result other) {
      if (other.isSetAuthError()) {
        this.authError = new TAuthorizationException(other.authError);
      }
      if (other.isSetNotFound()) {
        this.notFound = new TNotFoundException(other.notFound);
      }
      if (other.isSetImgError()) {
        this.imgError = new TImageDataException(other.imgError);
      }
      if (other.isSetServerError()) {
        this.serverError = new TInternalServerError(other.serverError);
      }
    }

    public updateImageBase_result deepCopy() {
      return new updateImageBase_result(this);
    }

    @Override
    public void clear() {
      this.authError = null;
      this.notFound = null;
      this.imgError = null;
      this.serverError = null;
    }

    public TAuthorizationException getAuthError() {
      return this.authError;
    }

    public updateImageBase_result setAuthError(TAuthorizationException authError) {
      this.authError = authError;
      return this;
    }

    public void unsetAuthError() {
      this.authError = null;
    }

    /** Returns true if field authError is set (has been assigned a value) and false otherwise */
    public boolean isSetAuthError() {
      return this.authError != null;
    }

    public void setAuthErrorIsSet(boolean value) {
      if (!value) {
        this.authError = null;
      }
    }

    public TNotFoundException getNotFound() {
      return this.notFound;
    }

    public updateImageBase_result setNotFound(TNotFoundException notFound) {
      this.notFound = notFound;
      return this;
    }

    public void unsetNotFound() {
      this.notFound = null;
    }

    /** Returns true if field notFound is set (has been assigned a value) and false otherwise */
    public boolean isSetNotFound() {
      return this.notFound != null;
    }

    public void setNotFoundIsSet(boolean value) {
      if (!value) {
        this.notFound = null;
      }
    }

    public TImageDataException getImgError() {
      return this.imgError;
    }

    public updateImageBase_result setImgError(TImageDataException imgError) {
      this.imgError = imgError;
      return this;
    }

    public void unsetImgError() {
      this.imgError = null;
    }

    /** Returns true if field imgError is set (has been assigned a value) and false otherwise */
    public boolean isSetImgError() {
      return this.imgError != null;
    }

    public void setImgErrorIsSet(boolean value) {
      if (!value) {
        this.imgError = null;
      }
    }

    public TInternalServerError getServerError() {
      return this.serverError;
    }

    public updateImageBase_result setServerError(TInternalServerError serverError) {
      this.serverError = serverError;
      return this;
    }

    public void unsetServerError() {
      this.serverError = null;
    }

    /** Returns true if field serverError is set (has been assigned a value) and false otherwise */
    public boolean isSetServerError() {
      return this.serverError != null;
    }

    public void setServerErrorIsSet(boolean value) {
      if (!value) {
        this.serverError = null;
      }
    }

    public void setFieldValue(_Fields field, Object value) {
      switch (field) {
      case AUTH_ERROR:
        if (value == null) {
          unsetAuthError();
        } else {
          setAuthError((TAuthorizationException)value);
        }
        break;

      case NOT_FOUND:
        if (value == null) {
          unsetNotFound();
        } else {
          setNotFound((TNotFoundException)value);
        }
        break;

      case IMG_ERROR:
        if (value == null) {
          unsetImgError();
        } else {
          setImgError((TImageDataException)value);
        }
        break;

      case SERVER_ERROR:
        if (value == null) {
          unsetServerError();
        } else {
          setServerError((TInternalServerError)value);
        }
        break;

      }
    }

    public Object getFieldValue(_Fields field) {
      switch (field) {
      case AUTH_ERROR:
        return getAuthError();

      case NOT_FOUND:
        return getNotFound();

      case IMG_ERROR:
        return getImgError();

      case SERVER_ERROR:
        return getServerError();

      }
      throw new IllegalStateException();
    }

    /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
    public boolean isSet(_Fields field) {
      if (field == null) {
        throw new IllegalArgumentException();
      }

      switch (field) {
      case AUTH_ERROR:
        return isSetAuthError();
      case NOT_FOUND:
        return isSetNotFound();
      case IMG_ERROR:
        return isSetImgError();
      case SERVER_ERROR:
        return isSetServerError();
      }
      throw new IllegalStateException();
    }

    @Override
    public boolean equals(Object that) {
      if (that == null)
        return false;
      if (that instanceof updateImageBase_result)
        return this.equals((updateImageBase_result)that);
      return false;
    }

    public boolean equals(updateImageBase_result that) {
      if (that == null)
        return false;

      boolean this_present_authError = true && this.isSetAuthError();
      boolean that_present_authError = true && that.isSetAuthError();
      if (this_present_authError || that_present_authError) {
        if (!(this_present_authError && that_present_authError))
          return false;
        if (!this.authError.equals(that.authError))
          return false;
      }

      boolean this_present_notFound = true && this.isSetNotFound();
      boolean that_present_notFound = true && that.isSetNotFound();
      if (this_present_notFound || that_present_notFound) {
        if (!(this_present_notFound && that_present_notFound))
          return false;
        if (!this.notFound.equals(that.notFound))
          return false;
      }

      boolean this_present_imgError = true && this.isSetImgError();
      boolean that_present_imgError = true && that.isSetImgError();
      if (this_present_imgError || that_present_imgError) {
        if (!(this_present_imgError && that_present_imgError))
          return false;
        if (!this.imgError.equals(that.imgError))
          return false;
      }

      boolean this_present_serverError = true && this.isSetServerError();
      boolean that_present_serverError = true && that.isSetServerError();
      if (this_present_serverError || that_present_serverError) {
        if (!(this_present_serverError && that_present_serverError))
          return false;
        if (!this.serverError.equals(that.serverError))
          return false;
      }

      return true;
    }

    @Override
    public int hashCode() {
      return 0;
    }

    @Override
    public int compareTo(updateImageBase_result other) {
      if (!getClass().equals(other.getClass())) {
        return getClass().getName().compareTo(other.getClass().getName());
      }

      int lastComparison = 0;

      lastComparison = Boolean.valueOf(isSetAuthError()).compareTo(other.isSetAuthError());
      if (lastComparison != 0) {
        return lastComparison;
      }
      if (isSetAuthError()) {
        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.authError, other.authError);
        if (lastComparison != 0) {
          return lastComparison;
        }
      }
      lastComparison = Boolean.valueOf(isSetNotFound()).compareTo(other.isSetNotFound());
      if (lastComparison != 0) {
        return lastComparison;
      }
      if (isSetNotFound()) {
        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.notFound, other.notFound);
        if (lastComparison != 0) {
          return lastComparison;
        }
      }
      lastComparison = Boolean.valueOf(isSetImgError()).compareTo(other.isSetImgError());
      if (lastComparison != 0) {
        return lastComparison;
      }
      if (isSetImgError()) {
        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.imgError, other.imgError);
        if (lastComparison != 0) {
          return lastComparison;
        }
      }
      lastComparison = Boolean.valueOf(isSetServerError()).compareTo(other.isSetServerError());
      if (lastComparison != 0) {
        return lastComparison;
      }
      if (isSetServerError()) {
        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.serverError, other.serverError);
        if (lastComparison != 0) {
          return lastComparison;
        }
      }
      return 0;
    }

    public _Fields fieldForId(int fieldId) {
      return _Fields.findByThriftId(fieldId);
    }

    public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
      schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
    }

    public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
      schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
      }

    @Override
    public String toString() {
      StringBuilder sb = new StringBuilder("updateImageBase_result(");
      boolean first = true;

      sb.append("authError:");
      if (this.authError == null) {
        sb.append("null");
      } else {
        sb.append(this.authError);
      }
      first = false;
      if (!first) sb.append(", ");
      sb.append("notFound:");
      if (this.notFound == null) {
        sb.append("null");
      } else {
        sb.append(this.notFound);
      }
      first = false;
      if (!first) sb.append(", ");
      sb.append("imgError:");
      if (this.imgError == null) {
        sb.append("null");
      } else {
        sb.append(this.imgError);
      }
      first = false;
      if (!first) sb.append(", ");
      sb.append("serverError:");
      if (this.serverError == null) {
        sb.append("null");
      } else {
        sb.append(this.serverError);
      }
      first = false;
      sb.append(")");
      return sb.toString();
    }

    public void validate() throws org.apache.thrift.TException {
      // check for required fields
      // check for sub-struct validity
    }

    private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
      try {
        write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
      } catch (org.apache.thrift.TException te) {
        throw new java.io.IOException(te);
      }
    }

    private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
      try {
        read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
      } catch (org.apache.thrift.TException te) {
        throw new java.io.IOException(te);
      }
    }

    private static class updateImageBase_resultStandardSchemeFactory implements SchemeFactory {
      public updateImageBase_resultStandardScheme getScheme() {
        return new updateImageBase_resultStandardScheme();
      }
    }

    private static class updateImageBase_resultStandardScheme extends StandardScheme<updateImageBase_result> {

      public void read(org.apache.thrift.protocol.TProtocol iprot, updateImageBase_result struct) throws org.apache.thrift.TException {
        org.apache.thrift.protocol.TField schemeField;
        iprot.readStructBegin();
        while (true)
        {
          schemeField = iprot.readFieldBegin();
          if (schemeField.type == org.apache.thrift.protocol.TType.STOP) { 
            break;
          }
          switch (schemeField.id) {
            case 1: // AUTH_ERROR
              if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
                struct.authError = new TAuthorizationException();
                struct.authError.read(iprot);
                struct.setAuthErrorIsSet(true);
              } else { 
                org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
              }
              break;
            case 2: // NOT_FOUND
              if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
                struct.notFound = new TNotFoundException();
                struct.notFound.read(iprot);
                struct.setNotFoundIsSet(true);
              } else { 
                org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
              }
              break;
            case 3: // IMG_ERROR
              if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
                struct.imgError = new TImageDataException();
                struct.imgError.read(iprot);
                struct.setImgErrorIsSet(true);
              } else { 
                org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
              }
              break;
            case 4: // SERVER_ERROR
              if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
                struct.serverError = new TInternalServerError();
                struct.serverError.read(iprot);
                struct.setServerErrorIsSet(true);
              } else { 
                org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
              }
              break;
            default:
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
          }
          iprot.readFieldEnd();
        }
        iprot.readStructEnd();

        // check for required fields of primitive type, which can't be checked in the validate method
        struct.validate();
      }

      public void write(org.apache.thrift.protocol.TProtocol oprot, updateImageBase_result struct) throws org.apache.thrift.TException {
        struct.validate();

        oprot.writeStructBegin(STRUCT_DESC);
        if (struct.authError != null) {
          oprot.writeFieldBegin(AUTH_ERROR_FIELD_DESC);
          struct.authError.write(oprot);
          oprot.writeFieldEnd();
        }
        if (struct.notFound != null) {
          oprot.writeFieldBegin(NOT_FOUND_FIELD_DESC);
          struct.notFound.write(oprot);
          oprot.writeFieldEnd();
        }
        if (struct.imgError != null) {
          oprot.writeFieldBegin(IMG_ERROR_FIELD_DESC);
          struct.imgError.write(oprot);
          oprot.writeFieldEnd();
        }
        if (struct.serverError != null) {
          oprot.writeFieldBegin(SERVER_ERROR_FIELD_DESC);
          struct.serverError.write(oprot);
          oprot.writeFieldEnd();
        }
        oprot.writeFieldStop();
        oprot.writeStructEnd();
      }

    }

    private static class updateImageBase_resultTupleSchemeFactory implements SchemeFactory {
      public updateImageBase_resultTupleScheme getScheme() {
        return new updateImageBase_resultTupleScheme();
      }
    }

    private static class updateImageBase_resultTupleScheme extends TupleScheme<updateImageBase_result> {

      @Override
      public void write(org.apache.thrift.protocol.TProtocol prot, updateImageBase_result struct) throws org.apache.thrift.TException {
        TTupleProtocol oprot = (TTupleProtocol) prot;
        BitSet optionals = new BitSet();
        if (struct.isSetAuthError()) {
          optionals.set(0);
        }
        if (struct.isSetNotFound()) {
          optionals.set(1);
        }
        if (struct.isSetImgError()) {
          optionals.set(2);
        }
        if (struct.isSetServerError()) {
          optionals.set(3);
        }
        oprot.writeBitSet(optionals, 4);
        if (struct.isSetAuthError()) {
          struct.authError.write(oprot);
        }
        if (struct.isSetNotFound()) {
          struct.notFound.write(oprot);
        }
        if (struct.isSetImgError()) {
          struct.imgError.write(oprot);
        }
        if (struct.isSetServerError()) {
          struct.serverError.write(oprot);
        }
      }

      @Override
      public void read(org.apache.thrift.protocol.TProtocol prot, updateImageBase_result struct) throws org.apache.thrift.TException {
        TTupleProtocol iprot = (TTupleProtocol) prot;
        BitSet incoming = iprot.readBitSet(4);
        if (incoming.get(0)) {
          struct.authError = new TAuthorizationException();
          struct.authError.read(iprot);
          struct.setAuthErrorIsSet(true);
        }
        if (incoming.get(1)) {
          struct.notFound = new TNotFoundException();
          struct.notFound.read(iprot);
          struct.setNotFoundIsSet(true);
        }
        if (incoming.get(2)) {
          struct.imgError = new TImageDataException();
          struct.imgError.read(iprot);
          struct.setImgErrorIsSet(true);
        }
        if (incoming.get(3)) {
          struct.serverError = new TInternalServerError();
          struct.serverError.read(iprot);
          struct.setServerErrorIsSet(true);
        }
      }
    }

  }

  public static class updateImageVersion_args implements org.apache.thrift.TBase<updateImageVersion_args, updateImageVersion_args._Fields>, java.io.Serializable, Cloneable, Comparable<updateImageVersion_args>   {
    private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("updateImageVersion_args");

    private static final org.apache.thrift.protocol.TField USER_TOKEN_FIELD_DESC = new org.apache.thrift.protocol.TField("userToken", org.apache.thrift.protocol.TType.STRING, (short)1);
    private static final org.apache.thrift.protocol.TField IMAGE_VERSION_ID_FIELD_DESC = new org.apache.thrift.protocol.TField("imageVersionId", org.apache.thrift.protocol.TType.STRING, (short)2);
    private static final org.apache.thrift.protocol.TField IMAGE_FIELD_DESC = new org.apache.thrift.protocol.TField("image", org.apache.thrift.protocol.TType.STRUCT, (short)3);

    private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
    static {
      schemes.put(StandardScheme.class, new updateImageVersion_argsStandardSchemeFactory());
      schemes.put(TupleScheme.class, new updateImageVersion_argsTupleSchemeFactory());
    }

    public String userToken; // required
    public String imageVersionId; // required
    public ImageVersionWrite image; // required

    /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
    public enum _Fields implements org.apache.thrift.TFieldIdEnum {
      USER_TOKEN((short)1, "userToken"),
      IMAGE_VERSION_ID((short)2, "imageVersionId"),
      IMAGE((short)3, "image");

      private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();

      static {
        for (_Fields field : EnumSet.allOf(_Fields.class)) {
          byName.put(field.getFieldName(), field);
        }
      }

      /**
       * Find the _Fields constant that matches fieldId, or null if its not found.
       */
      public static _Fields findByThriftId(int fieldId) {
        switch(fieldId) {
          case 1: // USER_TOKEN
            return USER_TOKEN;
          case 2: // IMAGE_VERSION_ID
            return IMAGE_VERSION_ID;
          case 3: // IMAGE
            return IMAGE;
          default:
            return null;
        }
      }

      /**
       * Find the _Fields constant that matches fieldId, throwing an exception
       * if it is not found.
       */
      public static _Fields findByThriftIdOrThrow(int fieldId) {
        _Fields fields = findByThriftId(fieldId);
        if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
        return fields;
      }

      /**
       * Find the _Fields constant that matches name, or null if its not found.
       */
      public static _Fields findByName(String name) {
        return byName.get(name);
      }

      private final short _thriftId;
      private final String _fieldName;

      _Fields(short thriftId, String fieldName) {
        _thriftId = thriftId;
        _fieldName = fieldName;
      }

      public short getThriftFieldId() {
        return _thriftId;
      }

      public String getFieldName() {
        return _fieldName;
      }
    }

    // isset id assignments
    public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
    static {
      Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
      tmpMap.put(_Fields.USER_TOKEN, new org.apache.thrift.meta_data.FieldMetaData("userToken", org.apache.thrift.TFieldRequirementType.DEFAULT, 
          new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING          , "Token")));
      tmpMap.put(_Fields.IMAGE_VERSION_ID, new org.apache.thrift.meta_data.FieldMetaData("imageVersionId", org.apache.thrift.TFieldRequirementType.DEFAULT, 
          new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING          , "UUID")));
      tmpMap.put(_Fields.IMAGE, new org.apache.thrift.meta_data.FieldMetaData("image", org.apache.thrift.TFieldRequirementType.DEFAULT, 
          new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, ImageVersionWrite.class)));
      metaDataMap = Collections.unmodifiableMap(tmpMap);
      org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(updateImageVersion_args.class, metaDataMap);
    }

    public updateImageVersion_args() {
    }

    public updateImageVersion_args(
      String userToken,
      String imageVersionId,
      ImageVersionWrite image)
    {
      this();
      this.userToken = userToken;
      this.imageVersionId = imageVersionId;
      this.image = image;
    }

    /**
     * Performs a deep copy on <i>other</i>.
     */
    public updateImageVersion_args(updateImageVersion_args other) {
      if (other.isSetUserToken()) {
        this.userToken = other.userToken;
      }
      if (other.isSetImageVersionId()) {
        this.imageVersionId = other.imageVersionId;
      }
      if (other.isSetImage()) {
        this.image = new ImageVersionWrite(other.image);
      }
    }

    public updateImageVersion_args deepCopy() {
      return new updateImageVersion_args(this);
    }

    @Override
    public void clear() {
      this.userToken = null;
      this.imageVersionId = null;
      this.image = null;
    }

    public String getUserToken() {
      return this.userToken;
    }

    public updateImageVersion_args setUserToken(String userToken) {
      this.userToken = userToken;
      return this;
    }

    public void unsetUserToken() {
      this.userToken = null;
    }

    /** Returns true if field userToken is set (has been assigned a value) and false otherwise */
    public boolean isSetUserToken() {
      return this.userToken != null;
    }

    public void setUserTokenIsSet(boolean value) {
      if (!value) {
        this.userToken = null;
      }
    }

    public String getImageVersionId() {
      return this.imageVersionId;
    }

    public updateImageVersion_args setImageVersionId(String imageVersionId) {
      this.imageVersionId = imageVersionId;
      return this;
    }

    public void unsetImageVersionId() {
      this.imageVersionId = null;
    }

    /** Returns true if field imageVersionId is set (has been assigned a value) and false otherwise */
    public boolean isSetImageVersionId() {
      return this.imageVersionId != null;
    }

    public void setImageVersionIdIsSet(boolean value) {
      if (!value) {
        this.imageVersionId = null;
      }
    }

    public ImageVersionWrite getImage() {
      return this.image;
    }

    public updateImageVersion_args setImage(ImageVersionWrite image) {
      this.image = image;
      return this;
    }

    public void unsetImage() {
      this.image = null;
    }

    /** Returns true if field image is set (has been assigned a value) and false otherwise */
    public boolean isSetImage() {
      return this.image != null;
    }

    public void setImageIsSet(boolean value) {
      if (!value) {
        this.image = null;
      }
    }

    public void setFieldValue(_Fields field, Object value) {
      switch (field) {
      case USER_TOKEN:
        if (value == null) {
          unsetUserToken();
        } else {
          setUserToken((String)value);
        }
        break;

      case IMAGE_VERSION_ID:
        if (value == null) {
          unsetImageVersionId();
        } else {
          setImageVersionId((String)value);
        }
        break;

      case IMAGE:
        if (value == null) {
          unsetImage();
        } else {
          setImage((ImageVersionWrite)value);
        }
        break;

      }
    }

    public Object getFieldValue(_Fields field) {
      switch (field) {
      case USER_TOKEN:
        return getUserToken();

      case IMAGE_VERSION_ID:
        return getImageVersionId();

      case IMAGE:
        return getImage();

      }
      throw new IllegalStateException();
    }

    /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
    public boolean isSet(_Fields field) {
      if (field == null) {
        throw new IllegalArgumentException();
      }

      switch (field) {
      case USER_TOKEN:
        return isSetUserToken();
      case IMAGE_VERSION_ID:
        return isSetImageVersionId();
      case IMAGE:
        return isSetImage();
      }
      throw new IllegalStateException();
    }

    @Override
    public boolean equals(Object that) {
      if (that == null)
        return false;
      if (that instanceof updateImageVersion_args)
        return this.equals((updateImageVersion_args)that);
      return false;
    }

    public boolean equals(updateImageVersion_args that) {
      if (that == null)
        return false;

      boolean this_present_userToken = true && this.isSetUserToken();
      boolean that_present_userToken = true && that.isSetUserToken();
      if (this_present_userToken || that_present_userToken) {
        if (!(this_present_userToken && that_present_userToken))
          return false;
        if (!this.userToken.equals(that.userToken))
          return false;
      }

      boolean this_present_imageVersionId = true && this.isSetImageVersionId();
      boolean that_present_imageVersionId = true && that.isSetImageVersionId();
      if (this_present_imageVersionId || that_present_imageVersionId) {
        if (!(this_present_imageVersionId && that_present_imageVersionId))
          return false;
        if (!this.imageVersionId.equals(that.imageVersionId))
          return false;
      }

      boolean this_present_image = true && this.isSetImage();
      boolean that_present_image = true && that.isSetImage();
      if (this_present_image || that_present_image) {
        if (!(this_present_image && that_present_image))
          return false;
        if (!this.image.equals(that.image))
          return false;
      }

      return true;
    }

    @Override
    public int hashCode() {
      return 0;
    }

    @Override
    public int compareTo(updateImageVersion_args other) {
      if (!getClass().equals(other.getClass())) {
        return getClass().getName().compareTo(other.getClass().getName());
      }

      int lastComparison = 0;

      lastComparison = Boolean.valueOf(isSetUserToken()).compareTo(other.isSetUserToken());
      if (lastComparison != 0) {
        return lastComparison;
      }
      if (isSetUserToken()) {
        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.userToken, other.userToken);
        if (lastComparison != 0) {
          return lastComparison;
        }
      }
      lastComparison = Boolean.valueOf(isSetImageVersionId()).compareTo(other.isSetImageVersionId());
      if (lastComparison != 0) {
        return lastComparison;
      }
      if (isSetImageVersionId()) {
        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.imageVersionId, other.imageVersionId);
        if (lastComparison != 0) {
          return lastComparison;
        }
      }
      lastComparison = Boolean.valueOf(isSetImage()).compareTo(other.isSetImage());
      if (lastComparison != 0) {
        return lastComparison;
      }
      if (isSetImage()) {
        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.image, other.image);
        if (lastComparison != 0) {
          return lastComparison;
        }
      }
      return 0;
    }

    public _Fields fieldForId(int fieldId) {
      return _Fields.findByThriftId(fieldId);
    }

    public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
      schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
    }

    public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
      schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
    }

    @Override
    public String toString() {
      StringBuilder sb = new StringBuilder("updateImageVersion_args(");
      boolean first = true;

      sb.append("userToken:");
      if (this.userToken == null) {
        sb.append("null");
      } else {
        sb.append(this.userToken);
      }
      first = false;
      if (!first) sb.append(", ");
      sb.append("imageVersionId:");
      if (this.imageVersionId == null) {
        sb.append("null");
      } else {
        sb.append(this.imageVersionId);
      }
      first = false;
      if (!first) sb.append(", ");
      sb.append("image:");
      if (this.image == null) {
        sb.append("null");
      } else {
        sb.append(this.image);
      }
      first = false;
      sb.append(")");
      return sb.toString();
    }

    public void validate() throws org.apache.thrift.TException {
      // check for required fields
      // check for sub-struct validity
      if (image != null) {
        image.validate();
      }
    }

    private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
      try {
        write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
      } catch (org.apache.thrift.TException te) {
        throw new java.io.IOException(te);
      }
    }

    private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
      try {
        read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
      } catch (org.apache.thrift.TException te) {
        throw new java.io.IOException(te);
      }
    }

    private static class updateImageVersion_argsStandardSchemeFactory implements SchemeFactory {
      public updateImageVersion_argsStandardScheme getScheme() {
        return new updateImageVersion_argsStandardScheme();
      }
    }

    private static class updateImageVersion_argsStandardScheme extends StandardScheme<updateImageVersion_args> {

      public void read(org.apache.thrift.protocol.TProtocol iprot, updateImageVersion_args struct) throws org.apache.thrift.TException {
        org.apache.thrift.protocol.TField schemeField;
        iprot.readStructBegin();
        while (true)
        {
          schemeField = iprot.readFieldBegin();
          if (schemeField.type == org.apache.thrift.protocol.TType.STOP) { 
            break;
          }
          switch (schemeField.id) {
            case 1: // USER_TOKEN
              if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
                struct.userToken = iprot.readString();
                struct.setUserTokenIsSet(true);
              } else { 
                org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
              }
              break;
            case 2: // IMAGE_VERSION_ID
              if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
                struct.imageVersionId = iprot.readString();
                struct.setImageVersionIdIsSet(true);
              } else { 
                org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
              }
              break;
            case 3: // IMAGE
              if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
                struct.image = new ImageVersionWrite();
                struct.image.read(iprot);
                struct.setImageIsSet(true);
              } else { 
                org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
              }
              break;
            default:
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
          }
          iprot.readFieldEnd();
        }
        iprot.readStructEnd();

        // check for required fields of primitive type, which can't be checked in the validate method
        struct.validate();
      }

      public void write(org.apache.thrift.protocol.TProtocol oprot, updateImageVersion_args struct) throws org.apache.thrift.TException {
        struct.validate();

        oprot.writeStructBegin(STRUCT_DESC);
        if (struct.userToken != null) {
          oprot.writeFieldBegin(USER_TOKEN_FIELD_DESC);
          oprot.writeString(struct.userToken);
          oprot.writeFieldEnd();
        }
        if (struct.imageVersionId != null) {
          oprot.writeFieldBegin(IMAGE_VERSION_ID_FIELD_DESC);
          oprot.writeString(struct.imageVersionId);
          oprot.writeFieldEnd();
        }
        if (struct.image != null) {
          oprot.writeFieldBegin(IMAGE_FIELD_DESC);
          struct.image.write(oprot);
          oprot.writeFieldEnd();
        }
        oprot.writeFieldStop();
        oprot.writeStructEnd();
      }

    }

    private static class updateImageVersion_argsTupleSchemeFactory implements SchemeFactory {
      public updateImageVersion_argsTupleScheme getScheme() {
        return new updateImageVersion_argsTupleScheme();
      }
    }

    private static class updateImageVersion_argsTupleScheme extends TupleScheme<updateImageVersion_args> {

      @Override
      public void write(org.apache.thrift.protocol.TProtocol prot, updateImageVersion_args struct) throws org.apache.thrift.TException {
        TTupleProtocol oprot = (TTupleProtocol) prot;
        BitSet optionals = new BitSet();
        if (struct.isSetUserToken()) {
          optionals.set(0);
        }
        if (struct.isSetImageVersionId()) {
          optionals.set(1);
        }
        if (struct.isSetImage()) {
          optionals.set(2);
        }
        oprot.writeBitSet(optionals, 3);
        if (struct.isSetUserToken()) {
          oprot.writeString(struct.userToken);
        }
        if (struct.isSetImageVersionId()) {
          oprot.writeString(struct.imageVersionId);
        }
        if (struct.isSetImage()) {
          struct.image.write(oprot);
        }
      }

      @Override
      public void read(org.apache.thrift.protocol.TProtocol prot, updateImageVersion_args struct) throws org.apache.thrift.TException {
        TTupleProtocol iprot = (TTupleProtocol) prot;
        BitSet incoming = iprot.readBitSet(3);
        if (incoming.get(0)) {
          struct.userToken = iprot.readString();
          struct.setUserTokenIsSet(true);
        }
        if (incoming.get(1)) {
          struct.imageVersionId = iprot.readString();
          struct.setImageVersionIdIsSet(true);
        }
        if (incoming.get(2)) {
          struct.image = new ImageVersionWrite();
          struct.image.read(iprot);
          struct.setImageIsSet(true);
        }
      }
    }

  }

  public static class updateImageVersion_result implements org.apache.thrift.TBase<updateImageVersion_result, updateImageVersion_result._Fields>, java.io.Serializable, Cloneable, Comparable<updateImageVersion_result>   {
    private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("updateImageVersion_result");

    private static final org.apache.thrift.protocol.TField AUTH_ERROR_FIELD_DESC = new org.apache.thrift.protocol.TField("authError", org.apache.thrift.protocol.TType.STRUCT, (short)1);
    private static final org.apache.thrift.protocol.TField NOT_FOUND_FIELD_DESC = new org.apache.thrift.protocol.TField("notFound", org.apache.thrift.protocol.TType.STRUCT, (short)2);
    private static final org.apache.thrift.protocol.TField IMG_ERROR_FIELD_DESC = new org.apache.thrift.protocol.TField("imgError", org.apache.thrift.protocol.TType.STRUCT, (short)3);
    private static final org.apache.thrift.protocol.TField SERVER_ERROR_FIELD_DESC = new org.apache.thrift.protocol.TField("serverError", org.apache.thrift.protocol.TType.STRUCT, (short)4);

    private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
    static {
      schemes.put(StandardScheme.class, new updateImageVersion_resultStandardSchemeFactory());
      schemes.put(TupleScheme.class, new updateImageVersion_resultTupleSchemeFactory());
    }

    public TAuthorizationException authError; // required
    public TNotFoundException notFound; // required
    public TImageDataException imgError; // required
    public TInternalServerError serverError; // required

    /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
    public enum _Fields implements org.apache.thrift.TFieldIdEnum {
      AUTH_ERROR((short)1, "authError"),
      NOT_FOUND((short)2, "notFound"),
      IMG_ERROR((short)3, "imgError"),
      SERVER_ERROR((short)4, "serverError");

      private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();

      static {
        for (_Fields field : EnumSet.allOf(_Fields.class)) {
          byName.put(field.getFieldName(), field);
        }
      }

      /**
       * Find the _Fields constant that matches fieldId, or null if its not found.
       */
      public static _Fields findByThriftId(int fieldId) {
        switch(fieldId) {
          case 1: // AUTH_ERROR
            return AUTH_ERROR;
          case 2: // NOT_FOUND
            return NOT_FOUND;
          case 3: // IMG_ERROR
            return IMG_ERROR;
          case 4: // SERVER_ERROR
            return SERVER_ERROR;
          default:
            return null;
        }
      }

      /**
       * Find the _Fields constant that matches fieldId, throwing an exception
       * if it is not found.
       */
      public static _Fields findByThriftIdOrThrow(int fieldId) {
        _Fields fields = findByThriftId(fieldId);
        if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
        return fields;
      }

      /**
       * Find the _Fields constant that matches name, or null if its not found.
       */
      public static _Fields findByName(String name) {
        return byName.get(name);
      }

      private final short _thriftId;
      private final String _fieldName;

      _Fields(short thriftId, String fieldName) {
        _thriftId = thriftId;
        _fieldName = fieldName;
      }

      public short getThriftFieldId() {
        return _thriftId;
      }

      public String getFieldName() {
        return _fieldName;
      }
    }

    // isset id assignments
    public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
    static {
      Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
      tmpMap.put(_Fields.AUTH_ERROR, new org.apache.thrift.meta_data.FieldMetaData("authError", org.apache.thrift.TFieldRequirementType.DEFAULT, 
          new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT)));
      tmpMap.put(_Fields.NOT_FOUND, new org.apache.thrift.meta_data.FieldMetaData("notFound", org.apache.thrift.TFieldRequirementType.DEFAULT, 
          new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT)));
      tmpMap.put(_Fields.IMG_ERROR, new org.apache.thrift.meta_data.FieldMetaData("imgError", org.apache.thrift.TFieldRequirementType.DEFAULT, 
          new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT)));
      tmpMap.put(_Fields.SERVER_ERROR, new org.apache.thrift.meta_data.FieldMetaData("serverError", org.apache.thrift.TFieldRequirementType.DEFAULT, 
          new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT)));
      metaDataMap = Collections.unmodifiableMap(tmpMap);
      org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(updateImageVersion_result.class, metaDataMap);
    }

    public updateImageVersion_result() {
    }

    public updateImageVersion_result(
      TAuthorizationException authError,
      TNotFoundException notFound,
      TImageDataException imgError,
      TInternalServerError serverError)
    {
      this();
      this.authError = authError;
      this.notFound = notFound;
      this.imgError = imgError;
      this.serverError = serverError;
    }

    /**
     * Performs a deep copy on <i>other</i>.
     */
    public updateImageVersion_result(updateImageVersion_result other) {
      if (other.isSetAuthError()) {
        this.authError = new TAuthorizationException(other.authError);
      }
      if (other.isSetNotFound()) {
        this.notFound = new TNotFoundException(other.notFound);
      }
      if (other.isSetImgError()) {
        this.imgError = new TImageDataException(other.imgError);
      }
      if (other.isSetServerError()) {
        this.serverError = new TInternalServerError(other.serverError);
      }
    }

    public updateImageVersion_result deepCopy() {
      return new updateImageVersion_result(this);
    }

    @Override
    public void clear() {
      this.authError = null;
      this.notFound = null;
      this.imgError = null;
      this.serverError = null;
    }

    public TAuthorizationException getAuthError() {
      return this.authError;
    }

    public updateImageVersion_result setAuthError(TAuthorizationException authError) {
      this.authError = authError;
      return this;
    }

    public void unsetAuthError() {
      this.authError = null;
    }

    /** Returns true if field authError is set (has been assigned a value) and false otherwise */
    public boolean isSetAuthError() {
      return this.authError != null;
    }

    public void setAuthErrorIsSet(boolean value) {
      if (!value) {
        this.authError = null;
      }
    }

    public TNotFoundException getNotFound() {
      return this.notFound;
    }

    public updateImageVersion_result setNotFound(TNotFoundException notFound) {
      this.notFound = notFound;
      return this;
    }

    public void unsetNotFound() {
      this.notFound = null;
    }

    /** Returns true if field notFound is set (has been assigned a value) and false otherwise */
    public boolean isSetNotFound() {
      return this.notFound != null;
    }

    public void setNotFoundIsSet(boolean value) {
      if (!value) {
        this.notFound = null;
      }
    }

    public TImageDataException getImgError() {
      return this.imgError;
    }

    public updateImageVersion_result setImgError(TImageDataException imgError) {
      this.imgError = imgError;
      return this;
    }

    public void unsetImgError() {
      this.imgError = null;
    }

    /** Returns true if field imgError is set (has been assigned a value) and false otherwise */
    public boolean isSetImgError() {
      return this.imgError != null;
    }

    public void setImgErrorIsSet(boolean value) {
      if (!value) {
        this.imgError = null;
      }
    }

    public TInternalServerError getServerError() {
      return this.serverError;
    }

    public updateImageVersion_result setServerError(TInternalServerError serverError) {
      this.serverError = serverError;
      return this;
    }

    public void unsetServerError() {
      this.serverError = null;
    }

    /** Returns true if field serverError is set (has been assigned a value) and false otherwise */
    public boolean isSetServerError() {
      return this.serverError != null;
    }

    public void setServerErrorIsSet(boolean value) {
      if (!value) {
        this.serverError = null;
      }
    }

    public void setFieldValue(_Fields field, Object value) {
      switch (field) {
      case AUTH_ERROR:
        if (value == null) {
          unsetAuthError();
        } else {
          setAuthError((TAuthorizationException)value);
        }
        break;

      case NOT_FOUND:
        if (value == null) {
          unsetNotFound();
        } else {
          setNotFound((TNotFoundException)value);
        }
        break;

      case IMG_ERROR:
        if (value == null) {
          unsetImgError();
        } else {
          setImgError((TImageDataException)value);
        }
        break;

      case SERVER_ERROR:
        if (value == null) {
          unsetServerError();
        } else {
          setServerError((TInternalServerError)value);
        }
        break;

      }
    }

    public Object getFieldValue(_Fields field) {
      switch (field) {
      case AUTH_ERROR:
        return getAuthError();

      case NOT_FOUND:
        return getNotFound();

      case IMG_ERROR:
        return getImgError();

      case SERVER_ERROR:
        return getServerError();

      }
      throw new IllegalStateException();
    }

    /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
    public boolean isSet(_Fields field) {
      if (field == null) {
        throw new IllegalArgumentException();
      }

      switch (field) {
      case AUTH_ERROR:
        return isSetAuthError();
      case NOT_FOUND:
        return isSetNotFound();
      case IMG_ERROR:
        return isSetImgError();
      case SERVER_ERROR:
        return isSetServerError();
      }
      throw new IllegalStateException();
    }

    @Override
    public boolean equals(Object that) {
      if (that == null)
        return false;
      if (that instanceof updateImageVersion_result)
        return this.equals((updateImageVersion_result)that);
      return false;
    }

    public boolean equals(updateImageVersion_result that) {
      if (that == null)
        return false;

      boolean this_present_authError = true && this.isSetAuthError();
      boolean that_present_authError = true && that.isSetAuthError();
      if (this_present_authError || that_present_authError) {
        if (!(this_present_authError && that_present_authError))
          return false;
        if (!this.authError.equals(that.authError))
          return false;
      }

      boolean this_present_notFound = true && this.isSetNotFound();
      boolean that_present_notFound = true && that.isSetNotFound();
      if (this_present_notFound || that_present_notFound) {
        if (!(this_present_notFound && that_present_notFound))
          return false;
        if (!this.notFound.equals(that.notFound))
          return false;
      }

      boolean this_present_imgError = true && this.isSetImgError();
      boolean that_present_imgError = true && that.isSetImgError();
      if (this_present_imgError || that_present_imgError) {
        if (!(this_present_imgError && that_present_imgError))
          return false;
        if (!this.imgError.equals(that.imgError))
          return false;
      }

      boolean this_present_serverError = true && this.isSetServerError();
      boolean that_present_serverError = true && that.isSetServerError();
      if (this_present_serverError || that_present_serverError) {
        if (!(this_present_serverError && that_present_serverError))
          return false;
        if (!this.serverError.equals(that.serverError))
          return false;
      }

      return true;
    }

    @Override
    public int hashCode() {
      return 0;
    }

    @Override
    public int compareTo(updateImageVersion_result other) {
      if (!getClass().equals(other.getClass())) {
        return getClass().getName().compareTo(other.getClass().getName());
      }

      int lastComparison = 0;

      lastComparison = Boolean.valueOf(isSetAuthError()).compareTo(other.isSetAuthError());
      if (lastComparison != 0) {
        return lastComparison;
      }
      if (isSetAuthError()) {
        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.authError, other.authError);
        if (lastComparison != 0) {
          return lastComparison;
        }
      }
      lastComparison = Boolean.valueOf(isSetNotFound()).compareTo(other.isSetNotFound());
      if (lastComparison != 0) {
        return lastComparison;
      }
      if (isSetNotFound()) {
        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.notFound, other.notFound);
        if (lastComparison != 0) {
          return lastComparison;
        }
      }
      lastComparison = Boolean.valueOf(isSetImgError()).compareTo(other.isSetImgError());
      if (lastComparison != 0) {
        return lastComparison;
      }
      if (isSetImgError()) {
        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.imgError, other.imgError);
        if (lastComparison != 0) {
          return lastComparison;
        }
      }
      lastComparison = Boolean.valueOf(isSetServerError()).compareTo(other.isSetServerError());
      if (lastComparison != 0) {
        return lastComparison;
      }
      if (isSetServerError()) {
        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.serverError, other.serverError);
        if (lastComparison != 0) {
          return lastComparison;
        }
      }
      return 0;
    }

    public _Fields fieldForId(int fieldId) {
      return _Fields.findByThriftId(fieldId);
    }

    public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
      schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
    }

    public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
      schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
      }

    @Override
    public String toString() {
      StringBuilder sb = new StringBuilder("updateImageVersion_result(");
      boolean first = true;

      sb.append("authError:");
      if (this.authError == null) {
        sb.append("null");
      } else {
        sb.append(this.authError);
      }
      first = false;
      if (!first) sb.append(", ");
      sb.append("notFound:");
      if (this.notFound == null) {
        sb.append("null");
      } else {
        sb.append(this.notFound);
      }
      first = false;
      if (!first) sb.append(", ");
      sb.append("imgError:");
      if (this.imgError == null) {
        sb.append("null");
      } else {
        sb.append(this.imgError);
      }
      first = false;
      if (!first) sb.append(", ");
      sb.append("serverError:");
      if (this.serverError == null) {
        sb.append("null");
      } else {
        sb.append(this.serverError);
      }
      first = false;
      sb.append(")");
      return sb.toString();
    }

    public void validate() throws org.apache.thrift.TException {
      // check for required fields
      // check for sub-struct validity
    }

    private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
      try {
        write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
      } catch (org.apache.thrift.TException te) {
        throw new java.io.IOException(te);
      }
    }

    private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
      try {
        read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
      } catch (org.apache.thrift.TException te) {
        throw new java.io.IOException(te);
      }
    }

    private static class updateImageVersion_resultStandardSchemeFactory implements SchemeFactory {
      public updateImageVersion_resultStandardScheme getScheme() {
        return new updateImageVersion_resultStandardScheme();
      }
    }

    private static class updateImageVersion_resultStandardScheme extends StandardScheme<updateImageVersion_result> {

      public void read(org.apache.thrift.protocol.TProtocol iprot, updateImageVersion_result struct) throws org.apache.thrift.TException {
        org.apache.thrift.protocol.TField schemeField;
        iprot.readStructBegin();
        while (true)
        {
          schemeField = iprot.readFieldBegin();
          if (schemeField.type == org.apache.thrift.protocol.TType.STOP) { 
            break;
          }
          switch (schemeField.id) {
            case 1: // AUTH_ERROR
              if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
                struct.authError = new TAuthorizationException();
                struct.authError.read(iprot);
                struct.setAuthErrorIsSet(true);
              } else { 
                org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
              }
              break;
            case 2: // NOT_FOUND
              if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
                struct.notFound = new TNotFoundException();
                struct.notFound.read(iprot);
                struct.setNotFoundIsSet(true);
              } else { 
                org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
              }
              break;
            case 3: // IMG_ERROR
              if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
                struct.imgError = new TImageDataException();
                struct.imgError.read(iprot);
                struct.setImgErrorIsSet(true);
              } else { 
                org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
              }
              break;
            case 4: // SERVER_ERROR
              if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
                struct.serverError = new TInternalServerError();
                struct.serverError.read(iprot);
                struct.setServerErrorIsSet(true);
              } else { 
                org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
              }
              break;
            default:
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
          }
          iprot.readFieldEnd();
        }
        iprot.readStructEnd();

        // check for required fields of primitive type, which can't be checked in the validate method
        struct.validate();
      }

      public void write(org.apache.thrift.protocol.TProtocol oprot, updateImageVersion_result struct) throws org.apache.thrift.TException {
        struct.validate();

        oprot.writeStructBegin(STRUCT_DESC);
        if (struct.authError != null) {
          oprot.writeFieldBegin(AUTH_ERROR_FIELD_DESC);
          struct.authError.write(oprot);
          oprot.writeFieldEnd();
        }
        if (struct.notFound != null) {
          oprot.writeFieldBegin(NOT_FOUND_FIELD_DESC);
          struct.notFound.write(oprot);
          oprot.writeFieldEnd();
        }
        if (struct.imgError != null) {
          oprot.writeFieldBegin(IMG_ERROR_FIELD_DESC);
          struct.imgError.write(oprot);
          oprot.writeFieldEnd();
        }
        if (struct.serverError != null) {
          oprot.writeFieldBegin(SERVER_ERROR_FIELD_DESC);
          struct.serverError.write(oprot);
          oprot.writeFieldEnd();
        }
        oprot.writeFieldStop();
        oprot.writeStructEnd();
      }

    }

    private static class updateImageVersion_resultTupleSchemeFactory implements SchemeFactory {
      public updateImageVersion_resultTupleScheme getScheme() {
        return new updateImageVersion_resultTupleScheme();
      }
    }

    private static class updateImageVersion_resultTupleScheme extends TupleScheme<updateImageVersion_result> {

      @Override
      public void write(org.apache.thrift.protocol.TProtocol prot, updateImageVersion_result struct) throws org.apache.thrift.TException {
        TTupleProtocol oprot = (TTupleProtocol) prot;
        BitSet optionals = new BitSet();
        if (struct.isSetAuthError()) {
          optionals.set(0);
        }
        if (struct.isSetNotFound()) {
          optionals.set(1);
        }
        if (struct.isSetImgError()) {
          optionals.set(2);
        }
        if (struct.isSetServerError()) {
          optionals.set(3);
        }
        oprot.writeBitSet(optionals, 4);
        if (struct.isSetAuthError()) {
          struct.authError.write(oprot);
        }
        if (struct.isSetNotFound()) {
          struct.notFound.write(oprot);
        }
        if (struct.isSetImgError()) {
          struct.imgError.write(oprot);
        }
        if (struct.isSetServerError()) {
          struct.serverError.write(oprot);
        }
      }

      @Override
      public void read(org.apache.thrift.protocol.TProtocol prot, updateImageVersion_result struct) throws org.apache.thrift.TException {
        TTupleProtocol iprot = (TTupleProtocol) prot;
        BitSet incoming = iprot.readBitSet(4);
        if (incoming.get(0)) {
          struct.authError = new TAuthorizationException();
          struct.authError.read(iprot);
          struct.setAuthErrorIsSet(true);
        }
        if (incoming.get(1)) {
          struct.notFound = new TNotFoundException();
          struct.notFound.read(iprot);
          struct.setNotFoundIsSet(true);
        }
        if (incoming.get(2)) {
          struct.imgError = new TImageDataException();
          struct.imgError.read(iprot);
          struct.setImgErrorIsSet(true);
        }
        if (incoming.get(3)) {
          struct.serverError = new TInternalServerError();
          struct.serverError.read(iprot);
          struct.setServerErrorIsSet(true);
        }
      }
    }

  }

  public static class deleteImageVersion_args implements org.apache.thrift.TBase<deleteImageVersion_args, deleteImageVersion_args._Fields>, java.io.Serializable, Cloneable, Comparable<deleteImageVersion_args>   {
    private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("deleteImageVersion_args");

    private static final org.apache.thrift.protocol.TField USER_TOKEN_FIELD_DESC = new org.apache.thrift.protocol.TField("userToken", org.apache.thrift.protocol.TType.STRING, (short)1);
    private static final org.apache.thrift.protocol.TField IMAGE_VERSION_ID_FIELD_DESC = new org.apache.thrift.protocol.TField("imageVersionId", org.apache.thrift.protocol.TType.STRING, (short)2);

    private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
    static {
      schemes.put(StandardScheme.class, new deleteImageVersion_argsStandardSchemeFactory());
      schemes.put(TupleScheme.class, new deleteImageVersion_argsTupleSchemeFactory());
    }

    public String userToken; // required
    public String imageVersionId; // required

    /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
    public enum _Fields implements org.apache.thrift.TFieldIdEnum {
      USER_TOKEN((short)1, "userToken"),
      IMAGE_VERSION_ID((short)2, "imageVersionId");

      private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();

      static {
        for (_Fields field : EnumSet.allOf(_Fields.class)) {
          byName.put(field.getFieldName(), field);
        }
      }

      /**
       * Find the _Fields constant that matches fieldId, or null if its not found.
       */
      public static _Fields findByThriftId(int fieldId) {
        switch(fieldId) {
          case 1: // USER_TOKEN
            return USER_TOKEN;
          case 2: // IMAGE_VERSION_ID
            return IMAGE_VERSION_ID;
          default:
            return null;
        }
      }

      /**
       * Find the _Fields constant that matches fieldId, throwing an exception
       * if it is not found.
       */
      public static _Fields findByThriftIdOrThrow(int fieldId) {
        _Fields fields = findByThriftId(fieldId);
        if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
        return fields;
      }

      /**
       * Find the _Fields constant that matches name, or null if its not found.
       */
      public static _Fields findByName(String name) {
        return byName.get(name);
      }

      private final short _thriftId;
      private final String _fieldName;

      _Fields(short thriftId, String fieldName) {
        _thriftId = thriftId;
        _fieldName = fieldName;
      }

      public short getThriftFieldId() {
        return _thriftId;
      }

      public String getFieldName() {
        return _fieldName;
      }
    }

    // isset id assignments
    public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
    static {
      Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
      tmpMap.put(_Fields.USER_TOKEN, new org.apache.thrift.meta_data.FieldMetaData("userToken", org.apache.thrift.TFieldRequirementType.DEFAULT, 
          new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING          , "Token")));
      tmpMap.put(_Fields.IMAGE_VERSION_ID, new org.apache.thrift.meta_data.FieldMetaData("imageVersionId", org.apache.thrift.TFieldRequirementType.DEFAULT, 
          new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING          , "UUID")));
      metaDataMap = Collections.unmodifiableMap(tmpMap);
      org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(deleteImageVersion_args.class, metaDataMap);
    }

    public deleteImageVersion_args() {
    }

    public deleteImageVersion_args(
      String userToken,
      String imageVersionId)
    {
      this();
      this.userToken = userToken;
      this.imageVersionId = imageVersionId;
    }

    /**
     * Performs a deep copy on <i>other</i>.
     */
    public deleteImageVersion_args(deleteImageVersion_args other) {
      if (other.isSetUserToken()) {
        this.userToken = other.userToken;
      }
      if (other.isSetImageVersionId()) {
        this.imageVersionId = other.imageVersionId;
      }
    }

    public deleteImageVersion_args deepCopy() {
      return new deleteImageVersion_args(this);
    }

    @Override
    public void clear() {
      this.userToken = null;
      this.imageVersionId = null;
    }

    public String getUserToken() {
      return this.userToken;
    }

    public deleteImageVersion_args setUserToken(String userToken) {
      this.userToken = userToken;
      return this;
    }

    public void unsetUserToken() {
      this.userToken = null;
    }

    /** Returns true if field userToken is set (has been assigned a value) and false otherwise */
    public boolean isSetUserToken() {
      return this.userToken != null;
    }

    public void setUserTokenIsSet(boolean value) {
      if (!value) {
        this.userToken = null;
      }
    }

    public String getImageVersionId() {
      return this.imageVersionId;
    }

    public deleteImageVersion_args setImageVersionId(String imageVersionId) {
      this.imageVersionId = imageVersionId;
      return this;
    }

    public void unsetImageVersionId() {
      this.imageVersionId = null;
    }

    /** Returns true if field imageVersionId is set (has been assigned a value) and false otherwise */
    public boolean isSetImageVersionId() {
      return this.imageVersionId != null;
    }

    public void setImageVersionIdIsSet(boolean value) {
      if (!value) {
        this.imageVersionId = null;
      }
    }

    public void setFieldValue(_Fields field, Object value) {
      switch (field) {
      case USER_TOKEN:
        if (value == null) {
          unsetUserToken();
        } else {
          setUserToken((String)value);
        }
        break;

      case IMAGE_VERSION_ID:
        if (value == null) {
          unsetImageVersionId();
        } else {
          setImageVersionId((String)value);
        }
        break;

      }
    }

    public Object getFieldValue(_Fields field) {
      switch (field) {
      case USER_TOKEN:
        return getUserToken();

      case IMAGE_VERSION_ID:
        return getImageVersionId();

      }
      throw new IllegalStateException();
    }

    /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
    public boolean isSet(_Fields field) {
      if (field == null) {
        throw new IllegalArgumentException();
      }

      switch (field) {
      case USER_TOKEN:
        return isSetUserToken();
      case IMAGE_VERSION_ID:
        return isSetImageVersionId();
      }
      throw new IllegalStateException();
    }

    @Override
    public boolean equals(Object that) {
      if (that == null)
        return false;
      if (that instanceof deleteImageVersion_args)
        return this.equals((deleteImageVersion_args)that);
      return false;
    }

    public boolean equals(deleteImageVersion_args that) {
      if (that == null)
        return false;

      boolean this_present_userToken = true && this.isSetUserToken();
      boolean that_present_userToken = true && that.isSetUserToken();
      if (this_present_userToken || that_present_userToken) {
        if (!(this_present_userToken && that_present_userToken))
          return false;
        if (!this.userToken.equals(that.userToken))
          return false;
      }

      boolean this_present_imageVersionId = true && this.isSetImageVersionId();
      boolean that_present_imageVersionId = true && that.isSetImageVersionId();
      if (this_present_imageVersionId || that_present_imageVersionId) {
        if (!(this_present_imageVersionId && that_present_imageVersionId))
          return false;
        if (!this.imageVersionId.equals(that.imageVersionId))
          return false;
      }

      return true;
    }

    @Override
    public int hashCode() {
      return 0;
    }

    @Override
    public int compareTo(deleteImageVersion_args other) {
      if (!getClass().equals(other.getClass())) {
        return getClass().getName().compareTo(other.getClass().getName());
      }

      int lastComparison = 0;

      lastComparison = Boolean.valueOf(isSetUserToken()).compareTo(other.isSetUserToken());
      if (lastComparison != 0) {
        return lastComparison;
      }
      if (isSetUserToken()) {
        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.userToken, other.userToken);
        if (lastComparison != 0) {
          return lastComparison;
        }
      }
      lastComparison = Boolean.valueOf(isSetImageVersionId()).compareTo(other.isSetImageVersionId());
      if (lastComparison != 0) {
        return lastComparison;
      }
      if (isSetImageVersionId()) {
        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.imageVersionId, other.imageVersionId);
        if (lastComparison != 0) {
          return lastComparison;
        }
      }
      return 0;
    }

    public _Fields fieldForId(int fieldId) {
      return _Fields.findByThriftId(fieldId);
    }

    public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
      schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
    }

    public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
      schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
    }

    @Override
    public String toString() {
      StringBuilder sb = new StringBuilder("deleteImageVersion_args(");
      boolean first = true;

      sb.append("userToken:");
      if (this.userToken == null) {
        sb.append("null");
      } else {
        sb.append(this.userToken);
      }
      first = false;
      if (!first) sb.append(", ");
      sb.append("imageVersionId:");
      if (this.imageVersionId == null) {
        sb.append("null");
      } else {
        sb.append(this.imageVersionId);
      }
      first = false;
      sb.append(")");
      return sb.toString();
    }

    public void validate() throws org.apache.thrift.TException {
      // check for required fields
      // check for sub-struct validity
    }

    private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
      try {
        write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
      } catch (org.apache.thrift.TException te) {
        throw new java.io.IOException(te);
      }
    }

    private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
      try {
        read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
      } catch (org.apache.thrift.TException te) {
        throw new java.io.IOException(te);
      }
    }

    private static class deleteImageVersion_argsStandardSchemeFactory implements SchemeFactory {
      public deleteImageVersion_argsStandardScheme getScheme() {
        return new deleteImageVersion_argsStandardScheme();
      }
    }

    private static class deleteImageVersion_argsStandardScheme extends StandardScheme<deleteImageVersion_args> {

      public void read(org.apache.thrift.protocol.TProtocol iprot, deleteImageVersion_args struct) throws org.apache.thrift.TException {
        org.apache.thrift.protocol.TField schemeField;
        iprot.readStructBegin();
        while (true)
        {
          schemeField = iprot.readFieldBegin();
          if (schemeField.type == org.apache.thrift.protocol.TType.STOP) { 
            break;
          }
          switch (schemeField.id) {
            case 1: // USER_TOKEN
              if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
                struct.userToken = iprot.readString();
                struct.setUserTokenIsSet(true);
              } else { 
                org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
              }
              break;
            case 2: // IMAGE_VERSION_ID
              if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
                struct.imageVersionId = iprot.readString();
                struct.setImageVersionIdIsSet(true);
              } else { 
                org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
              }
              break;
            default:
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
          }
          iprot.readFieldEnd();
        }
        iprot.readStructEnd();

        // check for required fields of primitive type, which can't be checked in the validate method
        struct.validate();
      }

      public void write(org.apache.thrift.protocol.TProtocol oprot, deleteImageVersion_args struct) throws org.apache.thrift.TException {
        struct.validate();

        oprot.writeStructBegin(STRUCT_DESC);
        if (struct.userToken != null) {
          oprot.writeFieldBegin(USER_TOKEN_FIELD_DESC);
          oprot.writeString(struct.userToken);
          oprot.writeFieldEnd();
        }
        if (struct.imageVersionId != null) {
          oprot.writeFieldBegin(IMAGE_VERSION_ID_FIELD_DESC);
          oprot.writeString(struct.imageVersionId);
          oprot.writeFieldEnd();
        }
        oprot.writeFieldStop();
        oprot.writeStructEnd();
      }

    }

    private static class deleteImageVersion_argsTupleSchemeFactory implements SchemeFactory {
      public deleteImageVersion_argsTupleScheme getScheme() {
        return new deleteImageVersion_argsTupleScheme();
      }
    }

    private static class deleteImageVersion_argsTupleScheme extends TupleScheme<deleteImageVersion_args> {

      @Override
      public void write(org.apache.thrift.protocol.TProtocol prot, deleteImageVersion_args struct) throws org.apache.thrift.TException {
        TTupleProtocol oprot = (TTupleProtocol) prot;
        BitSet optionals = new BitSet();
        if (struct.isSetUserToken()) {
          optionals.set(0);
        }
        if (struct.isSetImageVersionId()) {
          optionals.set(1);
        }
        oprot.writeBitSet(optionals, 2);
        if (struct.isSetUserToken()) {
          oprot.writeString(struct.userToken);
        }
        if (struct.isSetImageVersionId()) {
          oprot.writeString(struct.imageVersionId);
        }
      }

      @Override
      public void read(org.apache.thrift.protocol.TProtocol prot, deleteImageVersion_args struct) throws org.apache.thrift.TException {
        TTupleProtocol iprot = (TTupleProtocol) prot;
        BitSet incoming = iprot.readBitSet(2);
        if (incoming.get(0)) {
          struct.userToken = iprot.readString();
          struct.setUserTokenIsSet(true);
        }
        if (incoming.get(1)) {
          struct.imageVersionId = iprot.readString();
          struct.setImageVersionIdIsSet(true);
        }
      }
    }

  }

  public static class deleteImageVersion_result implements org.apache.thrift.TBase<deleteImageVersion_result, deleteImageVersion_result._Fields>, java.io.Serializable, Cloneable, Comparable<deleteImageVersion_result>   {
    private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("deleteImageVersion_result");

    private static final org.apache.thrift.protocol.TField AUTH_ERROR_FIELD_DESC = new org.apache.thrift.protocol.TField("authError", org.apache.thrift.protocol.TType.STRUCT, (short)1);
    private static final org.apache.thrift.protocol.TField NOT_FOUND_FIELD_DESC = new org.apache.thrift.protocol.TField("notFound", org.apache.thrift.protocol.TType.STRUCT, (short)2);
    private static final org.apache.thrift.protocol.TField SERVER_ERROR_FIELD_DESC = new org.apache.thrift.protocol.TField("serverError", org.apache.thrift.protocol.TType.STRUCT, (short)3);

    private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
    static {
      schemes.put(StandardScheme.class, new deleteImageVersion_resultStandardSchemeFactory());
      schemes.put(TupleScheme.class, new deleteImageVersion_resultTupleSchemeFactory());
    }

    public TAuthorizationException authError; // required
    public TNotFoundException notFound; // required
    public TInternalServerError serverError; // required

    /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
    public enum _Fields implements org.apache.thrift.TFieldIdEnum {
      AUTH_ERROR((short)1, "authError"),
      NOT_FOUND((short)2, "notFound"),
      SERVER_ERROR((short)3, "serverError");

      private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();

      static {
        for (_Fields field : EnumSet.allOf(_Fields.class)) {
          byName.put(field.getFieldName(), field);
        }
      }

      /**
       * Find the _Fields constant that matches fieldId, or null if its not found.
       */
      public static _Fields findByThriftId(int fieldId) {
        switch(fieldId) {
          case 1: // AUTH_ERROR
            return AUTH_ERROR;
          case 2: // NOT_FOUND
            return NOT_FOUND;
          case 3: // SERVER_ERROR
            return SERVER_ERROR;
          default:
            return null;
        }
      }

      /**
       * Find the _Fields constant that matches fieldId, throwing an exception
       * if it is not found.
       */
      public static _Fields findByThriftIdOrThrow(int fieldId) {
        _Fields fields = findByThriftId(fieldId);
        if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
        return fields;
      }

      /**
       * Find the _Fields constant that matches name, or null if its not found.
       */
      public static _Fields findByName(String name) {
        return byName.get(name);
      }

      private final short _thriftId;
      private final String _fieldName;

      _Fields(short thriftId, String fieldName) {
        _thriftId = thriftId;
        _fieldName = fieldName;
      }

      public short getThriftFieldId() {
        return _thriftId;
      }

      public String getFieldName() {
        return _fieldName;
      }
    }

    // isset id assignments
    public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
    static {
      Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
      tmpMap.put(_Fields.AUTH_ERROR, new org.apache.thrift.meta_data.FieldMetaData("authError", org.apache.thrift.TFieldRequirementType.DEFAULT, 
          new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT)));
      tmpMap.put(_Fields.NOT_FOUND, new org.apache.thrift.meta_data.FieldMetaData("notFound", org.apache.thrift.TFieldRequirementType.DEFAULT, 
          new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT)));
      tmpMap.put(_Fields.SERVER_ERROR, new org.apache.thrift.meta_data.FieldMetaData("serverError", org.apache.thrift.TFieldRequirementType.DEFAULT, 
          new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT)));
      metaDataMap = Collections.unmodifiableMap(tmpMap);
      org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(deleteImageVersion_result.class, metaDataMap);
    }

    public deleteImageVersion_result() {
    }

    public deleteImageVersion_result(
      TAuthorizationException authError,
      TNotFoundException notFound,
      TInternalServerError serverError)
    {
      this();
      this.authError = authError;
      this.notFound = notFound;
      this.serverError = serverError;
    }

    /**
     * Performs a deep copy on <i>other</i>.
     */
    public deleteImageVersion_result(deleteImageVersion_result other) {
      if (other.isSetAuthError()) {
        this.authError = new TAuthorizationException(other.authError);
      }
      if (other.isSetNotFound()) {
        this.notFound = new TNotFoundException(other.notFound);
      }
      if (other.isSetServerError()) {
        this.serverError = new TInternalServerError(other.serverError);
      }
    }

    public deleteImageVersion_result deepCopy() {
      return new deleteImageVersion_result(this);
    }

    @Override
    public void clear() {
      this.authError = null;
      this.notFound = null;
      this.serverError = null;
    }

    public TAuthorizationException getAuthError() {
      return this.authError;
    }

    public deleteImageVersion_result setAuthError(TAuthorizationException authError) {
      this.authError = authError;
      return this;
    }

    public void unsetAuthError() {
      this.authError = null;
    }

    /** Returns true if field authError is set (has been assigned a value) and false otherwise */
    public boolean isSetAuthError() {
      return this.authError != null;
    }

    public void setAuthErrorIsSet(boolean value) {
      if (!value) {
        this.authError = null;
      }
    }

    public TNotFoundException getNotFound() {
      return this.notFound;
    }

    public deleteImageVersion_result setNotFound(TNotFoundException notFound) {
      this.notFound = notFound;
      return this;
    }

    public void unsetNotFound() {
      this.notFound = null;
    }

    /** Returns true if field notFound is set (has been assigned a value) and false otherwise */
    public boolean isSetNotFound() {
      return this.notFound != null;
    }

    public void setNotFoundIsSet(boolean value) {
      if (!value) {
        this.notFound = null;
      }
    }

    public TInternalServerError getServerError() {
      return this.serverError;
    }

    public deleteImageVersion_result setServerError(TInternalServerError serverError) {
      this.serverError = serverError;
      return this;
    }

    public void unsetServerError() {
      this.serverError = null;
    }

    /** Returns true if field serverError is set (has been assigned a value) and false otherwise */
    public boolean isSetServerError() {
      return this.serverError != null;
    }

    public void setServerErrorIsSet(boolean value) {
      if (!value) {
        this.serverError = null;
      }
    }

    public void setFieldValue(_Fields field, Object value) {
      switch (field) {
      case AUTH_ERROR:
        if (value == null) {
          unsetAuthError();
        } else {
          setAuthError((TAuthorizationException)value);
        }
        break;

      case NOT_FOUND:
        if (value == null) {
          unsetNotFound();
        } else {
          setNotFound((TNotFoundException)value);
        }
        break;

      case SERVER_ERROR:
        if (value == null) {
          unsetServerError();
        } else {
          setServerError((TInternalServerError)value);
        }
        break;

      }
    }

    public Object getFieldValue(_Fields field) {
      switch (field) {
      case AUTH_ERROR:
        return getAuthError();

      case NOT_FOUND:
        return getNotFound();

      case SERVER_ERROR:
        return getServerError();

      }
      throw new IllegalStateException();
    }

    /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
    public boolean isSet(_Fields field) {
      if (field == null) {
        throw new IllegalArgumentException();
      }

      switch (field) {
      case AUTH_ERROR:
        return isSetAuthError();
      case NOT_FOUND:
        return isSetNotFound();
      case SERVER_ERROR:
        return isSetServerError();
      }
      throw new IllegalStateException();
    }

    @Override
    public boolean equals(Object that) {
      if (that == null)
        return false;
      if (that instanceof deleteImageVersion_result)
        return this.equals((deleteImageVersion_result)that);
      return false;
    }

    public boolean equals(deleteImageVersion_result that) {
      if (that == null)
        return false;

      boolean this_present_authError = true && this.isSetAuthError();
      boolean that_present_authError = true && that.isSetAuthError();
      if (this_present_authError || that_present_authError) {
        if (!(this_present_authError && that_present_authError))
          return false;
        if (!this.authError.equals(that.authError))
          return false;
      }

      boolean this_present_notFound = true && this.isSetNotFound();
      boolean that_present_notFound = true && that.isSetNotFound();
      if (this_present_notFound || that_present_notFound) {
        if (!(this_present_notFound && that_present_notFound))
          return false;
        if (!this.notFound.equals(that.notFound))
          return false;
      }

      boolean this_present_serverError = true && this.isSetServerError();
      boolean that_present_serverError = true && that.isSetServerError();
      if (this_present_serverError || that_present_serverError) {
        if (!(this_present_serverError && that_present_serverError))
          return false;
        if (!this.serverError.equals(that.serverError))
          return false;
      }

      return true;
    }

    @Override
    public int hashCode() {
      return 0;
    }

    @Override
    public int compareTo(deleteImageVersion_result other) {
      if (!getClass().equals(other.getClass())) {
        return getClass().getName().compareTo(other.getClass().getName());
      }

      int lastComparison = 0;

      lastComparison = Boolean.valueOf(isSetAuthError()).compareTo(other.isSetAuthError());
      if (lastComparison != 0) {
        return lastComparison;
      }
      if (isSetAuthError()) {
        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.authError, other.authError);
        if (lastComparison != 0) {
          return lastComparison;
        }
      }
      lastComparison = Boolean.valueOf(isSetNotFound()).compareTo(other.isSetNotFound());
      if (lastComparison != 0) {
        return lastComparison;
      }
      if (isSetNotFound()) {
        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.notFound, other.notFound);
        if (lastComparison != 0) {
          return lastComparison;
        }
      }
      lastComparison = Boolean.valueOf(isSetServerError()).compareTo(other.isSetServerError());
      if (lastComparison != 0) {
        return lastComparison;
      }
      if (isSetServerError()) {
        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.serverError, other.serverError);
        if (lastComparison != 0) {
          return lastComparison;
        }
      }
      return 0;
    }

    public _Fields fieldForId(int fieldId) {
      return _Fields.findByThriftId(fieldId);
    }

    public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
      schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
    }

    public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
      schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
      }

    @Override
    public String toString() {
      StringBuilder sb = new StringBuilder("deleteImageVersion_result(");
      boolean first = true;

      sb.append("authError:");
      if (this.authError == null) {
        sb.append("null");
      } else {
        sb.append(this.authError);
      }
      first = false;
      if (!first) sb.append(", ");
      sb.append("notFound:");
      if (this.notFound == null) {
        sb.append("null");
      } else {
        sb.append(this.notFound);
      }
      first = false;
      if (!first) sb.append(", ");
      sb.append("serverError:");
      if (this.serverError == null) {
        sb.append("null");
      } else {
        sb.append(this.serverError);
      }
      first = false;
      sb.append(")");
      return sb.toString();
    }

    public void validate() throws org.apache.thrift.TException {
      // check for required fields
      // check for sub-struct validity
    }

    private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
      try {
        write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
      } catch (org.apache.thrift.TException te) {
        throw new java.io.IOException(te);
      }
    }

    private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
      try {
        read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
      } catch (org.apache.thrift.TException te) {
        throw new java.io.IOException(te);
      }
    }

    private static class deleteImageVersion_resultStandardSchemeFactory implements SchemeFactory {
      public deleteImageVersion_resultStandardScheme getScheme() {
        return new deleteImageVersion_resultStandardScheme();
      }
    }

    private static class deleteImageVersion_resultStandardScheme extends StandardScheme<deleteImageVersion_result> {

      public void read(org.apache.thrift.protocol.TProtocol iprot, deleteImageVersion_result struct) throws org.apache.thrift.TException {
        org.apache.thrift.protocol.TField schemeField;
        iprot.readStructBegin();
        while (true)
        {
          schemeField = iprot.readFieldBegin();
          if (schemeField.type == org.apache.thrift.protocol.TType.STOP) { 
            break;
          }
          switch (schemeField.id) {
            case 1: // AUTH_ERROR
              if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
                struct.authError = new TAuthorizationException();
                struct.authError.read(iprot);
                struct.setAuthErrorIsSet(true);
              } else { 
                org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
              }
              break;
            case 2: // NOT_FOUND
              if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
                struct.notFound = new TNotFoundException();
                struct.notFound.read(iprot);
                struct.setNotFoundIsSet(true);
              } else { 
                org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
              }
              break;
            case 3: // SERVER_ERROR
              if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
                struct.serverError = new TInternalServerError();
                struct.serverError.read(iprot);
                struct.setServerErrorIsSet(true);
              } else { 
                org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
              }
              break;
            default:
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
          }
          iprot.readFieldEnd();
        }
        iprot.readStructEnd();

        // check for required fields of primitive type, which can't be checked in the validate method
        struct.validate();
      }

      public void write(org.apache.thrift.protocol.TProtocol oprot, deleteImageVersion_result struct) throws org.apache.thrift.TException {
        struct.validate();

        oprot.writeStructBegin(STRUCT_DESC);
        if (struct.authError != null) {
          oprot.writeFieldBegin(AUTH_ERROR_FIELD_DESC);
          struct.authError.write(oprot);
          oprot.writeFieldEnd();
        }
        if (struct.notFound != null) {
          oprot.writeFieldBegin(NOT_FOUND_FIELD_DESC);
          struct.notFound.write(oprot);
          oprot.writeFieldEnd();
        }
        if (struct.serverError != null) {
          oprot.writeFieldBegin(SERVER_ERROR_FIELD_DESC);
          struct.serverError.write(oprot);
          oprot.writeFieldEnd();
        }
        oprot.writeFieldStop();
        oprot.writeStructEnd();
      }

    }

    private static class deleteImageVersion_resultTupleSchemeFactory implements SchemeFactory {
      public deleteImageVersion_resultTupleScheme getScheme() {
        return new deleteImageVersion_resultTupleScheme();
      }
    }

    private static class deleteImageVersion_resultTupleScheme extends TupleScheme<deleteImageVersion_result> {

      @Override
      public void write(org.apache.thrift.protocol.TProtocol prot, deleteImageVersion_result struct) throws org.apache.thrift.TException {
        TTupleProtocol oprot = (TTupleProtocol) prot;
        BitSet optionals = new BitSet();
        if (struct.isSetAuthError()) {
          optionals.set(0);
        }
        if (struct.isSetNotFound()) {
          optionals.set(1);
        }
        if (struct.isSetServerError()) {
          optionals.set(2);
        }
        oprot.writeBitSet(optionals, 3);
        if (struct.isSetAuthError()) {
          struct.authError.write(oprot);
        }
        if (struct.isSetNotFound()) {
          struct.notFound.write(oprot);
        }
        if (struct.isSetServerError()) {
          struct.serverError.write(oprot);
        }
      }

      @Override
      public void read(org.apache.thrift.protocol.TProtocol prot, deleteImageVersion_result struct) throws org.apache.thrift.TException {
        TTupleProtocol iprot = (TTupleProtocol) prot;
        BitSet incoming = iprot.readBitSet(3);
        if (incoming.get(0)) {
          struct.authError = new TAuthorizationException();
          struct.authError.read(iprot);
          struct.setAuthErrorIsSet(true);
        }
        if (incoming.get(1)) {
          struct.notFound = new TNotFoundException();
          struct.notFound.read(iprot);
          struct.setNotFoundIsSet(true);
        }
        if (incoming.get(2)) {
          struct.serverError = new TInternalServerError();
          struct.serverError.read(iprot);
          struct.setServerErrorIsSet(true);
        }
      }
    }

  }

  public static class writeImagePermissions_args implements org.apache.thrift.TBase<writeImagePermissions_args, writeImagePermissions_args._Fields>, java.io.Serializable, Cloneable, Comparable<writeImagePermissions_args>   {
    private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("writeImagePermissions_args");

    private static final org.apache.thrift.protocol.TField USER_TOKEN_FIELD_DESC = new org.apache.thrift.protocol.TField("userToken", org.apache.thrift.protocol.TType.STRING, (short)1);
    private static final org.apache.thrift.protocol.TField IMAGE_BASE_ID_FIELD_DESC = new org.apache.thrift.protocol.TField("imageBaseId", org.apache.thrift.protocol.TType.STRING, (short)2);
    private static final org.apache.thrift.protocol.TField PERMISSIONS_FIELD_DESC = new org.apache.thrift.protocol.TField("permissions", org.apache.thrift.protocol.TType.MAP, (short)3);

    private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
    static {
      schemes.put(StandardScheme.class, new writeImagePermissions_argsStandardSchemeFactory());
      schemes.put(TupleScheme.class, new writeImagePermissions_argsTupleSchemeFactory());
    }

    public String userToken; // required
    public String imageBaseId; // required
    public Map<String,ImagePermissions> permissions; // required

    /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
    public enum _Fields implements org.apache.thrift.TFieldIdEnum {
      USER_TOKEN((short)1, "userToken"),
      IMAGE_BASE_ID((short)2, "imageBaseId"),
      PERMISSIONS((short)3, "permissions");

      private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();

      static {
        for (_Fields field : EnumSet.allOf(_Fields.class)) {
          byName.put(field.getFieldName(), field);
        }
      }

      /**
       * Find the _Fields constant that matches fieldId, or null if its not found.
       */
      public static _Fields findByThriftId(int fieldId) {
        switch(fieldId) {
          case 1: // USER_TOKEN
            return USER_TOKEN;
          case 2: // IMAGE_BASE_ID
            return IMAGE_BASE_ID;
          case 3: // PERMISSIONS
            return PERMISSIONS;
          default:
            return null;
        }
      }

      /**
       * Find the _Fields constant that matches fieldId, throwing an exception
       * if it is not found.
       */
      public static _Fields findByThriftIdOrThrow(int fieldId) {
        _Fields fields = findByThriftId(fieldId);
        if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
        return fields;
      }

      /**
       * Find the _Fields constant that matches name, or null if its not found.
       */
      public static _Fields findByName(String name) {
        return byName.get(name);
      }

      private final short _thriftId;
      private final String _fieldName;

      _Fields(short thriftId, String fieldName) {
        _thriftId = thriftId;
        _fieldName = fieldName;
      }

      public short getThriftFieldId() {
        return _thriftId;
      }

      public String getFieldName() {
        return _fieldName;
      }
    }

    // isset id assignments
    public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
    static {
      Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
      tmpMap.put(_Fields.USER_TOKEN, new org.apache.thrift.meta_data.FieldMetaData("userToken", org.apache.thrift.TFieldRequirementType.DEFAULT, 
          new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING          , "Token")));
      tmpMap.put(_Fields.IMAGE_BASE_ID, new org.apache.thrift.meta_data.FieldMetaData("imageBaseId", org.apache.thrift.TFieldRequirementType.DEFAULT, 
          new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING          , "UUID")));
      tmpMap.put(_Fields.PERMISSIONS, new org.apache.thrift.meta_data.FieldMetaData("permissions", org.apache.thrift.TFieldRequirementType.DEFAULT, 
          new org.apache.thrift.meta_data.MapMetaData(org.apache.thrift.protocol.TType.MAP, 
              new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING              , "UUID"), 
              new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, ImagePermissions.class))));
      metaDataMap = Collections.unmodifiableMap(tmpMap);
      org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(writeImagePermissions_args.class, metaDataMap);
    }

    public writeImagePermissions_args() {
    }

    public writeImagePermissions_args(
      String userToken,
      String imageBaseId,
      Map<String,ImagePermissions> permissions)
    {
      this();
      this.userToken = userToken;
      this.imageBaseId = imageBaseId;
      this.permissions = permissions;
    }

    /**
     * Performs a deep copy on <i>other</i>.
     */
    public writeImagePermissions_args(writeImagePermissions_args other) {
      if (other.isSetUserToken()) {
        this.userToken = other.userToken;
      }
      if (other.isSetImageBaseId()) {
        this.imageBaseId = other.imageBaseId;
      }
      if (other.isSetPermissions()) {
        Map<String,ImagePermissions> __this__permissions = new HashMap<String,ImagePermissions>(other.permissions.size());
        for (Map.Entry<String, ImagePermissions> other_element : other.permissions.entrySet()) {

          String other_element_key = other_element.getKey();
          ImagePermissions other_element_value = other_element.getValue();

          String __this__permissions_copy_key = other_element_key;

          ImagePermissions __this__permissions_copy_value = new ImagePermissions(other_element_value);

          __this__permissions.put(__this__permissions_copy_key, __this__permissions_copy_value);
        }
        this.permissions = __this__permissions;
      }
    }

    public writeImagePermissions_args deepCopy() {
      return new writeImagePermissions_args(this);
    }

    @Override
    public void clear() {
      this.userToken = null;
      this.imageBaseId = null;
      this.permissions = null;
    }

    public String getUserToken() {
      return this.userToken;
    }

    public writeImagePermissions_args setUserToken(String userToken) {
      this.userToken = userToken;
      return this;
    }

    public void unsetUserToken() {
      this.userToken = null;
    }

    /** Returns true if field userToken is set (has been assigned a value) and false otherwise */
    public boolean isSetUserToken() {
      return this.userToken != null;
    }

    public void setUserTokenIsSet(boolean value) {
      if (!value) {
        this.userToken = null;
      }
    }

    public String getImageBaseId() {
      return this.imageBaseId;
    }

    public writeImagePermissions_args setImageBaseId(String imageBaseId) {
      this.imageBaseId = imageBaseId;
      return this;
    }

    public void unsetImageBaseId() {
      this.imageBaseId = null;
    }

    /** Returns true if field imageBaseId is set (has been assigned a value) and false otherwise */
    public boolean isSetImageBaseId() {
      return this.imageBaseId != null;
    }

    public void setImageBaseIdIsSet(boolean value) {
      if (!value) {
        this.imageBaseId = null;
      }
    }

    public int getPermissionsSize() {
      return (this.permissions == null) ? 0 : this.permissions.size();
    }

    public void putToPermissions(String key, ImagePermissions val) {
      if (this.permissions == null) {
        this.permissions = new HashMap<String,ImagePermissions>();
      }
      this.permissions.put(key, val);
    }

    public Map<String,ImagePermissions> getPermissions() {
      return this.permissions;
    }

    public writeImagePermissions_args setPermissions(Map<String,ImagePermissions> permissions) {
      this.permissions = permissions;
      return this;
    }

    public void unsetPermissions() {
      this.permissions = null;
    }

    /** Returns true if field permissions is set (has been assigned a value) and false otherwise */
    public boolean isSetPermissions() {
      return this.permissions != null;
    }

    public void setPermissionsIsSet(boolean value) {
      if (!value) {
        this.permissions = null;
      }
    }

    public void setFieldValue(_Fields field, Object value) {
      switch (field) {
      case USER_TOKEN:
        if (value == null) {
          unsetUserToken();
        } else {
          setUserToken((String)value);
        }
        break;

      case IMAGE_BASE_ID:
        if (value == null) {
          unsetImageBaseId();
        } else {
          setImageBaseId((String)value);
        }
        break;

      case PERMISSIONS:
        if (value == null) {
          unsetPermissions();
        } else {
          setPermissions((Map<String,ImagePermissions>)value);
        }
        break;

      }
    }

    public Object getFieldValue(_Fields field) {
      switch (field) {
      case USER_TOKEN:
        return getUserToken();

      case IMAGE_BASE_ID:
        return getImageBaseId();

      case PERMISSIONS:
        return getPermissions();

      }
      throw new IllegalStateException();
    }

    /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
    public boolean isSet(_Fields field) {
      if (field == null) {
        throw new IllegalArgumentException();
      }

      switch (field) {
      case USER_TOKEN:
        return isSetUserToken();
      case IMAGE_BASE_ID:
        return isSetImageBaseId();
      case PERMISSIONS:
        return isSetPermissions();
      }
      throw new IllegalStateException();
    }

    @Override
    public boolean equals(Object that) {
      if (that == null)
        return false;
      if (that instanceof writeImagePermissions_args)
        return this.equals((writeImagePermissions_args)that);
      return false;
    }

    public boolean equals(writeImagePermissions_args that) {
      if (that == null)
        return false;

      boolean this_present_userToken = true && this.isSetUserToken();
      boolean that_present_userToken = true && that.isSetUserToken();
      if (this_present_userToken || that_present_userToken) {
        if (!(this_present_userToken && that_present_userToken))
          return false;
        if (!this.userToken.equals(that.userToken))
          return false;
      }

      boolean this_present_imageBaseId = true && this.isSetImageBaseId();
      boolean that_present_imageBaseId = true && that.isSetImageBaseId();
      if (this_present_imageBaseId || that_present_imageBaseId) {
        if (!(this_present_imageBaseId && that_present_imageBaseId))
          return false;
        if (!this.imageBaseId.equals(that.imageBaseId))
          return false;
      }

      boolean this_present_permissions = true && this.isSetPermissions();
      boolean that_present_permissions = true && that.isSetPermissions();
      if (this_present_permissions || that_present_permissions) {
        if (!(this_present_permissions && that_present_permissions))
          return false;
        if (!this.permissions.equals(that.permissions))
          return false;
      }

      return true;
    }

    @Override
    public int hashCode() {
      return 0;
    }

    @Override
    public int compareTo(writeImagePermissions_args other) {
      if (!getClass().equals(other.getClass())) {
        return getClass().getName().compareTo(other.getClass().getName());
      }

      int lastComparison = 0;

      lastComparison = Boolean.valueOf(isSetUserToken()).compareTo(other.isSetUserToken());
      if (lastComparison != 0) {
        return lastComparison;
      }
      if (isSetUserToken()) {
        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.userToken, other.userToken);
        if (lastComparison != 0) {
          return lastComparison;
        }
      }
      lastComparison = Boolean.valueOf(isSetImageBaseId()).compareTo(other.isSetImageBaseId());
      if (lastComparison != 0) {
        return lastComparison;
      }
      if (isSetImageBaseId()) {
        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.imageBaseId, other.imageBaseId);
        if (lastComparison != 0) {
          return lastComparison;
        }
      }
      lastComparison = Boolean.valueOf(isSetPermissions()).compareTo(other.isSetPermissions());
      if (lastComparison != 0) {
        return lastComparison;
      }
      if (isSetPermissions()) {
        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.permissions, other.permissions);
        if (lastComparison != 0) {
          return lastComparison;
        }
      }
      return 0;
    }

    public _Fields fieldForId(int fieldId) {
      return _Fields.findByThriftId(fieldId);
    }

    public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
      schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
    }

    public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
      schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
    }

    @Override
    public String toString() {
      StringBuilder sb = new StringBuilder("writeImagePermissions_args(");
      boolean first = true;

      sb.append("userToken:");
      if (this.userToken == null) {
        sb.append("null");
      } else {
        sb.append(this.userToken);
      }
      first = false;
      if (!first) sb.append(", ");
      sb.append("imageBaseId:");
      if (this.imageBaseId == null) {
        sb.append("null");
      } else {
        sb.append(this.imageBaseId);
      }
      first = false;
      if (!first) sb.append(", ");
      sb.append("permissions:");
      if (this.permissions == null) {
        sb.append("null");
      } else {
        sb.append(this.permissions);
      }
      first = false;
      sb.append(")");
      return sb.toString();
    }

    public void validate() throws org.apache.thrift.TException {
      // check for required fields
      // check for sub-struct validity
    }

    private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
      try {
        write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
      } catch (org.apache.thrift.TException te) {
        throw new java.io.IOException(te);
      }
    }

    private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
      try {
        read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
      } catch (org.apache.thrift.TException te) {
        throw new java.io.IOException(te);
      }
    }

    private static class writeImagePermissions_argsStandardSchemeFactory implements SchemeFactory {
      public writeImagePermissions_argsStandardScheme getScheme() {
        return new writeImagePermissions_argsStandardScheme();
      }
    }

    private static class writeImagePermissions_argsStandardScheme extends StandardScheme<writeImagePermissions_args> {

      public void read(org.apache.thrift.protocol.TProtocol iprot, writeImagePermissions_args struct) throws org.apache.thrift.TException {
        org.apache.thrift.protocol.TField schemeField;
        iprot.readStructBegin();
        while (true)
        {
          schemeField = iprot.readFieldBegin();
          if (schemeField.type == org.apache.thrift.protocol.TType.STOP) { 
            break;
          }
          switch (schemeField.id) {
            case 1: // USER_TOKEN
              if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
                struct.userToken = iprot.readString();
                struct.setUserTokenIsSet(true);
              } else { 
                org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
              }
              break;
            case 2: // IMAGE_BASE_ID
              if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
                struct.imageBaseId = iprot.readString();
                struct.setImageBaseIdIsSet(true);
              } else { 
                org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
              }
              break;
            case 3: // PERMISSIONS
              if (schemeField.type == org.apache.thrift.protocol.TType.MAP) {
                {
                  org.apache.thrift.protocol.TMap _map186 = iprot.readMapBegin();
                  struct.permissions = new HashMap<String,ImagePermissions>(2*_map186.size);
                  for (int _i187 = 0; _i187 < _map186.size; ++_i187)
                  {
                    String _key188;
                    ImagePermissions _val189;
                    _key188 = iprot.readString();
                    _val189 = new ImagePermissions();
                    _val189.read(iprot);
                    struct.permissions.put(_key188, _val189);
                  }
                  iprot.readMapEnd();
                }
                struct.setPermissionsIsSet(true);
              } else { 
                org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
              }
              break;
            default:
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
          }
          iprot.readFieldEnd();
        }
        iprot.readStructEnd();

        // check for required fields of primitive type, which can't be checked in the validate method
        struct.validate();
      }

      public void write(org.apache.thrift.protocol.TProtocol oprot, writeImagePermissions_args struct) throws org.apache.thrift.TException {
        struct.validate();

        oprot.writeStructBegin(STRUCT_DESC);
        if (struct.userToken != null) {
          oprot.writeFieldBegin(USER_TOKEN_FIELD_DESC);
          oprot.writeString(struct.userToken);
          oprot.writeFieldEnd();
        }
        if (struct.imageBaseId != null) {
          oprot.writeFieldBegin(IMAGE_BASE_ID_FIELD_DESC);
          oprot.writeString(struct.imageBaseId);
          oprot.writeFieldEnd();
        }
        if (struct.permissions != null) {
          oprot.writeFieldBegin(PERMISSIONS_FIELD_DESC);
          {
            oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRUCT, struct.permissions.size()));
            for (Map.Entry<String, ImagePermissions> _iter190 : struct.permissions.entrySet())
            {
              oprot.writeString(_iter190.getKey());
              _iter190.getValue().write(oprot);
            }
            oprot.writeMapEnd();
          }
          oprot.writeFieldEnd();
        }
        oprot.writeFieldStop();
        oprot.writeStructEnd();
      }

    }

    private static class writeImagePermissions_argsTupleSchemeFactory implements SchemeFactory {
      public writeImagePermissions_argsTupleScheme getScheme() {
        return new writeImagePermissions_argsTupleScheme();
      }
    }

    private static class writeImagePermissions_argsTupleScheme extends TupleScheme<writeImagePermissions_args> {

      @Override
      public void write(org.apache.thrift.protocol.TProtocol prot, writeImagePermissions_args struct) throws org.apache.thrift.TException {
        TTupleProtocol oprot = (TTupleProtocol) prot;
        BitSet optionals = new BitSet();
        if (struct.isSetUserToken()) {
          optionals.set(0);
        }
        if (struct.isSetImageBaseId()) {
          optionals.set(1);
        }
        if (struct.isSetPermissions()) {
          optionals.set(2);
        }
        oprot.writeBitSet(optionals, 3);
        if (struct.isSetUserToken()) {
          oprot.writeString(struct.userToken);
        }
        if (struct.isSetImageBaseId()) {
          oprot.writeString(struct.imageBaseId);
        }
        if (struct.isSetPermissions()) {
          {
            oprot.writeI32(struct.permissions.size());
            for (Map.Entry<String, ImagePermissions> _iter191 : struct.permissions.entrySet())
            {
              oprot.writeString(_iter191.getKey());
              _iter191.getValue().write(oprot);
            }
          }
        }
      }

      @Override
      public void read(org.apache.thrift.protocol.TProtocol prot, writeImagePermissions_args struct) throws org.apache.thrift.TException {
        TTupleProtocol iprot = (TTupleProtocol) prot;
        BitSet incoming = iprot.readBitSet(3);
        if (incoming.get(0)) {
          struct.userToken = iprot.readString();
          struct.setUserTokenIsSet(true);
        }
        if (incoming.get(1)) {
          struct.imageBaseId = iprot.readString();
          struct.setImageBaseIdIsSet(true);
        }
        if (incoming.get(2)) {
          {
            org.apache.thrift.protocol.TMap _map192 = new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRUCT, iprot.readI32());
            struct.permissions = new HashMap<String,ImagePermissions>(2*_map192.size);
            for (int _i193 = 0; _i193 < _map192.size; ++_i193)
            {
              String _key194;
              ImagePermissions _val195;
              _key194 = iprot.readString();
              _val195 = new ImagePermissions();
              _val195.read(iprot);
              struct.permissions.put(_key194, _val195);
            }
          }
          struct.setPermissionsIsSet(true);
        }
      }
    }

  }

  public static class writeImagePermissions_result implements org.apache.thrift.TBase<writeImagePermissions_result, writeImagePermissions_result._Fields>, java.io.Serializable, Cloneable, Comparable<writeImagePermissions_result>   {
    private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("writeImagePermissions_result");

    private static final org.apache.thrift.protocol.TField AUTH_ERROR_FIELD_DESC = new org.apache.thrift.protocol.TField("authError", org.apache.thrift.protocol.TType.STRUCT, (short)1);
    private static final org.apache.thrift.protocol.TField NOT_FOUND_FIELD_DESC = new org.apache.thrift.protocol.TField("notFound", org.apache.thrift.protocol.TType.STRUCT, (short)2);
    private static final org.apache.thrift.protocol.TField SERVER_ERROR_FIELD_DESC = new org.apache.thrift.protocol.TField("serverError", org.apache.thrift.protocol.TType.STRUCT, (short)3);

    private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
    static {
      schemes.put(StandardScheme.class, new writeImagePermissions_resultStandardSchemeFactory());
      schemes.put(TupleScheme.class, new writeImagePermissions_resultTupleSchemeFactory());
    }

    public TAuthorizationException authError; // required
    public TNotFoundException notFound; // required
    public TInternalServerError serverError; // required

    /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
    public enum _Fields implements org.apache.thrift.TFieldIdEnum {
      AUTH_ERROR((short)1, "authError"),
      NOT_FOUND((short)2, "notFound"),
      SERVER_ERROR((short)3, "serverError");

      private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();

      static {
        for (_Fields field : EnumSet.allOf(_Fields.class)) {
          byName.put(field.getFieldName(), field);
        }
      }

      /**
       * Find the _Fields constant that matches fieldId, or null if its not found.
       */
      public static _Fields findByThriftId(int fieldId) {
        switch(fieldId) {
          case 1: // AUTH_ERROR
            return AUTH_ERROR;
          case 2: // NOT_FOUND
            return NOT_FOUND;
          case 3: // SERVER_ERROR
            return SERVER_ERROR;
          default:
            return null;
        }
      }

      /**
       * Find the _Fields constant that matches fieldId, throwing an exception
       * if it is not found.
       */
      public static _Fields findByThriftIdOrThrow(int fieldId) {
        _Fields fields = findByThriftId(fieldId);
        if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
        return fields;
      }

      /**
       * Find the _Fields constant that matches name, or null if its not found.
       */
      public static _Fields findByName(String name) {
        return byName.get(name);
      }

      private final short _thriftId;
      private final String _fieldName;

      _Fields(short thriftId, String fieldName) {
        _thriftId = thriftId;
        _fieldName = fieldName;
      }

      public short getThriftFieldId() {
        return _thriftId;
      }

      public String getFieldName() {
        return _fieldName;
      }
    }

    // isset id assignments
    public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
    static {
      Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
      tmpMap.put(_Fields.AUTH_ERROR, new org.apache.thrift.meta_data.FieldMetaData("authError", org.apache.thrift.TFieldRequirementType.DEFAULT, 
          new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT)));
      tmpMap.put(_Fields.NOT_FOUND, new org.apache.thrift.meta_data.FieldMetaData("notFound", org.apache.thrift.TFieldRequirementType.DEFAULT, 
          new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT)));
      tmpMap.put(_Fields.SERVER_ERROR, new org.apache.thrift.meta_data.FieldMetaData("serverError", org.apache.thrift.TFieldRequirementType.DEFAULT, 
          new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT)));
      metaDataMap = Collections.unmodifiableMap(tmpMap);
      org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(writeImagePermissions_result.class, metaDataMap);
    }

    public writeImagePermissions_result() {
    }

    public writeImagePermissions_result(
      TAuthorizationException authError,
      TNotFoundException notFound,
      TInternalServerError serverError)
    {
      this();
      this.authError = authError;
      this.notFound = notFound;
      this.serverError = serverError;
    }

    /**
     * Performs a deep copy on <i>other</i>.
     */
    public writeImagePermissions_result(writeImagePermissions_result other) {
      if (other.isSetAuthError()) {
        this.authError = new TAuthorizationException(other.authError);
      }
      if (other.isSetNotFound()) {
        this.notFound = new TNotFoundException(other.notFound);
      }
      if (other.isSetServerError()) {
        this.serverError = new TInternalServerError(other.serverError);
      }
    }

    public writeImagePermissions_result deepCopy() {
      return new writeImagePermissions_result(this);
    }

    @Override
    public void clear() {
      this.authError = null;
      this.notFound = null;
      this.serverError = null;
    }

    public TAuthorizationException getAuthError() {
      return this.authError;
    }

    public writeImagePermissions_result setAuthError(TAuthorizationException authError) {
      this.authError = authError;
      return this;
    }

    public void unsetAuthError() {
      this.authError = null;
    }

    /** Returns true if field authError is set (has been assigned a value) and false otherwise */
    public boolean isSetAuthError() {
      return this.authError != null;
    }

    public void setAuthErrorIsSet(boolean value) {
      if (!value) {
        this.authError = null;
      }
    }

    public TNotFoundException getNotFound() {
      return this.notFound;
    }

    public writeImagePermissions_result setNotFound(TNotFoundException notFound) {
      this.notFound = notFound;
      return this;
    }

    public void unsetNotFound() {
      this.notFound = null;
    }

    /** Returns true if field notFound is set (has been assigned a value) and false otherwise */
    public boolean isSetNotFound() {
      return this.notFound != null;
    }

    public void setNotFoundIsSet(boolean value) {
      if (!value) {
        this.notFound = null;
      }
    }

    public TInternalServerError getServerError() {
      return this.serverError;
    }

    public writeImagePermissions_result setServerError(TInternalServerError serverError) {
      this.serverError = serverError;
      return this;
    }

    public void unsetServerError() {
      this.serverError = null;
    }

    /** Returns true if field serverError is set (has been assigned a value) and false otherwise */
    public boolean isSetServerError() {
      return this.serverError != null;
    }

    public void setServerErrorIsSet(boolean value) {
      if (!value) {
        this.serverError = null;
      }
    }

    public void setFieldValue(_Fields field, Object value) {
      switch (field) {
      case AUTH_ERROR:
        if (value == null) {
          unsetAuthError();
        } else {
          setAuthError((TAuthorizationException)value);
        }
        break;

      case NOT_FOUND:
        if (value == null) {
          unsetNotFound();
        } else {
          setNotFound((TNotFoundException)value);
        }
        break;

      case SERVER_ERROR:
        if (value == null) {
          unsetServerError();
        } else {
          setServerError((TInternalServerError)value);
        }
        break;

      }
    }

    public Object getFieldValue(_Fields field) {
      switch (field) {
      case AUTH_ERROR:
        return getAuthError();

      case NOT_FOUND:
        return getNotFound();

      case SERVER_ERROR:
        return getServerError();

      }
      throw new IllegalStateException();
    }

    /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
    public boolean isSet(_Fields field) {
      if (field == null) {
        throw new IllegalArgumentException();
      }

      switch (field) {
      case AUTH_ERROR:
        return isSetAuthError();
      case NOT_FOUND:
        return isSetNotFound();
      case SERVER_ERROR:
        return isSetServerError();
      }
      throw new IllegalStateException();
    }

    @Override
    public boolean equals(Object that) {
      if (that == null)
        return false;
      if (that instanceof writeImagePermissions_result)
        return this.equals((writeImagePermissions_result)that);
      return false;
    }

    public boolean equals(writeImagePermissions_result that) {
      if (that == null)
        return false;

      boolean this_present_authError = true && this.isSetAuthError();
      boolean that_present_authError = true && that.isSetAuthError();
      if (this_present_authError || that_present_authError) {
        if (!(this_present_authError && that_present_authError))
          return false;
        if (!this.authError.equals(that.authError))
          return false;
      }

      boolean this_present_notFound = true && this.isSetNotFound();
      boolean that_present_notFound = true && that.isSetNotFound();
      if (this_present_notFound || that_present_notFound) {
        if (!(this_present_notFound && that_present_notFound))
          return false;
        if (!this.notFound.equals(that.notFound))
          return false;
      }

      boolean this_present_serverError = true && this.isSetServerError();
      boolean that_present_serverError = true && that.isSetServerError();
      if (this_present_serverError || that_present_serverError) {
        if (!(this_present_serverError && that_present_serverError))
          return false;
        if (!this.serverError.equals(that.serverError))
          return false;
      }

      return true;
    }

    @Override
    public int hashCode() {
      return 0;
    }

    @Override
    public int compareTo(writeImagePermissions_result other) {
      if (!getClass().equals(other.getClass())) {
        return getClass().getName().compareTo(other.getClass().getName());
      }

      int lastComparison = 0;

      lastComparison = Boolean.valueOf(isSetAuthError()).compareTo(other.isSetAuthError());
      if (lastComparison != 0) {
        return lastComparison;
      }
      if (isSetAuthError()) {
        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.authError, other.authError);
        if (lastComparison != 0) {
          return lastComparison;
        }
      }
      lastComparison = Boolean.valueOf(isSetNotFound()).compareTo(other.isSetNotFound());
      if (lastComparison != 0) {
        return lastComparison;
      }
      if (isSetNotFound()) {
        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.notFound, other.notFound);
        if (lastComparison != 0) {
          return lastComparison;
        }
      }
      lastComparison = Boolean.valueOf(isSetServerError()).compareTo(other.isSetServerError());
      if (lastComparison != 0) {
        return lastComparison;
      }
      if (isSetServerError()) {
        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.serverError, other.serverError);
        if (lastComparison != 0) {
          return lastComparison;
        }
      }
      return 0;
    }

    public _Fields fieldForId(int fieldId) {
      return _Fields.findByThriftId(fieldId);
    }

    public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
      schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
    }

    public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
      schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
      }

    @Override
    public String toString() {
      StringBuilder sb = new StringBuilder("writeImagePermissions_result(");
      boolean first = true;

      sb.append("authError:");
      if (this.authError == null) {
        sb.append("null");
      } else {
        sb.append(this.authError);
      }
      first = false;
      if (!first) sb.append(", ");
      sb.append("notFound:");
      if (this.notFound == null) {
        sb.append("null");
      } else {
        sb.append(this.notFound);
      }
      first = false;
      if (!first) sb.append(", ");
      sb.append("serverError:");
      if (this.serverError == null) {
        sb.append("null");
      } else {
        sb.append(this.serverError);
      }
      first = false;
      sb.append(")");
      return sb.toString();
    }

    public void validate() throws org.apache.thrift.TException {
      // check for required fields
      // check for sub-struct validity
    }

    private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
      try {
        write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
      } catch (org.apache.thrift.TException te) {
        throw new java.io.IOException(te);
      }
    }

    private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
      try {
        read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
      } catch (org.apache.thrift.TException te) {
        throw new java.io.IOException(te);
      }
    }

    private static class writeImagePermissions_resultStandardSchemeFactory implements SchemeFactory {
      public writeImagePermissions_resultStandardScheme getScheme() {
        return new writeImagePermissions_resultStandardScheme();
      }
    }

    private static class writeImagePermissions_resultStandardScheme extends StandardScheme<writeImagePermissions_result> {

      public void read(org.apache.thrift.protocol.TProtocol iprot, writeImagePermissions_result struct) throws org.apache.thrift.TException {
        org.apache.thrift.protocol.TField schemeField;
        iprot.readStructBegin();
        while (true)
        {
          schemeField = iprot.readFieldBegin();
          if (schemeField.type == org.apache.thrift.protocol.TType.STOP) { 
            break;
          }
          switch (schemeField.id) {
            case 1: // AUTH_ERROR
              if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
                struct.authError = new TAuthorizationException();
                struct.authError.read(iprot);
                struct.setAuthErrorIsSet(true);
              } else { 
                org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
              }
              break;
            case 2: // NOT_FOUND
              if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
                struct.notFound = new TNotFoundException();
                struct.notFound.read(iprot);
                struct.setNotFoundIsSet(true);
              } else { 
                org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
              }
              break;
            case 3: // SERVER_ERROR
              if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
                struct.serverError = new TInternalServerError();
                struct.serverError.read(iprot);
                struct.setServerErrorIsSet(true);
              } else { 
                org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
              }
              break;
            default:
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
          }
          iprot.readFieldEnd();
        }
        iprot.readStructEnd();

        // check for required fields of primitive type, which can't be checked in the validate method
        struct.validate();
      }

      public void write(org.apache.thrift.protocol.TProtocol oprot, writeImagePermissions_result struct) throws org.apache.thrift.TException {
        struct.validate();

        oprot.writeStructBegin(STRUCT_DESC);
        if (struct.authError != null) {
          oprot.writeFieldBegin(AUTH_ERROR_FIELD_DESC);
          struct.authError.write(oprot);
          oprot.writeFieldEnd();
        }
        if (struct.notFound != null) {
          oprot.writeFieldBegin(NOT_FOUND_FIELD_DESC);
          struct.notFound.write(oprot);
          oprot.writeFieldEnd();
        }
        if (struct.serverError != null) {
          oprot.writeFieldBegin(SERVER_ERROR_FIELD_DESC);
          struct.serverError.write(oprot);
          oprot.writeFieldEnd();
        }
        oprot.writeFieldStop();
        oprot.writeStructEnd();
      }

    }

    private static class writeImagePermissions_resultTupleSchemeFactory implements SchemeFactory {
      public writeImagePermissions_resultTupleScheme getScheme() {
        return new writeImagePermissions_resultTupleScheme();
      }
    }

    private static class writeImagePermissions_resultTupleScheme extends TupleScheme<writeImagePermissions_result> {

      @Override
      public void write(org.apache.thrift.protocol.TProtocol prot, writeImagePermissions_result struct) throws org.apache.thrift.TException {
        TTupleProtocol oprot = (TTupleProtocol) prot;
        BitSet optionals = new BitSet();
        if (struct.isSetAuthError()) {
          optionals.set(0);
        }
        if (struct.isSetNotFound()) {
          optionals.set(1);
        }
        if (struct.isSetServerError()) {
          optionals.set(2);
        }
        oprot.writeBitSet(optionals, 3);
        if (struct.isSetAuthError()) {
          struct.authError.write(oprot);
        }
        if (struct.isSetNotFound()) {
          struct.notFound.write(oprot);
        }
        if (struct.isSetServerError()) {
          struct.serverError.write(oprot);
        }
      }

      @Override
      public void read(org.apache.thrift.protocol.TProtocol prot, writeImagePermissions_result struct) throws org.apache.thrift.TException {
        TTupleProtocol iprot = (TTupleProtocol) prot;
        BitSet incoming = iprot.readBitSet(3);
        if (incoming.get(0)) {
          struct.authError = new TAuthorizationException();
          struct.authError.read(iprot);
          struct.setAuthErrorIsSet(true);
        }
        if (incoming.get(1)) {
          struct.notFound = new TNotFoundException();
          struct.notFound.read(iprot);
          struct.setNotFoundIsSet(true);
        }
        if (incoming.get(2)) {
          struct.serverError = new TInternalServerError();
          struct.serverError.read(iprot);
          struct.setServerErrorIsSet(true);
        }
      }
    }

  }

  public static class getImagePermissions_args implements org.apache.thrift.TBase<getImagePermissions_args, getImagePermissions_args._Fields>, java.io.Serializable, Cloneable, Comparable<getImagePermissions_args>   {
    private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getImagePermissions_args");

    private static final org.apache.thrift.protocol.TField USER_TOKEN_FIELD_DESC = new org.apache.thrift.protocol.TField("userToken", org.apache.thrift.protocol.TType.STRING, (short)1);
    private static final org.apache.thrift.protocol.TField IMAGE_BASE_ID_FIELD_DESC = new org.apache.thrift.protocol.TField("imageBaseId", org.apache.thrift.protocol.TType.STRING, (short)2);

    private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
    static {
      schemes.put(StandardScheme.class, new getImagePermissions_argsStandardSchemeFactory());
      schemes.put(TupleScheme.class, new getImagePermissions_argsTupleSchemeFactory());
    }

    public String userToken; // required
    public String imageBaseId; // required

    /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
    public enum _Fields implements org.apache.thrift.TFieldIdEnum {
      USER_TOKEN((short)1, "userToken"),
      IMAGE_BASE_ID((short)2, "imageBaseId");

      private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();

      static {
        for (_Fields field : EnumSet.allOf(_Fields.class)) {
          byName.put(field.getFieldName(), field);
        }
      }

      /**
       * Find the _Fields constant that matches fieldId, or null if its not found.
       */
      public static _Fields findByThriftId(int fieldId) {
        switch(fieldId) {
          case 1: // USER_TOKEN
            return USER_TOKEN;
          case 2: // IMAGE_BASE_ID
            return IMAGE_BASE_ID;
          default:
            return null;
        }
      }

      /**
       * Find the _Fields constant that matches fieldId, throwing an exception
       * if it is not found.
       */
      public static _Fields findByThriftIdOrThrow(int fieldId) {
        _Fields fields = findByThriftId(fieldId);
        if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
        return fields;
      }

      /**
       * Find the _Fields constant that matches name, or null if its not found.
       */
      public static _Fields findByName(String name) {
        return byName.get(name);
      }

      private final short _thriftId;
      private final String _fieldName;

      _Fields(short thriftId, String fieldName) {
        _thriftId = thriftId;
        _fieldName = fieldName;
      }

      public short getThriftFieldId() {
        return _thriftId;
      }

      public String getFieldName() {
        return _fieldName;
      }
    }

    // isset id assignments
    public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
    static {
      Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
      tmpMap.put(_Fields.USER_TOKEN, new org.apache.thrift.meta_data.FieldMetaData("userToken", org.apache.thrift.TFieldRequirementType.DEFAULT, 
          new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING          , "Token")));
      tmpMap.put(_Fields.IMAGE_BASE_ID, new org.apache.thrift.meta_data.FieldMetaData("imageBaseId", org.apache.thrift.TFieldRequirementType.DEFAULT, 
          new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING          , "UUID")));
      metaDataMap = Collections.unmodifiableMap(tmpMap);
      org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getImagePermissions_args.class, metaDataMap);
    }

    public getImagePermissions_args() {
    }

    public getImagePermissions_args(
      String userToken,
      String imageBaseId)
    {
      this();
      this.userToken = userToken;
      this.imageBaseId = imageBaseId;
    }

    /**
     * Performs a deep copy on <i>other</i>.
     */
    public getImagePermissions_args(getImagePermissions_args other) {
      if (other.isSetUserToken()) {
        this.userToken = other.userToken;
      }
      if (other.isSetImageBaseId()) {
        this.imageBaseId = other.imageBaseId;
      }
    }

    public getImagePermissions_args deepCopy() {
      return new getImagePermissions_args(this);
    }

    @Override
    public void clear() {
      this.userToken = null;
      this.imageBaseId = null;
    }

    public String getUserToken() {
      return this.userToken;
    }

    public getImagePermissions_args setUserToken(String userToken) {
      this.userToken = userToken;
      return this;
    }

    public void unsetUserToken() {
      this.userToken = null;
    }

    /** Returns true if field userToken is set (has been assigned a value) and false otherwise */
    public boolean isSetUserToken() {
      return this.userToken != null;
    }

    public void setUserTokenIsSet(boolean value) {
      if (!value) {
        this.userToken = null;
      }
    }

    public String getImageBaseId() {
      return this.imageBaseId;
    }

    public getImagePermissions_args setImageBaseId(String imageBaseId) {
      this.imageBaseId = imageBaseId;
      return this;
    }

    public void unsetImageBaseId() {
      this.imageBaseId = null;
    }

    /** Returns true if field imageBaseId is set (has been assigned a value) and false otherwise */
    public boolean isSetImageBaseId() {
      return this.imageBaseId != null;
    }

    public void setImageBaseIdIsSet(boolean value) {
      if (!value) {
        this.imageBaseId = null;
      }
    }

    public void setFieldValue(_Fields field, Object value) {
      switch (field) {
      case USER_TOKEN:
        if (value == null) {
          unsetUserToken();
        } else {
          setUserToken((String)value);
        }
        break;

      case IMAGE_BASE_ID:
        if (value == null) {
          unsetImageBaseId();
        } else {
          setImageBaseId((String)value);
        }
        break;

      }
    }

    public Object getFieldValue(_Fields field) {
      switch (field) {
      case USER_TOKEN:
        return getUserToken();

      case IMAGE_BASE_ID:
        return getImageBaseId();

      }
      throw new IllegalStateException();
    }

    /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
    public boolean isSet(_Fields field) {
      if (field == null) {
        throw new IllegalArgumentException();
      }

      switch (field) {
      case USER_TOKEN:
        return isSetUserToken();
      case IMAGE_BASE_ID:
        return isSetImageBaseId();
      }
      throw new IllegalStateException();
    }

    @Override
    public boolean equals(Object that) {
      if (that == null)
        return false;
      if (that instanceof getImagePermissions_args)
        return this.equals((getImagePermissions_args)that);
      return false;
    }

    public boolean equals(getImagePermissions_args that) {
      if (that == null)
        return false;

      boolean this_present_userToken = true && this.isSetUserToken();
      boolean that_present_userToken = true && that.isSetUserToken();
      if (this_present_userToken || that_present_userToken) {
        if (!(this_present_userToken && that_present_userToken))
          return false;
        if (!this.userToken.equals(that.userToken))
          return false;
      }

      boolean this_present_imageBaseId = true && this.isSetImageBaseId();
      boolean that_present_imageBaseId = true && that.isSetImageBaseId();
      if (this_present_imageBaseId || that_present_imageBaseId) {
        if (!(this_present_imageBaseId && that_present_imageBaseId))
          return false;
        if (!this.imageBaseId.equals(that.imageBaseId))
          return false;
      }

      return true;
    }

    @Override
    public int hashCode() {
      return 0;
    }

    @Override
    public int compareTo(getImagePermissions_args other) {
      if (!getClass().equals(other.getClass())) {
        return getClass().getName().compareTo(other.getClass().getName());
      }

      int lastComparison = 0;

      lastComparison = Boolean.valueOf(isSetUserToken()).compareTo(other.isSetUserToken());
      if (lastComparison != 0) {
        return lastComparison;
      }
      if (isSetUserToken()) {
        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.userToken, other.userToken);
        if (lastComparison != 0) {
          return lastComparison;
        }
      }
      lastComparison = Boolean.valueOf(isSetImageBaseId()).compareTo(other.isSetImageBaseId());
      if (lastComparison != 0) {
        return lastComparison;
      }
      if (isSetImageBaseId()) {
        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.imageBaseId, other.imageBaseId);
        if (lastComparison != 0) {
          return lastComparison;
        }
      }
      return 0;
    }

    public _Fields fieldForId(int fieldId) {
      return _Fields.findByThriftId(fieldId);
    }

    public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
      schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
    }

    public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
      schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
    }

    @Override
    public String toString() {
      StringBuilder sb = new StringBuilder("getImagePermissions_args(");
      boolean first = true;

      sb.append("userToken:");
      if (this.userToken == null) {
        sb.append("null");
      } else {
        sb.append(this.userToken);
      }
      first = false;
      if (!first) sb.append(", ");
      sb.append("imageBaseId:");
      if (this.imageBaseId == null) {
        sb.append("null");
      } else {
        sb.append(this.imageBaseId);
      }
      first = false;
      sb.append(")");
      return sb.toString();
    }

    public void validate() throws org.apache.thrift.TException {
      // check for required fields
      // check for sub-struct validity
    }

    private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
      try {
        write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
      } catch (org.apache.thrift.TException te) {
        throw new java.io.IOException(te);
      }
    }

    private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
      try {
        read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
      } catch (org.apache.thrift.TException te) {
        throw new java.io.IOException(te);
      }
    }

    private static class getImagePermissions_argsStandardSchemeFactory implements SchemeFactory {
      public getImagePermissions_argsStandardScheme getScheme() {
        return new getImagePermissions_argsStandardScheme();
      }
    }

    private static class getImagePermissions_argsStandardScheme extends StandardScheme<getImagePermissions_args> {

      public void read(org.apache.thrift.protocol.TProtocol iprot, getImagePermissions_args struct) throws org.apache.thrift.TException {
        org.apache.thrift.protocol.TField schemeField;
        iprot.readStructBegin();
        while (true)
        {
          schemeField = iprot.readFieldBegin();
          if (schemeField.type == org.apache.thrift.protocol.TType.STOP) { 
            break;
          }
          switch (schemeField.id) {
            case 1: // USER_TOKEN
              if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
                struct.userToken = iprot.readString();
                struct.setUserTokenIsSet(true);
              } else { 
                org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
              }
              break;
            case 2: // IMAGE_BASE_ID
              if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
                struct.imageBaseId = iprot.readString();
                struct.setImageBaseIdIsSet(true);
              } else { 
                org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
              }
              break;
            default:
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
          }
          iprot.readFieldEnd();
        }
        iprot.readStructEnd();

        // check for required fields of primitive type, which can't be checked in the validate method
        struct.validate();
      }

      public void write(org.apache.thrift.protocol.TProtocol oprot, getImagePermissions_args struct) throws org.apache.thrift.TException {
        struct.validate();

        oprot.writeStructBegin(STRUCT_DESC);
        if (struct.userToken != null) {
          oprot.writeFieldBegin(USER_TOKEN_FIELD_DESC);
          oprot.writeString(struct.userToken);
          oprot.writeFieldEnd();
        }
        if (struct.imageBaseId != null) {
          oprot.writeFieldBegin(IMAGE_BASE_ID_FIELD_DESC);
          oprot.writeString(struct.imageBaseId);
          oprot.writeFieldEnd();
        }
        oprot.writeFieldStop();
        oprot.writeStructEnd();
      }

    }

    private static class getImagePermissions_argsTupleSchemeFactory implements SchemeFactory {
      public getImagePermissions_argsTupleScheme getScheme() {
        return new getImagePermissions_argsTupleScheme();
      }
    }

    private static class getImagePermissions_argsTupleScheme extends TupleScheme<getImagePermissions_args> {

      @Override
      public void write(org.apache.thrift.protocol.TProtocol prot, getImagePermissions_args struct) throws org.apache.thrift.TException {
        TTupleProtocol oprot = (TTupleProtocol) prot;
        BitSet optionals = new BitSet();
        if (struct.isSetUserToken()) {
          optionals.set(0);
        }
        if (struct.isSetImageBaseId()) {
          optionals.set(1);
        }
        oprot.writeBitSet(optionals, 2);
        if (struct.isSetUserToken()) {
          oprot.writeString(struct.userToken);
        }
        if (struct.isSetImageBaseId()) {
          oprot.writeString(struct.imageBaseId);
        }
      }

      @Override
      public void read(org.apache.thrift.protocol.TProtocol prot, getImagePermissions_args struct) throws org.apache.thrift.TException {
        TTupleProtocol iprot = (TTupleProtocol) prot;
        BitSet incoming = iprot.readBitSet(2);
        if (incoming.get(0)) {
          struct.userToken = iprot.readString();
          struct.setUserTokenIsSet(true);
        }
        if (incoming.get(1)) {
          struct.imageBaseId = iprot.readString();
          struct.setImageBaseIdIsSet(true);
        }
      }
    }

  }

  public static class getImagePermissions_result implements org.apache.thrift.TBase<getImagePermissions_result, getImagePermissions_result._Fields>, java.io.Serializable, Cloneable, Comparable<getImagePermissions_result>   {
    private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getImagePermissions_result");

    private static final org.apache.thrift.protocol.TField SUCCESS_FIELD_DESC = new org.apache.thrift.protocol.TField("success", org.apache.thrift.protocol.TType.MAP, (short)0);
    private static final org.apache.thrift.protocol.TField AUTH_ERROR_FIELD_DESC = new org.apache.thrift.protocol.TField("authError", org.apache.thrift.protocol.TType.STRUCT, (short)1);
    private static final org.apache.thrift.protocol.TField NOT_FOUND_FIELD_DESC = new org.apache.thrift.protocol.TField("notFound", org.apache.thrift.protocol.TType.STRUCT, (short)2);
    private static final org.apache.thrift.protocol.TField SERVER_ERROR_FIELD_DESC = new org.apache.thrift.protocol.TField("serverError", org.apache.thrift.protocol.TType.STRUCT, (short)3);

    private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
    static {
      schemes.put(StandardScheme.class, new getImagePermissions_resultStandardSchemeFactory());
      schemes.put(TupleScheme.class, new getImagePermissions_resultTupleSchemeFactory());
    }

    public Map<String,ImagePermissions> success; // required
    public TAuthorizationException authError; // required
    public TNotFoundException notFound; // required
    public TInternalServerError serverError; // required

    /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
    public enum _Fields implements org.apache.thrift.TFieldIdEnum {
      SUCCESS((short)0, "success"),
      AUTH_ERROR((short)1, "authError"),
      NOT_FOUND((short)2, "notFound"),
      SERVER_ERROR((short)3, "serverError");

      private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();

      static {
        for (_Fields field : EnumSet.allOf(_Fields.class)) {
          byName.put(field.getFieldName(), field);
        }
      }

      /**
       * Find the _Fields constant that matches fieldId, or null if its not found.
       */
      public static _Fields findByThriftId(int fieldId) {
        switch(fieldId) {
          case 0: // SUCCESS
            return SUCCESS;
          case 1: // AUTH_ERROR
            return AUTH_ERROR;
          case 2: // NOT_FOUND
            return NOT_FOUND;
          case 3: // SERVER_ERROR
            return SERVER_ERROR;
          default:
            return null;
        }
      }

      /**
       * Find the _Fields constant that matches fieldId, throwing an exception
       * if it is not found.
       */
      public static _Fields findByThriftIdOrThrow(int fieldId) {
        _Fields fields = findByThriftId(fieldId);
        if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
        return fields;
      }

      /**
       * Find the _Fields constant that matches name, or null if its not found.
       */
      public static _Fields findByName(String name) {
        return byName.get(name);
      }

      private final short _thriftId;
      private final String _fieldName;

      _Fields(short thriftId, String fieldName) {
        _thriftId = thriftId;
        _fieldName = fieldName;
      }

      public short getThriftFieldId() {
        return _thriftId;
      }

      public String getFieldName() {
        return _fieldName;
      }
    }

    // isset id assignments
    public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
    static {
      Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
      tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, 
          new org.apache.thrift.meta_data.MapMetaData(org.apache.thrift.protocol.TType.MAP, 
              new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING              , "UUID"), 
              new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, ImagePermissions.class))));
      tmpMap.put(_Fields.AUTH_ERROR, new org.apache.thrift.meta_data.FieldMetaData("authError", org.apache.thrift.TFieldRequirementType.DEFAULT, 
          new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT)));
      tmpMap.put(_Fields.NOT_FOUND, new org.apache.thrift.meta_data.FieldMetaData("notFound", org.apache.thrift.TFieldRequirementType.DEFAULT, 
          new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT)));
      tmpMap.put(_Fields.SERVER_ERROR, new org.apache.thrift.meta_data.FieldMetaData("serverError", org.apache.thrift.TFieldRequirementType.DEFAULT, 
          new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT)));
      metaDataMap = Collections.unmodifiableMap(tmpMap);
      org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getImagePermissions_result.class, metaDataMap);
    }

    public getImagePermissions_result() {
    }

    public getImagePermissions_result(
      Map<String,ImagePermissions> success,
      TAuthorizationException authError,
      TNotFoundException notFound,
      TInternalServerError serverError)
    {
      this();
      this.success = success;
      this.authError = authError;
      this.notFound = notFound;
      this.serverError = serverError;
    }

    /**
     * Performs a deep copy on <i>other</i>.
     */
    public getImagePermissions_result(getImagePermissions_result other) {
      if (other.isSetSuccess()) {
        Map<String,ImagePermissions> __this__success = new HashMap<String,ImagePermissions>(other.success.size());
        for (Map.Entry<String, ImagePermissions> other_element : other.success.entrySet()) {

          String other_element_key = other_element.getKey();
          ImagePermissions other_element_value = other_element.getValue();

          String __this__success_copy_key = other_element_key;

          ImagePermissions __this__success_copy_value = new ImagePermissions(other_element_value);

          __this__success.put(__this__success_copy_key, __this__success_copy_value);
        }
        this.success = __this__success;
      }
      if (other.isSetAuthError()) {
        this.authError = new TAuthorizationException(other.authError);
      }
      if (other.isSetNotFound()) {
        this.notFound = new TNotFoundException(other.notFound);
      }
      if (other.isSetServerError()) {
        this.serverError = new TInternalServerError(other.serverError);
      }
    }

    public getImagePermissions_result deepCopy() {
      return new getImagePermissions_result(this);
    }

    @Override
    public void clear() {
      this.success = null;
      this.authError = null;
      this.notFound = null;
      this.serverError = null;
    }

    public int getSuccessSize() {
      return (this.success == null) ? 0 : this.success.size();
    }

    public void putToSuccess(String key, ImagePermissions val) {
      if (this.success == null) {
        this.success = new HashMap<String,ImagePermissions>();
      }
      this.success.put(key, val);
    }

    public Map<String,ImagePermissions> getSuccess() {
      return this.success;
    }

    public getImagePermissions_result setSuccess(Map<String,ImagePermissions> success) {
      this.success = success;
      return this;
    }

    public void unsetSuccess() {
      this.success = null;
    }

    /** Returns true if field success is set (has been assigned a value) and false otherwise */
    public boolean isSetSuccess() {
      return this.success != null;
    }

    public void setSuccessIsSet(boolean value) {
      if (!value) {
        this.success = null;
      }
    }

    public TAuthorizationException getAuthError() {
      return this.authError;
    }

    public getImagePermissions_result setAuthError(TAuthorizationException authError) {
      this.authError = authError;
      return this;
    }

    public void unsetAuthError() {
      this.authError = null;
    }

    /** Returns true if field authError is set (has been assigned a value) and false otherwise */
    public boolean isSetAuthError() {
      return this.authError != null;
    }

    public void setAuthErrorIsSet(boolean value) {
      if (!value) {
        this.authError = null;
      }
    }

    public TNotFoundException getNotFound() {
      return this.notFound;
    }

    public getImagePermissions_result setNotFound(TNotFoundException notFound) {
      this.notFound = notFound;
      return this;
    }

    public void unsetNotFound() {
      this.notFound = null;
    }

    /** Returns true if field notFound is set (has been assigned a value) and false otherwise */
    public boolean isSetNotFound() {
      return this.notFound != null;
    }

    public void setNotFoundIsSet(boolean value) {
      if (!value) {
        this.notFound = null;
      }
    }

    public TInternalServerError getServerError() {
      return this.serverError;
    }

    public getImagePermissions_result setServerError(TInternalServerError serverError) {
      this.serverError = serverError;
      return this;
    }

    public void unsetServerError() {
      this.serverError = null;
    }

    /** Returns true if field serverError is set (has been assigned a value) and false otherwise */
    public boolean isSetServerError() {
      return this.serverError != null;
    }

    public void setServerErrorIsSet(boolean value) {
      if (!value) {
        this.serverError = null;
      }
    }

    public void setFieldValue(_Fields field, Object value) {
      switch (field) {
      case SUCCESS:
        if (value == null) {
          unsetSuccess();
        } else {
          setSuccess((Map<String,ImagePermissions>)value);
        }
        break;

      case AUTH_ERROR:
        if (value == null) {
          unsetAuthError();
        } else {
          setAuthError((TAuthorizationException)value);
        }
        break;

      case NOT_FOUND:
        if (value == null) {
          unsetNotFound();
        } else {
          setNotFound((TNotFoundException)value);
        }
        break;

      case SERVER_ERROR:
        if (value == null) {
          unsetServerError();
        } else {
          setServerError((TInternalServerError)value);
        }
        break;

      }
    }

    public Object getFieldValue(_Fields field) {
      switch (field) {
      case SUCCESS:
        return getSuccess();

      case AUTH_ERROR:
        return getAuthError();

      case NOT_FOUND:
        return getNotFound();

      case SERVER_ERROR:
        return getServerError();

      }
      throw new IllegalStateException();
    }

    /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
    public boolean isSet(_Fields field) {
      if (field == null) {
        throw new IllegalArgumentException();
      }

      switch (field) {
      case SUCCESS:
        return isSetSuccess();
      case AUTH_ERROR:
        return isSetAuthError();
      case NOT_FOUND:
        return isSetNotFound();
      case SERVER_ERROR:
        return isSetServerError();
      }
      throw new IllegalStateException();
    }

    @Override
    public boolean equals(Object that) {
      if (that == null)
        return false;
      if (that instanceof getImagePermissions_result)
        return this.equals((getImagePermissions_result)that);
      return false;
    }

    public boolean equals(getImagePermissions_result that) {
      if (that == null)
        return false;

      boolean this_present_success = true && this.isSetSuccess();
      boolean that_present_success = true && that.isSetSuccess();
      if (this_present_success || that_present_success) {
        if (!(this_present_success && that_present_success))
          return false;
        if (!this.success.equals(that.success))
          return false;
      }

      boolean this_present_authError = true && this.isSetAuthError();
      boolean that_present_authError = true && that.isSetAuthError();
      if (this_present_authError || that_present_authError) {
        if (!(this_present_authError && that_present_authError))
          return false;
        if (!this.authError.equals(that.authError))
          return false;
      }

      boolean this_present_notFound = true && this.isSetNotFound();
      boolean that_present_notFound = true && that.isSetNotFound();
      if (this_present_notFound || that_present_notFound) {
        if (!(this_present_notFound && that_present_notFound))
          return false;
        if (!this.notFound.equals(that.notFound))
          return false;
      }

      boolean this_present_serverError = true && this.isSetServerError();
      boolean that_present_serverError = true && that.isSetServerError();
      if (this_present_serverError || that_present_serverError) {
        if (!(this_present_serverError && that_present_serverError))
          return false;
        if (!this.serverError.equals(that.serverError))
          return false;
      }

      return true;
    }

    @Override
    public int hashCode() {
      return 0;
    }

    @Override
    public int compareTo(getImagePermissions_result other) {
      if (!getClass().equals(other.getClass())) {
        return getClass().getName().compareTo(other.getClass().getName());
      }

      int lastComparison = 0;

      lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(other.isSetSuccess());
      if (lastComparison != 0) {
        return lastComparison;
      }
      if (isSetSuccess()) {
        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, other.success);
        if (lastComparison != 0) {
          return lastComparison;
        }
      }
      lastComparison = Boolean.valueOf(isSetAuthError()).compareTo(other.isSetAuthError());
      if (lastComparison != 0) {
        return lastComparison;
      }
      if (isSetAuthError()) {
        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.authError, other.authError);
        if (lastComparison != 0) {
          return lastComparison;
        }
      }
      lastComparison = Boolean.valueOf(isSetNotFound()).compareTo(other.isSetNotFound());
      if (lastComparison != 0) {
        return lastComparison;
      }
      if (isSetNotFound()) {
        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.notFound, other.notFound);
        if (lastComparison != 0) {
          return lastComparison;
        }
      }
      lastComparison = Boolean.valueOf(isSetServerError()).compareTo(other.isSetServerError());
      if (lastComparison != 0) {
        return lastComparison;
      }
      if (isSetServerError()) {
        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.serverError, other.serverError);
        if (lastComparison != 0) {
          return lastComparison;
        }
      }
      return 0;
    }

    public _Fields fieldForId(int fieldId) {
      return _Fields.findByThriftId(fieldId);
    }

    public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
      schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
    }

    public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
      schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
      }

    @Override
    public String toString() {
      StringBuilder sb = new StringBuilder("getImagePermissions_result(");
      boolean first = true;

      sb.append("success:");
      if (this.success == null) {
        sb.append("null");
      } else {
        sb.append(this.success);
      }
      first = false;
      if (!first) sb.append(", ");
      sb.append("authError:");
      if (this.authError == null) {
        sb.append("null");
      } else {
        sb.append(this.authError);
      }
      first = false;
      if (!first) sb.append(", ");
      sb.append("notFound:");
      if (this.notFound == null) {
        sb.append("null");
      } else {
        sb.append(this.notFound);
      }
      first = false;
      if (!first) sb.append(", ");
      sb.append("serverError:");
      if (this.serverError == null) {
        sb.append("null");
      } else {
        sb.append(this.serverError);
      }
      first = false;
      sb.append(")");
      return sb.toString();
    }

    public void validate() throws org.apache.thrift.TException {
      // check for required fields
      // check for sub-struct validity
    }

    private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
      try {
        write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
      } catch (org.apache.thrift.TException te) {
        throw new java.io.IOException(te);
      }
    }

    private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
      try {
        read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
      } catch (org.apache.thrift.TException te) {
        throw new java.io.IOException(te);
      }
    }

    private static class getImagePermissions_resultStandardSchemeFactory implements SchemeFactory {
      public getImagePermissions_resultStandardScheme getScheme() {
        return new getImagePermissions_resultStandardScheme();
      }
    }

    private static class getImagePermissions_resultStandardScheme extends StandardScheme<getImagePermissions_result> {

      public void read(org.apache.thrift.protocol.TProtocol iprot, getImagePermissions_result struct) throws org.apache.thrift.TException {
        org.apache.thrift.protocol.TField schemeField;
        iprot.readStructBegin();
        while (true)
        {
          schemeField = iprot.readFieldBegin();
          if (schemeField.type == org.apache.thrift.protocol.TType.STOP) { 
            break;
          }
          switch (schemeField.id) {
            case 0: // SUCCESS
              if (schemeField.type == org.apache.thrift.protocol.TType.MAP) {
                {
                  org.apache.thrift.protocol.TMap _map196 = iprot.readMapBegin();
                  struct.success = new HashMap<String,ImagePermissions>(2*_map196.size);
                  for (int _i197 = 0; _i197 < _map196.size; ++_i197)
                  {
                    String _key198;
                    ImagePermissions _val199;
                    _key198 = iprot.readString();
                    _val199 = new ImagePermissions();
                    _val199.read(iprot);
                    struct.success.put(_key198, _val199);
                  }
                  iprot.readMapEnd();
                }
                struct.setSuccessIsSet(true);
              } else { 
                org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
              }
              break;
            case 1: // AUTH_ERROR
              if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
                struct.authError = new TAuthorizationException();
                struct.authError.read(iprot);
                struct.setAuthErrorIsSet(true);
              } else { 
                org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
              }
              break;
            case 2: // NOT_FOUND
              if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
                struct.notFound = new TNotFoundException();
                struct.notFound.read(iprot);
                struct.setNotFoundIsSet(true);
              } else { 
                org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
              }
              break;
            case 3: // SERVER_ERROR
              if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
                struct.serverError = new TInternalServerError();
                struct.serverError.read(iprot);
                struct.setServerErrorIsSet(true);
              } else { 
                org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
              }
              break;
            default:
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
          }
          iprot.readFieldEnd();
        }
        iprot.readStructEnd();

        // check for required fields of primitive type, which can't be checked in the validate method
        struct.validate();
      }

      public void write(org.apache.thrift.protocol.TProtocol oprot, getImagePermissions_result struct) throws org.apache.thrift.TException {
        struct.validate();

        oprot.writeStructBegin(STRUCT_DESC);
        if (struct.success != null) {
          oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
          {
            oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRUCT, struct.success.size()));
            for (Map.Entry<String, ImagePermissions> _iter200 : struct.success.entrySet())
            {
              oprot.writeString(_iter200.getKey());
              _iter200.getValue().write(oprot);
            }
            oprot.writeMapEnd();
          }
          oprot.writeFieldEnd();
        }
        if (struct.authError != null) {
          oprot.writeFieldBegin(AUTH_ERROR_FIELD_DESC);
          struct.authError.write(oprot);
          oprot.writeFieldEnd();
        }
        if (struct.notFound != null) {
          oprot.writeFieldBegin(NOT_FOUND_FIELD_DESC);
          struct.notFound.write(oprot);
          oprot.writeFieldEnd();
        }
        if (struct.serverError != null) {
          oprot.writeFieldBegin(SERVER_ERROR_FIELD_DESC);
          struct.serverError.write(oprot);
          oprot.writeFieldEnd();
        }
        oprot.writeFieldStop();
        oprot.writeStructEnd();
      }

    }

    private static class getImagePermissions_resultTupleSchemeFactory implements SchemeFactory {
      public getImagePermissions_resultTupleScheme getScheme() {
        return new getImagePermissions_resultTupleScheme();
      }
    }

    private static class getImagePermissions_resultTupleScheme extends TupleScheme<getImagePermissions_result> {

      @Override
      public void write(org.apache.thrift.protocol.TProtocol prot, getImagePermissions_result struct) throws org.apache.thrift.TException {
        TTupleProtocol oprot = (TTupleProtocol) prot;
        BitSet optionals = new BitSet();
        if (struct.isSetSuccess()) {
          optionals.set(0);
        }
        if (struct.isSetAuthError()) {
          optionals.set(1);
        }
        if (struct.isSetNotFound()) {
          optionals.set(2);
        }
        if (struct.isSetServerError()) {
          optionals.set(3);
        }
        oprot.writeBitSet(optionals, 4);
        if (struct.isSetSuccess()) {
          {
            oprot.writeI32(struct.success.size());
            for (Map.Entry<String, ImagePermissions> _iter201 : struct.success.entrySet())
            {
              oprot.writeString(_iter201.getKey());
              _iter201.getValue().write(oprot);
            }
          }
        }
        if (struct.isSetAuthError()) {
          struct.authError.write(oprot);
        }
        if (struct.isSetNotFound()) {
          struct.notFound.write(oprot);
        }
        if (struct.isSetServerError()) {
          struct.serverError.write(oprot);
        }
      }

      @Override
      public void read(org.apache.thrift.protocol.TProtocol prot, getImagePermissions_result struct) throws org.apache.thrift.TException {
        TTupleProtocol iprot = (TTupleProtocol) prot;
        BitSet incoming = iprot.readBitSet(4);
        if (incoming.get(0)) {
          {
            org.apache.thrift.protocol.TMap _map202 = new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRUCT, iprot.readI32());
            struct.success = new HashMap<String,ImagePermissions>(2*_map202.size);
            for (int _i203 = 0; _i203 < _map202.size; ++_i203)
            {
              String _key204;
              ImagePermissions _val205;
              _key204 = iprot.readString();
              _val205 = new ImagePermissions();
              _val205.read(iprot);
              struct.success.put(_key204, _val205);
            }
          }
          struct.setSuccessIsSet(true);
        }
        if (incoming.get(1)) {
          struct.authError = new TAuthorizationException();
          struct.authError.read(iprot);
          struct.setAuthErrorIsSet(true);
        }
        if (incoming.get(2)) {
          struct.notFound = new TNotFoundException();
          struct.notFound.read(iprot);
          struct.setNotFoundIsSet(true);
        }
        if (incoming.get(3)) {
          struct.serverError = new TInternalServerError();
          struct.serverError.read(iprot);
          struct.setServerErrorIsSet(true);
        }
      }
    }

  }

  public static class setImageOwner_args implements org.apache.thrift.TBase<setImageOwner_args, setImageOwner_args._Fields>, java.io.Serializable, Cloneable, Comparable<setImageOwner_args>   {
    private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("setImageOwner_args");

    private static final org.apache.thrift.protocol.TField USER_TOKEN_FIELD_DESC = new org.apache.thrift.protocol.TField("userToken", org.apache.thrift.protocol.TType.STRING, (short)1);
    private static final org.apache.thrift.protocol.TField IMAGE_BASE_ID_FIELD_DESC = new org.apache.thrift.protocol.TField("imageBaseId", org.apache.thrift.protocol.TType.STRING, (short)2);
    private static final org.apache.thrift.protocol.TField NEW_OWNER_ID_FIELD_DESC = new org.apache.thrift.protocol.TField("newOwnerId", org.apache.thrift.protocol.TType.STRING, (short)3);

    private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
    static {
      schemes.put(StandardScheme.class, new setImageOwner_argsStandardSchemeFactory());
      schemes.put(TupleScheme.class, new setImageOwner_argsTupleSchemeFactory());
    }

    public String userToken; // required
    public String imageBaseId; // required
    public String newOwnerId; // required

    /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
    public enum _Fields implements org.apache.thrift.TFieldIdEnum {
      USER_TOKEN((short)1, "userToken"),
      IMAGE_BASE_ID((short)2, "imageBaseId"),
      NEW_OWNER_ID((short)3, "newOwnerId");

      private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();

      static {
        for (_Fields field : EnumSet.allOf(_Fields.class)) {
          byName.put(field.getFieldName(), field);
        }
      }

      /**
       * Find the _Fields constant that matches fieldId, or null if its not found.
       */
      public static _Fields findByThriftId(int fieldId) {
        switch(fieldId) {
          case 1: // USER_TOKEN
            return USER_TOKEN;
          case 2: // IMAGE_BASE_ID
            return IMAGE_BASE_ID;
          case 3: // NEW_OWNER_ID
            return NEW_OWNER_ID;
          default:
            return null;
        }
      }

      /**
       * Find the _Fields constant that matches fieldId, throwing an exception
       * if it is not found.
       */
      public static _Fields findByThriftIdOrThrow(int fieldId) {
        _Fields fields = findByThriftId(fieldId);
        if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
        return fields;
      }

      /**
       * Find the _Fields constant that matches name, or null if its not found.
       */
      public static _Fields findByName(String name) {
        return byName.get(name);
      }

      private final short _thriftId;
      private final String _fieldName;

      _Fields(short thriftId, String fieldName) {
        _thriftId = thriftId;
        _fieldName = fieldName;
      }

      public short getThriftFieldId() {
        return _thriftId;
      }

      public String getFieldName() {
        return _fieldName;
      }
    }

    // isset id assignments
    public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
    static {
      Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
      tmpMap.put(_Fields.USER_TOKEN, new org.apache.thrift.meta_data.FieldMetaData("userToken", org.apache.thrift.TFieldRequirementType.DEFAULT, 
          new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING          , "Token")));
      tmpMap.put(_Fields.IMAGE_BASE_ID, new org.apache.thrift.meta_data.FieldMetaData("imageBaseId", org.apache.thrift.TFieldRequirementType.DEFAULT, 
          new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING          , "UUID")));
      tmpMap.put(_Fields.NEW_OWNER_ID, new org.apache.thrift.meta_data.FieldMetaData("newOwnerId", org.apache.thrift.TFieldRequirementType.DEFAULT, 
          new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING          , "UUID")));
      metaDataMap = Collections.unmodifiableMap(tmpMap);
      org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(setImageOwner_args.class, metaDataMap);
    }

    public setImageOwner_args() {
    }

    public setImageOwner_args(
      String userToken,
      String imageBaseId,
      String newOwnerId)
    {
      this();
      this.userToken = userToken;
      this.imageBaseId = imageBaseId;
      this.newOwnerId = newOwnerId;
    }

    /**
     * Performs a deep copy on <i>other</i>.
     */
    public setImageOwner_args(setImageOwner_args other) {
      if (other.isSetUserToken()) {
        this.userToken = other.userToken;
      }
      if (other.isSetImageBaseId()) {
        this.imageBaseId = other.imageBaseId;
      }
      if (other.isSetNewOwnerId()) {
        this.newOwnerId = other.newOwnerId;
      }
    }

    public setImageOwner_args deepCopy() {
      return new setImageOwner_args(this);
    }

    @Override
    public void clear() {
      this.userToken = null;
      this.imageBaseId = null;
      this.newOwnerId = null;
    }

    public String getUserToken() {
      return this.userToken;
    }

    public setImageOwner_args setUserToken(String userToken) {
      this.userToken = userToken;
      return this;
    }

    public void unsetUserToken() {
      this.userToken = null;
    }

    /** Returns true if field userToken is set (has been assigned a value) and false otherwise */
    public boolean isSetUserToken() {
      return this.userToken != null;
    }

    public void setUserTokenIsSet(boolean value) {
      if (!value) {
        this.userToken = null;
      }
    }

    public String getImageBaseId() {
      return this.imageBaseId;
    }

    public setImageOwner_args setImageBaseId(String imageBaseId) {
      this.imageBaseId = imageBaseId;
      return this;
    }

    public void unsetImageBaseId() {
      this.imageBaseId = null;
    }

    /** Returns true if field imageBaseId is set (has been assigned a value) and false otherwise */
    public boolean isSetImageBaseId() {
      return this.imageBaseId != null;
    }

    public void setImageBaseIdIsSet(boolean value) {
      if (!value) {
        this.imageBaseId = null;
      }
    }

    public String getNewOwnerId() {
      return this.newOwnerId;
    }

    public setImageOwner_args setNewOwnerId(String newOwnerId) {
      this.newOwnerId = newOwnerId;
      return this;
    }

    public void unsetNewOwnerId() {
      this.newOwnerId = null;
    }

    /** Returns true if field newOwnerId is set (has been assigned a value) and false otherwise */
    public boolean isSetNewOwnerId() {
      return this.newOwnerId != null;
    }

    public void setNewOwnerIdIsSet(boolean value) {
      if (!value) {
        this.newOwnerId = null;
      }
    }

    public void setFieldValue(_Fields field, Object value) {
      switch (field) {
      case USER_TOKEN:
        if (value == null) {
          unsetUserToken();
        } else {
          setUserToken((String)value);
        }
        break;

      case IMAGE_BASE_ID:
        if (value == null) {
          unsetImageBaseId();
        } else {
          setImageBaseId((String)value);
        }
        break;

      case NEW_OWNER_ID:
        if (value == null) {
          unsetNewOwnerId();
        } else {
          setNewOwnerId((String)value);
        }
        break;

      }
    }

    public Object getFieldValue(_Fields field) {
      switch (field) {
      case USER_TOKEN:
        return getUserToken();

      case IMAGE_BASE_ID:
        return getImageBaseId();

      case NEW_OWNER_ID:
        return getNewOwnerId();

      }
      throw new IllegalStateException();
    }

    /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
    public boolean isSet(_Fields field) {
      if (field == null) {
        throw new IllegalArgumentException();
      }

      switch (field) {
      case USER_TOKEN:
        return isSetUserToken();
      case IMAGE_BASE_ID:
        return isSetImageBaseId();
      case NEW_OWNER_ID:
        return isSetNewOwnerId();
      }
      throw new IllegalStateException();
    }

    @Override
    public boolean equals(Object that) {
      if (that == null)
        return false;
      if (that instanceof setImageOwner_args)
        return this.equals((setImageOwner_args)that);
      return false;
    }

    public boolean equals(setImageOwner_args that) {
      if (that == null)
        return false;

      boolean this_present_userToken = true && this.isSetUserToken();
      boolean that_present_userToken = true && that.isSetUserToken();
      if (this_present_userToken || that_present_userToken) {
        if (!(this_present_userToken && that_present_userToken))
          return false;
        if (!this.userToken.equals(that.userToken))
          return false;
      }

      boolean this_present_imageBaseId = true && this.isSetImageBaseId();
      boolean that_present_imageBaseId = true && that.isSetImageBaseId();
      if (this_present_imageBaseId || that_present_imageBaseId) {
        if (!(this_present_imageBaseId && that_present_imageBaseId))
          return false;
        if (!this.imageBaseId.equals(that.imageBaseId))
          return false;
      }

      boolean this_present_newOwnerId = true && this.isSetNewOwnerId();
      boolean that_present_newOwnerId = true && that.isSetNewOwnerId();
      if (this_present_newOwnerId || that_present_newOwnerId) {
        if (!(this_present_newOwnerId && that_present_newOwnerId))
          return false;
        if (!this.newOwnerId.equals(that.newOwnerId))
          return false;
      }

      return true;
    }

    @Override
    public int hashCode() {
      return 0;
    }

    @Override
    public int compareTo(setImageOwner_args other) {
      if (!getClass().equals(other.getClass())) {
        return getClass().getName().compareTo(other.getClass().getName());
      }

      int lastComparison = 0;

      lastComparison = Boolean.valueOf(isSetUserToken()).compareTo(other.isSetUserToken());
      if (lastComparison != 0) {
        return lastComparison;
      }
      if (isSetUserToken()) {
        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.userToken, other.userToken);
        if (lastComparison != 0) {
          return lastComparison;
        }
      }
      lastComparison = Boolean.valueOf(isSetImageBaseId()).compareTo(other.isSetImageBaseId());
      if (lastComparison != 0) {
        return lastComparison;
      }
      if (isSetImageBaseId()) {
        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.imageBaseId, other.imageBaseId);
        if (lastComparison != 0) {
          return lastComparison;
        }
      }
      lastComparison = Boolean.valueOf(isSetNewOwnerId()).compareTo(other.isSetNewOwnerId());
      if (lastComparison != 0) {
        return lastComparison;
      }
      if (isSetNewOwnerId()) {
        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.newOwnerId, other.newOwnerId);
        if (lastComparison != 0) {
          return lastComparison;
        }
      }
      return 0;
    }

    public _Fields fieldForId(int fieldId) {
      return _Fields.findByThriftId(fieldId);
    }

    public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
      schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
    }

    public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
      schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
    }

    @Override
    public String toString() {
      StringBuilder sb = new StringBuilder("setImageOwner_args(");
      boolean first = true;

      sb.append("userToken:");
      if (this.userToken == null) {
        sb.append("null");
      } else {
        sb.append(this.userToken);
      }
      first = false;
      if (!first) sb.append(", ");
      sb.append("imageBaseId:");
      if (this.imageBaseId == null) {
        sb.append("null");
      } else {
        sb.append(this.imageBaseId);
      }
      first = false;
      if (!first) sb.append(", ");
      sb.append("newOwnerId:");
      if (this.newOwnerId == null) {
        sb.append("null");
      } else {
        sb.append(this.newOwnerId);
      }
      first = false;
      sb.append(")");
      return sb.toString();
    }

    public void validate() throws org.apache.thrift.TException {
      // check for required fields
      // check for sub-struct validity
    }

    private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
      try {
        write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
      } catch (org.apache.thrift.TException te) {
        throw new java.io.IOException(te);
      }
    }

    private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
      try {
        read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
      } catch (org.apache.thrift.TException te) {
        throw new java.io.IOException(te);
      }
    }

    private static class setImageOwner_argsStandardSchemeFactory implements SchemeFactory {
      public setImageOwner_argsStandardScheme getScheme() {
        return new setImageOwner_argsStandardScheme();
      }
    }

    private static class setImageOwner_argsStandardScheme extends StandardScheme<setImageOwner_args> {

      public void read(org.apache.thrift.protocol.TProtocol iprot, setImageOwner_args struct) throws org.apache.thrift.TException {
        org.apache.thrift.protocol.TField schemeField;
        iprot.readStructBegin();
        while (true)
        {
          schemeField = iprot.readFieldBegin();
          if (schemeField.type == org.apache.thrift.protocol.TType.STOP) { 
            break;
          }
          switch (schemeField.id) {
            case 1: // USER_TOKEN
              if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
                struct.userToken = iprot.readString();
                struct.setUserTokenIsSet(true);
              } else { 
                org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
              }
              break;
            case 2: // IMAGE_BASE_ID
              if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
                struct.imageBaseId = iprot.readString();
                struct.setImageBaseIdIsSet(true);
              } else { 
                org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
              }
              break;
            case 3: // NEW_OWNER_ID
              if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
                struct.newOwnerId = iprot.readString();
                struct.setNewOwnerIdIsSet(true);
              } else { 
                org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
              }
              break;
            default:
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
          }
          iprot.readFieldEnd();
        }
        iprot.readStructEnd();

        // check for required fields of primitive type, which can't be checked in the validate method
        struct.validate();
      }

      public void write(org.apache.thrift.protocol.TProtocol oprot, setImageOwner_args struct) throws org.apache.thrift.TException {
        struct.validate();

        oprot.writeStructBegin(STRUCT_DESC);
        if (struct.userToken != null) {
          oprot.writeFieldBegin(USER_TOKEN_FIELD_DESC);
          oprot.writeString(struct.userToken);
          oprot.writeFieldEnd();
        }
        if (struct.imageBaseId != null) {
          oprot.writeFieldBegin(IMAGE_BASE_ID_FIELD_DESC);
          oprot.writeString(struct.imageBaseId);
          oprot.writeFieldEnd();
        }
        if (struct.newOwnerId != null) {
          oprot.writeFieldBegin(NEW_OWNER_ID_FIELD_DESC);
          oprot.writeString(struct.newOwnerId);
          oprot.writeFieldEnd();
        }
        oprot.writeFieldStop();
        oprot.writeStructEnd();
      }

    }

    private static class setImageOwner_argsTupleSchemeFactory implements SchemeFactory {
      public setImageOwner_argsTupleScheme getScheme() {
        return new setImageOwner_argsTupleScheme();
      }
    }

    private static class setImageOwner_argsTupleScheme extends TupleScheme<setImageOwner_args> {

      @Override
      public void write(org.apache.thrift.protocol.TProtocol prot, setImageOwner_args struct) throws org.apache.thrift.TException {
        TTupleProtocol oprot = (TTupleProtocol) prot;
        BitSet optionals = new BitSet();
        if (struct.isSetUserToken()) {
          optionals.set(0);
        }
        if (struct.isSetImageBaseId()) {
          optionals.set(1);
        }
        if (struct.isSetNewOwnerId()) {
          optionals.set(2);
        }
        oprot.writeBitSet(optionals, 3);
        if (struct.isSetUserToken()) {
          oprot.writeString(struct.userToken);
        }
        if (struct.isSetImageBaseId()) {
          oprot.writeString(struct.imageBaseId);
        }
        if (struct.isSetNewOwnerId()) {
          oprot.writeString(struct.newOwnerId);
        }
      }

      @Override
      public void read(org.apache.thrift.protocol.TProtocol prot, setImageOwner_args struct) throws org.apache.thrift.TException {
        TTupleProtocol iprot = (TTupleProtocol) prot;
        BitSet incoming = iprot.readBitSet(3);
        if (incoming.get(0)) {
          struct.userToken = iprot.readString();
          struct.setUserTokenIsSet(true);
        }
        if (incoming.get(1)) {
          struct.imageBaseId = iprot.readString();
          struct.setImageBaseIdIsSet(true);
        }
        if (incoming.get(2)) {
          struct.newOwnerId = iprot.readString();
          struct.setNewOwnerIdIsSet(true);
        }
      }
    }

  }

  public static class setImageOwner_result implements org.apache.thrift.TBase<setImageOwner_result, setImageOwner_result._Fields>, java.io.Serializable, Cloneable, Comparable<setImageOwner_result>   {
    private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("setImageOwner_result");

    private static final org.apache.thrift.protocol.TField AUTH_ERROR_FIELD_DESC = new org.apache.thrift.protocol.TField("authError", org.apache.thrift.protocol.TType.STRUCT, (short)1);
    private static final org.apache.thrift.protocol.TField NOT_FOUND_FIELD_DESC = new org.apache.thrift.protocol.TField("notFound", org.apache.thrift.protocol.TType.STRUCT, (short)2);
    private static final org.apache.thrift.protocol.TField SERVER_ERROR_FIELD_DESC = new org.apache.thrift.protocol.TField("serverError", org.apache.thrift.protocol.TType.STRUCT, (short)3);

    private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
    static {
      schemes.put(StandardScheme.class, new setImageOwner_resultStandardSchemeFactory());
      schemes.put(TupleScheme.class, new setImageOwner_resultTupleSchemeFactory());
    }

    public TAuthorizationException authError; // required
    public TNotFoundException notFound; // required
    public TInternalServerError serverError; // required

    /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
    public enum _Fields implements org.apache.thrift.TFieldIdEnum {
      AUTH_ERROR((short)1, "authError"),
      NOT_FOUND((short)2, "notFound"),
      SERVER_ERROR((short)3, "serverError");

      private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();

      static {
        for (_Fields field : EnumSet.allOf(_Fields.class)) {
          byName.put(field.getFieldName(), field);
        }
      }

      /**
       * Find the _Fields constant that matches fieldId, or null if its not found.
       */
      public static _Fields findByThriftId(int fieldId) {
        switch(fieldId) {
          case 1: // AUTH_ERROR
            return AUTH_ERROR;
          case 2: // NOT_FOUND
            return NOT_FOUND;
          case 3: // SERVER_ERROR
            return SERVER_ERROR;
          default:
            return null;
        }
      }

      /**
       * Find the _Fields constant that matches fieldId, throwing an exception
       * if it is not found.
       */
      public static _Fields findByThriftIdOrThrow(int fieldId) {
        _Fields fields = findByThriftId(fieldId);
        if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
        return fields;
      }

      /**
       * Find the _Fields constant that matches name, or null if its not found.
       */
      public static _Fields findByName(String name) {
        return byName.get(name);
      }

      private final short _thriftId;
      private final String _fieldName;

      _Fields(short thriftId, String fieldName) {
        _thriftId = thriftId;
        _fieldName = fieldName;
      }

      public short getThriftFieldId() {
        return _thriftId;
      }

      public String getFieldName() {
        return _fieldName;
      }
    }

    // isset id assignments
    public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
    static {
      Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
      tmpMap.put(_Fields.AUTH_ERROR, new org.apache.thrift.meta_data.FieldMetaData("authError", org.apache.thrift.TFieldRequirementType.DEFAULT, 
          new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT)));
      tmpMap.put(_Fields.NOT_FOUND, new org.apache.thrift.meta_data.FieldMetaData("notFound", org.apache.thrift.TFieldRequirementType.DEFAULT, 
          new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT)));
      tmpMap.put(_Fields.SERVER_ERROR, new org.apache.thrift.meta_data.FieldMetaData("serverError", org.apache.thrift.TFieldRequirementType.DEFAULT, 
          new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT)));
      metaDataMap = Collections.unmodifiableMap(tmpMap);
      org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(setImageOwner_result.class, metaDataMap);
    }

    public setImageOwner_result() {
    }

    public setImageOwner_result(
      TAuthorizationException authError,
      TNotFoundException notFound,
      TInternalServerError serverError)
    {
      this();
      this.authError = authError;
      this.notFound = notFound;
      this.serverError = serverError;
    }

    /**
     * Performs a deep copy on <i>other</i>.
     */
    public setImageOwner_result(setImageOwner_result other) {
      if (other.isSetAuthError()) {
        this.authError = new TAuthorizationException(other.authError);
      }
      if (other.isSetNotFound()) {
        this.notFound = new TNotFoundException(other.notFound);
      }
      if (other.isSetServerError()) {
        this.serverError = new TInternalServerError(other.serverError);
      }
    }

    public setImageOwner_result deepCopy() {
      return new setImageOwner_result(this);
    }

    @Override
    public void clear() {
      this.authError = null;
      this.notFound = null;
      this.serverError = null;
    }

    public TAuthorizationException getAuthError() {
      return this.authError;
    }

    public setImageOwner_result setAuthError(TAuthorizationException authError) {
      this.authError = authError;
      return this;
    }

    public void unsetAuthError() {
      this.authError = null;
    }

    /** Returns true if field authError is set (has been assigned a value) and false otherwise */
    public boolean isSetAuthError() {
      return this.authError != null;
    }

    public void setAuthErrorIsSet(boolean value) {
      if (!value) {
        this.authError = null;
      }
    }

    public TNotFoundException getNotFound() {
      return this.notFound;
    }

    public setImageOwner_result setNotFound(TNotFoundException notFound) {
      this.notFound = notFound;
      return this;
    }

    public void unsetNotFound() {
      this.notFound = null;
    }

    /** Returns true if field notFound is set (has been assigned a value) and false otherwise */
    public boolean isSetNotFound() {
      return this.notFound != null;
    }

    public void setNotFoundIsSet(boolean value) {
      if (!value) {
        this.notFound = null;
      }
    }

    public TInternalServerError getServerError() {
      return this.serverError;
    }

    public setImageOwner_result setServerError(TInternalServerError serverError) {
      this.serverError = serverError;
      return this;
    }

    public void unsetServerError() {
      this.serverError = null;
    }

    /** Returns true if field serverError is set (has been assigned a value) and false otherwise */
    public boolean isSetServerError() {
      return this.serverError != null;
    }

    public void setServerErrorIsSet(boolean value) {
      if (!value) {
        this.serverError = null;
      }
    }

    public void setFieldValue(_Fields field, Object value) {
      switch (field) {
      case AUTH_ERROR:
        if (value == null) {
          unsetAuthError();
        } else {
          setAuthError((TAuthorizationException)value);
        }
        break;

      case NOT_FOUND:
        if (value == null) {
          unsetNotFound();
        } else {
          setNotFound((TNotFoundException)value);
        }
        break;

      case SERVER_ERROR:
        if (value == null) {
          unsetServerError();
        } else {
          setServerError((TInternalServerError)value);
        }
        break;

      }
    }

    public Object getFieldValue(_Fields field) {
      switch (field) {
      case AUTH_ERROR:
        return getAuthError();

      case NOT_FOUND:
        return getNotFound();

      case SERVER_ERROR:
        return getServerError();

      }
      throw new IllegalStateException();
    }

    /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
    public boolean isSet(_Fields field) {
      if (field == null) {
        throw new IllegalArgumentException();
      }

      switch (field) {
      case AUTH_ERROR:
        return isSetAuthError();
      case NOT_FOUND:
        return isSetNotFound();
      case SERVER_ERROR:
        return isSetServerError();
      }
      throw new IllegalStateException();
    }

    @Override
    public boolean equals(Object that) {
      if (that == null)
        return false;
      if (that instanceof setImageOwner_result)
        return this.equals((setImageOwner_result)that);
      return false;
    }

    public boolean equals(setImageOwner_result that) {
      if (that == null)
        return false;

      boolean this_present_authError = true && this.isSetAuthError();
      boolean that_present_authError = true && that.isSetAuthError();
      if (this_present_authError || that_present_authError) {
        if (!(this_present_authError && that_present_authError))
          return false;
        if (!this.authError.equals(that.authError))
          return false;
      }

      boolean this_present_notFound = true && this.isSetNotFound();
      boolean that_present_notFound = true && that.isSetNotFound();
      if (this_present_notFound || that_present_notFound) {
        if (!(this_present_notFound && that_present_notFound))
          return false;
        if (!this.notFound.equals(that.notFound))
          return false;
      }

      boolean this_present_serverError = true && this.isSetServerError();
      boolean that_present_serverError = true && that.isSetServerError();
      if (this_present_serverError || that_present_serverError) {
        if (!(this_present_serverError && that_present_serverError))
          return false;
        if (!this.serverError.equals(that.serverError))
          return false;
      }

      return true;
    }

    @Override
    public int hashCode() {
      return 0;
    }

    @Override
    public int compareTo(setImageOwner_result other) {
      if (!getClass().equals(other.getClass())) {
        return getClass().getName().compareTo(other.getClass().getName());
      }

      int lastComparison = 0;

      lastComparison = Boolean.valueOf(isSetAuthError()).compareTo(other.isSetAuthError());
      if (lastComparison != 0) {
        return lastComparison;
      }
      if (isSetAuthError()) {
        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.authError, other.authError);
        if (lastComparison != 0) {
          return lastComparison;
        }
      }
      lastComparison = Boolean.valueOf(isSetNotFound()).compareTo(other.isSetNotFound());
      if (lastComparison != 0) {
        return lastComparison;
      }
      if (isSetNotFound()) {
        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.notFound, other.notFound);
        if (lastComparison != 0) {
          return lastComparison;
        }
      }
      lastComparison = Boolean.valueOf(isSetServerError()).compareTo(other.isSetServerError());
      if (lastComparison != 0) {
        return lastComparison;
      }
      if (isSetServerError()) {
        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.serverError, other.serverError);
        if (lastComparison != 0) {
          return lastComparison;
        }
      }
      return 0;
    }

    public _Fields fieldForId(int fieldId) {
      return _Fields.findByThriftId(fieldId);
    }

    public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
      schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
    }

    public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
      schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
      }

    @Override
    public String toString() {
      StringBuilder sb = new StringBuilder("setImageOwner_result(");
      boolean first = true;

      sb.append("authError:");
      if (this.authError == null) {
        sb.append("null");
      } else {
        sb.append(this.authError);
      }
      first = false;
      if (!first) sb.append(", ");
      sb.append("notFound:");
      if (this.notFound == null) {
        sb.append("null");
      } else {
        sb.append(this.notFound);
      }
      first = false;
      if (!first) sb.append(", ");
      sb.append("serverError:");
      if (this.serverError == null) {
        sb.append("null");
      } else {
        sb.append(this.serverError);
      }
      first = false;
      sb.append(")");
      return sb.toString();
    }

    public void validate() throws org.apache.thrift.TException {
      // check for required fields
      // check for sub-struct validity
    }

    private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
      try {
        write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
      } catch (org.apache.thrift.TException te) {
        throw new java.io.IOException(te);
      }
    }

    private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
      try {
        read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
      } catch (org.apache.thrift.TException te) {
        throw new java.io.IOException(te);
      }
    }

    private static class setImageOwner_resultStandardSchemeFactory implements SchemeFactory {
      public setImageOwner_resultStandardScheme getScheme() {
        return new setImageOwner_resultStandardScheme();
      }
    }

    private static class setImageOwner_resultStandardScheme extends StandardScheme<setImageOwner_result> {

      public void read(org.apache.thrift.protocol.TProtocol iprot, setImageOwner_result struct) throws org.apache.thrift.TException {
        org.apache.thrift.protocol.TField schemeField;
        iprot.readStructBegin();
        while (true)
        {
          schemeField = iprot.readFieldBegin();
          if (schemeField.type == org.apache.thrift.protocol.TType.STOP) { 
            break;
          }
          switch (schemeField.id) {
            case 1: // AUTH_ERROR
              if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
                struct.authError = new TAuthorizationException();
                struct.authError.read(iprot);
                struct.setAuthErrorIsSet(true);
              } else { 
                org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
              }
              break;
            case 2: // NOT_FOUND
              if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
                struct.notFound = new TNotFoundException();
                struct.notFound.read(iprot);
                struct.setNotFoundIsSet(true);
              } else { 
                org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
              }
              break;
            case 3: // SERVER_ERROR
              if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
                struct.serverError = new TInternalServerError();
                struct.serverError.read(iprot);
                struct.setServerErrorIsSet(true);
              } else { 
                org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
              }
              break;
            default:
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
          }
          iprot.readFieldEnd();
        }
        iprot.readStructEnd();

        // check for required fields of primitive type, which can't be checked in the validate method
        struct.validate();
      }

      public void write(org.apache.thrift.protocol.TProtocol oprot, setImageOwner_result struct) throws org.apache.thrift.TException {
        struct.validate();

        oprot.writeStructBegin(STRUCT_DESC);
        if (struct.authError != null) {
          oprot.writeFieldBegin(AUTH_ERROR_FIELD_DESC);
          struct.authError.write(oprot);
          oprot.writeFieldEnd();
        }
        if (struct.notFound != null) {
          oprot.writeFieldBegin(NOT_FOUND_FIELD_DESC);
          struct.notFound.write(oprot);
          oprot.writeFieldEnd();
        }
        if (struct.serverError != null) {
          oprot.writeFieldBegin(SERVER_ERROR_FIELD_DESC);
          struct.serverError.write(oprot);
          oprot.writeFieldEnd();
        }
        oprot.writeFieldStop();
        oprot.writeStructEnd();
      }

    }

    private static class setImageOwner_resultTupleSchemeFactory implements SchemeFactory {
      public setImageOwner_resultTupleScheme getScheme() {
        return new setImageOwner_resultTupleScheme();
      }
    }

    private static class setImageOwner_resultTupleScheme extends TupleScheme<setImageOwner_result> {

      @Override
      public void write(org.apache.thrift.protocol.TProtocol prot, setImageOwner_result struct) throws org.apache.thrift.TException {
        TTupleProtocol oprot = (TTupleProtocol) prot;
        BitSet optionals = new BitSet();
        if (struct.isSetAuthError()) {
          optionals.set(0);
        }
        if (struct.isSetNotFound()) {
          optionals.set(1);
        }
        if (struct.isSetServerError()) {
          optionals.set(2);
        }
        oprot.writeBitSet(optionals, 3);
        if (struct.isSetAuthError()) {
          struct.authError.write(oprot);
        }
        if (struct.isSetNotFound()) {
          struct.notFound.write(oprot);
        }
        if (struct.isSetServerError()) {
          struct.serverError.write(oprot);
        }
      }

      @Override
      public void read(org.apache.thrift.protocol.TProtocol prot, setImageOwner_result struct) throws org.apache.thrift.TException {
        TTupleProtocol iprot = (TTupleProtocol) prot;
        BitSet incoming = iprot.readBitSet(3);
        if (incoming.get(0)) {
          struct.authError = new TAuthorizationException();
          struct.authError.read(iprot);
          struct.setAuthErrorIsSet(true);
        }
        if (incoming.get(1)) {
          struct.notFound = new TNotFoundException();
          struct.notFound.read(iprot);
          struct.setNotFoundIsSet(true);
        }
        if (incoming.get(2)) {
          struct.serverError = new TInternalServerError();
          struct.serverError.read(iprot);
          struct.setServerErrorIsSet(true);
        }
      }
    }

  }

  public static class createLecture_args implements org.apache.thrift.TBase<createLecture_args, createLecture_args._Fields>, java.io.Serializable, Cloneable, Comparable<createLecture_args>   {
    private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("createLecture_args");

    private static final org.apache.thrift.protocol.TField USER_TOKEN_FIELD_DESC = new org.apache.thrift.protocol.TField("userToken", org.apache.thrift.protocol.TType.STRING, (short)1);
    private static final org.apache.thrift.protocol.TField LECTURE_FIELD_DESC = new org.apache.thrift.protocol.TField("lecture", org.apache.thrift.protocol.TType.STRUCT, (short)2);

    private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
    static {
      schemes.put(StandardScheme.class, new createLecture_argsStandardSchemeFactory());
      schemes.put(TupleScheme.class, new createLecture_argsTupleSchemeFactory());
    }

    public String userToken; // required
    public LectureWrite lecture; // required

    /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
    public enum _Fields implements org.apache.thrift.TFieldIdEnum {
      USER_TOKEN((short)1, "userToken"),
      LECTURE((short)2, "lecture");

      private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();

      static {
        for (_Fields field : EnumSet.allOf(_Fields.class)) {
          byName.put(field.getFieldName(), field);
        }
      }

      /**
       * Find the _Fields constant that matches fieldId, or null if its not found.
       */
      public static _Fields findByThriftId(int fieldId) {
        switch(fieldId) {
          case 1: // USER_TOKEN
            return USER_TOKEN;
          case 2: // LECTURE
            return LECTURE;
          default:
            return null;
        }
      }

      /**
       * Find the _Fields constant that matches fieldId, throwing an exception
       * if it is not found.
       */
      public static _Fields findByThriftIdOrThrow(int fieldId) {
        _Fields fields = findByThriftId(fieldId);
        if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
        return fields;
      }

      /**
       * Find the _Fields constant that matches name, or null if its not found.
       */
      public static _Fields findByName(String name) {
        return byName.get(name);
      }

      private final short _thriftId;
      private final String _fieldName;

      _Fields(short thriftId, String fieldName) {
        _thriftId = thriftId;
        _fieldName = fieldName;
      }

      public short getThriftFieldId() {
        return _thriftId;
      }

      public String getFieldName() {
        return _fieldName;
      }
    }

    // isset id assignments
    public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
    static {
      Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
      tmpMap.put(_Fields.USER_TOKEN, new org.apache.thrift.meta_data.FieldMetaData("userToken", org.apache.thrift.TFieldRequirementType.DEFAULT, 
          new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING          , "Token")));
      tmpMap.put(_Fields.LECTURE, new org.apache.thrift.meta_data.FieldMetaData("lecture", org.apache.thrift.TFieldRequirementType.DEFAULT, 
          new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, LectureWrite.class)));
      metaDataMap = Collections.unmodifiableMap(tmpMap);
      org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(createLecture_args.class, metaDataMap);
    }

    public createLecture_args() {
    }

    public createLecture_args(
      String userToken,
      LectureWrite lecture)
    {
      this();
      this.userToken = userToken;
      this.lecture = lecture;
    }

    /**
     * Performs a deep copy on <i>other</i>.
     */
    public createLecture_args(createLecture_args other) {
      if (other.isSetUserToken()) {
        this.userToken = other.userToken;
      }
      if (other.isSetLecture()) {
        this.lecture = new LectureWrite(other.lecture);
      }
    }

    public createLecture_args deepCopy() {
      return new createLecture_args(this);
    }

    @Override
    public void clear() {
      this.userToken = null;
      this.lecture = null;
    }

    public String getUserToken() {
      return this.userToken;
    }

    public createLecture_args setUserToken(String userToken) {
      this.userToken = userToken;
      return this;
    }

    public void unsetUserToken() {
      this.userToken = null;
    }

    /** Returns true if field userToken is set (has been assigned a value) and false otherwise */
    public boolean isSetUserToken() {
      return this.userToken != null;
    }

    public void setUserTokenIsSet(boolean value) {
      if (!value) {
        this.userToken = null;
      }
    }

    public LectureWrite getLecture() {
      return this.lecture;
    }

    public createLecture_args setLecture(LectureWrite lecture) {
      this.lecture = lecture;
      return this;
    }

    public void unsetLecture() {
      this.lecture = null;
    }

    /** Returns true if field lecture is set (has been assigned a value) and false otherwise */
    public boolean isSetLecture() {
      return this.lecture != null;
    }

    public void setLectureIsSet(boolean value) {
      if (!value) {
        this.lecture = null;
      }
    }

    public void setFieldValue(_Fields field, Object value) {
      switch (field) {
      case USER_TOKEN:
        if (value == null) {
          unsetUserToken();
        } else {
          setUserToken((String)value);
        }
        break;

      case LECTURE:
        if (value == null) {
          unsetLecture();
        } else {
          setLecture((LectureWrite)value);
        }
        break;

      }
    }

    public Object getFieldValue(_Fields field) {
      switch (field) {
      case USER_TOKEN:
        return getUserToken();

      case LECTURE:
        return getLecture();

      }
      throw new IllegalStateException();
    }

    /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
    public boolean isSet(_Fields field) {
      if (field == null) {
        throw new IllegalArgumentException();
      }

      switch (field) {
      case USER_TOKEN:
        return isSetUserToken();
      case LECTURE:
        return isSetLecture();
      }
      throw new IllegalStateException();
    }

    @Override
    public boolean equals(Object that) {
      if (that == null)
        return false;
      if (that instanceof createLecture_args)
        return this.equals((createLecture_args)that);
      return false;
    }

    public boolean equals(createLecture_args that) {
      if (that == null)
        return false;

      boolean this_present_userToken = true && this.isSetUserToken();
      boolean that_present_userToken = true && that.isSetUserToken();
      if (this_present_userToken || that_present_userToken) {
        if (!(this_present_userToken && that_present_userToken))
          return false;
        if (!this.userToken.equals(that.userToken))
          return false;
      }

      boolean this_present_lecture = true && this.isSetLecture();
      boolean that_present_lecture = true && that.isSetLecture();
      if (this_present_lecture || that_present_lecture) {
        if (!(this_present_lecture && that_present_lecture))
          return false;
        if (!this.lecture.equals(that.lecture))
          return false;
      }

      return true;
    }

    @Override
    public int hashCode() {
      return 0;
    }

    @Override
    public int compareTo(createLecture_args other) {
      if (!getClass().equals(other.getClass())) {
        return getClass().getName().compareTo(other.getClass().getName());
      }

      int lastComparison = 0;

      lastComparison = Boolean.valueOf(isSetUserToken()).compareTo(other.isSetUserToken());
      if (lastComparison != 0) {
        return lastComparison;
      }
      if (isSetUserToken()) {
        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.userToken, other.userToken);
        if (lastComparison != 0) {
          return lastComparison;
        }
      }
      lastComparison = Boolean.valueOf(isSetLecture()).compareTo(other.isSetLecture());
      if (lastComparison != 0) {
        return lastComparison;
      }
      if (isSetLecture()) {
        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.lecture, other.lecture);
        if (lastComparison != 0) {
          return lastComparison;
        }
      }
      return 0;
    }

    public _Fields fieldForId(int fieldId) {
      return _Fields.findByThriftId(fieldId);
    }

    public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
      schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
    }

    public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
      schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
    }

    @Override
    public String toString() {
      StringBuilder sb = new StringBuilder("createLecture_args(");
      boolean first = true;

      sb.append("userToken:");
      if (this.userToken == null) {
        sb.append("null");
      } else {
        sb.append(this.userToken);
      }
      first = false;
      if (!first) sb.append(", ");
      sb.append("lecture:");
      if (this.lecture == null) {
        sb.append("null");
      } else {
        sb.append(this.lecture);
      }
      first = false;
      sb.append(")");
      return sb.toString();
    }

    public void validate() throws org.apache.thrift.TException {
      // check for required fields
      // check for sub-struct validity
      if (lecture != null) {
        lecture.validate();
      }
    }

    private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
      try {
        write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
      } catch (org.apache.thrift.TException te) {
        throw new java.io.IOException(te);
      }
    }

    private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
      try {
        read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
      } catch (org.apache.thrift.TException te) {
        throw new java.io.IOException(te);
      }
    }

    private static class createLecture_argsStandardSchemeFactory implements SchemeFactory {
      public createLecture_argsStandardScheme getScheme() {
        return new createLecture_argsStandardScheme();
      }
    }

    private static class createLecture_argsStandardScheme extends StandardScheme<createLecture_args> {

      public void read(org.apache.thrift.protocol.TProtocol iprot, createLecture_args struct) throws org.apache.thrift.TException {
        org.apache.thrift.protocol.TField schemeField;
        iprot.readStructBegin();
        while (true)
        {
          schemeField = iprot.readFieldBegin();
          if (schemeField.type == org.apache.thrift.protocol.TType.STOP) { 
            break;
          }
          switch (schemeField.id) {
            case 1: // USER_TOKEN
              if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
                struct.userToken = iprot.readString();
                struct.setUserTokenIsSet(true);
              } else { 
                org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
              }
              break;
            case 2: // LECTURE
              if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
                struct.lecture = new LectureWrite();
                struct.lecture.read(iprot);
                struct.setLectureIsSet(true);
              } else { 
                org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
              }
              break;
            default:
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
          }
          iprot.readFieldEnd();
        }
        iprot.readStructEnd();

        // check for required fields of primitive type, which can't be checked in the validate method
        struct.validate();
      }

      public void write(org.apache.thrift.protocol.TProtocol oprot, createLecture_args struct) throws org.apache.thrift.TException {
        struct.validate();

        oprot.writeStructBegin(STRUCT_DESC);
        if (struct.userToken != null) {
          oprot.writeFieldBegin(USER_TOKEN_FIELD_DESC);
          oprot.writeString(struct.userToken);
          oprot.writeFieldEnd();
        }
        if (struct.lecture != null) {
          oprot.writeFieldBegin(LECTURE_FIELD_DESC);
          struct.lecture.write(oprot);
          oprot.writeFieldEnd();
        }
        oprot.writeFieldStop();
        oprot.writeStructEnd();
      }

    }

    private static class createLecture_argsTupleSchemeFactory implements SchemeFactory {
      public createLecture_argsTupleScheme getScheme() {
        return new createLecture_argsTupleScheme();
      }
    }

    private static class createLecture_argsTupleScheme extends TupleScheme<createLecture_args> {

      @Override
      public void write(org.apache.thrift.protocol.TProtocol prot, createLecture_args struct) throws org.apache.thrift.TException {
        TTupleProtocol oprot = (TTupleProtocol) prot;
        BitSet optionals = new BitSet();
        if (struct.isSetUserToken()) {
          optionals.set(0);
        }
        if (struct.isSetLecture()) {
          optionals.set(1);
        }
        oprot.writeBitSet(optionals, 2);
        if (struct.isSetUserToken()) {
          oprot.writeString(struct.userToken);
        }
        if (struct.isSetLecture()) {
          struct.lecture.write(oprot);
        }
      }

      @Override
      public void read(org.apache.thrift.protocol.TProtocol prot, createLecture_args struct) throws org.apache.thrift.TException {
        TTupleProtocol iprot = (TTupleProtocol) prot;
        BitSet incoming = iprot.readBitSet(2);
        if (incoming.get(0)) {
          struct.userToken = iprot.readString();
          struct.setUserTokenIsSet(true);
        }
        if (incoming.get(1)) {
          struct.lecture = new LectureWrite();
          struct.lecture.read(iprot);
          struct.setLectureIsSet(true);
        }
      }
    }

  }

  public static class createLecture_result implements org.apache.thrift.TBase<createLecture_result, createLecture_result._Fields>, java.io.Serializable, Cloneable, Comparable<createLecture_result>   {
    private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("createLecture_result");

    private static final org.apache.thrift.protocol.TField SUCCESS_FIELD_DESC = new org.apache.thrift.protocol.TField("success", org.apache.thrift.protocol.TType.STRING, (short)0);
    private static final org.apache.thrift.protocol.TField AUTH_ERROR_FIELD_DESC = new org.apache.thrift.protocol.TField("authError", org.apache.thrift.protocol.TType.STRUCT, (short)1);
    private static final org.apache.thrift.protocol.TField SERVER_ERROR_FIELD_DESC = new org.apache.thrift.protocol.TField("serverError", org.apache.thrift.protocol.TType.STRUCT, (short)2);

    private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
    static {
      schemes.put(StandardScheme.class, new createLecture_resultStandardSchemeFactory());
      schemes.put(TupleScheme.class, new createLecture_resultTupleSchemeFactory());
    }

    public String success; // required
    public TAuthorizationException authError; // required
    public TInternalServerError serverError; // required

    /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
    public enum _Fields implements org.apache.thrift.TFieldIdEnum {
      SUCCESS((short)0, "success"),
      AUTH_ERROR((short)1, "authError"),
      SERVER_ERROR((short)2, "serverError");

      private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();

      static {
        for (_Fields field : EnumSet.allOf(_Fields.class)) {
          byName.put(field.getFieldName(), field);
        }
      }

      /**
       * Find the _Fields constant that matches fieldId, or null if its not found.
       */
      public static _Fields findByThriftId(int fieldId) {
        switch(fieldId) {
          case 0: // SUCCESS
            return SUCCESS;
          case 1: // AUTH_ERROR
            return AUTH_ERROR;
          case 2: // SERVER_ERROR
            return SERVER_ERROR;
          default:
            return null;
        }
      }

      /**
       * Find the _Fields constant that matches fieldId, throwing an exception
       * if it is not found.
       */
      public static _Fields findByThriftIdOrThrow(int fieldId) {
        _Fields fields = findByThriftId(fieldId);
        if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
        return fields;
      }

      /**
       * Find the _Fields constant that matches name, or null if its not found.
       */
      public static _Fields findByName(String name) {
        return byName.get(name);
      }

      private final short _thriftId;
      private final String _fieldName;

      _Fields(short thriftId, String fieldName) {
        _thriftId = thriftId;
        _fieldName = fieldName;
      }

      public short getThriftFieldId() {
        return _thriftId;
      }

      public String getFieldName() {
        return _fieldName;
      }
    }

    // isset id assignments
    public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
    static {
      Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
      tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, 
          new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING          , "UUID")));
      tmpMap.put(_Fields.AUTH_ERROR, new org.apache.thrift.meta_data.FieldMetaData("authError", org.apache.thrift.TFieldRequirementType.DEFAULT, 
          new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT)));
      tmpMap.put(_Fields.SERVER_ERROR, new org.apache.thrift.meta_data.FieldMetaData("serverError", org.apache.thrift.TFieldRequirementType.DEFAULT, 
          new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT)));
      metaDataMap = Collections.unmodifiableMap(tmpMap);
      org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(createLecture_result.class, metaDataMap);
    }

    public createLecture_result() {
    }

    public createLecture_result(
      String success,
      TAuthorizationException authError,
      TInternalServerError serverError)
    {
      this();
      this.success = success;
      this.authError = authError;
      this.serverError = serverError;
    }

    /**
     * Performs a deep copy on <i>other</i>.
     */
    public createLecture_result(createLecture_result other) {
      if (other.isSetSuccess()) {
        this.success = other.success;
      }
      if (other.isSetAuthError()) {
        this.authError = new TAuthorizationException(other.authError);
      }
      if (other.isSetServerError()) {
        this.serverError = new TInternalServerError(other.serverError);
      }
    }

    public createLecture_result deepCopy() {
      return new createLecture_result(this);
    }

    @Override
    public void clear() {
      this.success = null;
      this.authError = null;
      this.serverError = null;
    }

    public String getSuccess() {
      return this.success;
    }

    public createLecture_result setSuccess(String success) {
      this.success = success;
      return this;
    }

    public void unsetSuccess() {
      this.success = null;
    }

    /** Returns true if field success is set (has been assigned a value) and false otherwise */
    public boolean isSetSuccess() {
      return this.success != null;
    }

    public void setSuccessIsSet(boolean value) {
      if (!value) {
        this.success = null;
      }
    }

    public TAuthorizationException getAuthError() {
      return this.authError;
    }

    public createLecture_result setAuthError(TAuthorizationException authError) {
      this.authError = authError;
      return this;
    }

    public void unsetAuthError() {
      this.authError = null;
    }

    /** Returns true if field authError is set (has been assigned a value) and false otherwise */
    public boolean isSetAuthError() {
      return this.authError != null;
    }

    public void setAuthErrorIsSet(boolean value) {
      if (!value) {
        this.authError = null;
      }
    }

    public TInternalServerError getServerError() {
      return this.serverError;
    }

    public createLecture_result setServerError(TInternalServerError serverError) {
      this.serverError = serverError;
      return this;
    }

    public void unsetServerError() {
      this.serverError = null;
    }

    /** Returns true if field serverError is set (has been assigned a value) and false otherwise */
    public boolean isSetServerError() {
      return this.serverError != null;
    }

    public void setServerErrorIsSet(boolean value) {
      if (!value) {
        this.serverError = null;
      }
    }

    public void setFieldValue(_Fields field, Object value) {
      switch (field) {
      case SUCCESS:
        if (value == null) {
          unsetSuccess();
        } else {
          setSuccess((String)value);
        }
        break;

      case AUTH_ERROR:
        if (value == null) {
          unsetAuthError();
        } else {
          setAuthError((TAuthorizationException)value);
        }
        break;

      case SERVER_ERROR:
        if (value == null) {
          unsetServerError();
        } else {
          setServerError((TInternalServerError)value);
        }
        break;

      }
    }

    public Object getFieldValue(_Fields field) {
      switch (field) {
      case SUCCESS:
        return getSuccess();

      case AUTH_ERROR:
        return getAuthError();

      case SERVER_ERROR:
        return getServerError();

      }
      throw new IllegalStateException();
    }

    /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
    public boolean isSet(_Fields field) {
      if (field == null) {
        throw new IllegalArgumentException();
      }

      switch (field) {
      case SUCCESS:
        return isSetSuccess();
      case AUTH_ERROR:
        return isSetAuthError();
      case SERVER_ERROR:
        return isSetServerError();
      }
      throw new IllegalStateException();
    }

    @Override
    public boolean equals(Object that) {
      if (that == null)
        return false;
      if (that instanceof createLecture_result)
        return this.equals((createLecture_result)that);
      return false;
    }

    public boolean equals(createLecture_result that) {
      if (that == null)
        return false;

      boolean this_present_success = true && this.isSetSuccess();
      boolean that_present_success = true && that.isSetSuccess();
      if (this_present_success || that_present_success) {
        if (!(this_present_success && that_present_success))
          return false;
        if (!this.success.equals(that.success))
          return false;
      }

      boolean this_present_authError = true && this.isSetAuthError();
      boolean that_present_authError = true && that.isSetAuthError();
      if (this_present_authError || that_present_authError) {
        if (!(this_present_authError && that_present_authError))
          return false;
        if (!this.authError.equals(that.authError))
          return false;
      }

      boolean this_present_serverError = true && this.isSetServerError();
      boolean that_present_serverError = true && that.isSetServerError();
      if (this_present_serverError || that_present_serverError) {
        if (!(this_present_serverError && that_present_serverError))
          return false;
        if (!this.serverError.equals(that.serverError))
          return false;
      }

      return true;
    }

    @Override
    public int hashCode() {
      return 0;
    }

    @Override
    public int compareTo(createLecture_result other) {
      if (!getClass().equals(other.getClass())) {
        return getClass().getName().compareTo(other.getClass().getName());
      }

      int lastComparison = 0;

      lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(other.isSetSuccess());
      if (lastComparison != 0) {
        return lastComparison;
      }
      if (isSetSuccess()) {
        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, other.success);
        if (lastComparison != 0) {
          return lastComparison;
        }
      }
      lastComparison = Boolean.valueOf(isSetAuthError()).compareTo(other.isSetAuthError());
      if (lastComparison != 0) {
        return lastComparison;
      }
      if (isSetAuthError()) {
        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.authError, other.authError);
        if (lastComparison != 0) {
          return lastComparison;
        }
      }
      lastComparison = Boolean.valueOf(isSetServerError()).compareTo(other.isSetServerError());
      if (lastComparison != 0) {
        return lastComparison;
      }
      if (isSetServerError()) {
        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.serverError, other.serverError);
        if (lastComparison != 0) {
          return lastComparison;
        }
      }
      return 0;
    }

    public _Fields fieldForId(int fieldId) {
      return _Fields.findByThriftId(fieldId);
    }

    public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
      schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
    }

    public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
      schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
      }

    @Override
    public String toString() {
      StringBuilder sb = new StringBuilder("createLecture_result(");
      boolean first = true;

      sb.append("success:");
      if (this.success == null) {
        sb.append("null");
      } else {
        sb.append(this.success);
      }
      first = false;
      if (!first) sb.append(", ");
      sb.append("authError:");
      if (this.authError == null) {
        sb.append("null");
      } else {
        sb.append(this.authError);
      }
      first = false;
      if (!first) sb.append(", ");
      sb.append("serverError:");
      if (this.serverError == null) {
        sb.append("null");
      } else {
        sb.append(this.serverError);
      }
      first = false;
      sb.append(")");
      return sb.toString();
    }

    public void validate() throws org.apache.thrift.TException {
      // check for required fields
      // check for sub-struct validity
    }

    private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
      try {
        write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
      } catch (org.apache.thrift.TException te) {
        throw new java.io.IOException(te);
      }
    }

    private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
      try {
        read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
      } catch (org.apache.thrift.TException te) {
        throw new java.io.IOException(te);
      }
    }

    private static class createLecture_resultStandardSchemeFactory implements SchemeFactory {
      public createLecture_resultStandardScheme getScheme() {
        return new createLecture_resultStandardScheme();
      }
    }

    private static class createLecture_resultStandardScheme extends StandardScheme<createLecture_result> {

      public void read(org.apache.thrift.protocol.TProtocol iprot, createLecture_result struct) throws org.apache.thrift.TException {
        org.apache.thrift.protocol.TField schemeField;
        iprot.readStructBegin();
        while (true)
        {
          schemeField = iprot.readFieldBegin();
          if (schemeField.type == org.apache.thrift.protocol.TType.STOP) { 
            break;
          }
          switch (schemeField.id) {
            case 0: // SUCCESS
              if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
                struct.success = iprot.readString();
                struct.setSuccessIsSet(true);
              } else { 
                org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
              }
              break;
            case 1: // AUTH_ERROR
              if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
                struct.authError = new TAuthorizationException();
                struct.authError.read(iprot);
                struct.setAuthErrorIsSet(true);
              } else { 
                org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
              }
              break;
            case 2: // SERVER_ERROR
              if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
                struct.serverError = new TInternalServerError();
                struct.serverError.read(iprot);
                struct.setServerErrorIsSet(true);
              } else { 
                org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
              }
              break;
            default:
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
          }
          iprot.readFieldEnd();
        }
        iprot.readStructEnd();

        // check for required fields of primitive type, which can't be checked in the validate method
        struct.validate();
      }

      public void write(org.apache.thrift.protocol.TProtocol oprot, createLecture_result struct) throws org.apache.thrift.TException {
        struct.validate();

        oprot.writeStructBegin(STRUCT_DESC);
        if (struct.success != null) {
          oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
          oprot.writeString(struct.success);
          oprot.writeFieldEnd();
        }
        if (struct.authError != null) {
          oprot.writeFieldBegin(AUTH_ERROR_FIELD_DESC);
          struct.authError.write(oprot);
          oprot.writeFieldEnd();
        }
        if (struct.serverError != null) {
          oprot.writeFieldBegin(SERVER_ERROR_FIELD_DESC);
          struct.serverError.write(oprot);
          oprot.writeFieldEnd();
        }
        oprot.writeFieldStop();
        oprot.writeStructEnd();
      }

    }

    private static class createLecture_resultTupleSchemeFactory implements SchemeFactory {
      public createLecture_resultTupleScheme getScheme() {
        return new createLecture_resultTupleScheme();
      }
    }

    private static class createLecture_resultTupleScheme extends TupleScheme<createLecture_result> {

      @Override
      public void write(org.apache.thrift.protocol.TProtocol prot, createLecture_result struct) throws org.apache.thrift.TException {
        TTupleProtocol oprot = (TTupleProtocol) prot;
        BitSet optionals = new BitSet();
        if (struct.isSetSuccess()) {
          optionals.set(0);
        }
        if (struct.isSetAuthError()) {
          optionals.set(1);
        }
        if (struct.isSetServerError()) {
          optionals.set(2);
        }
        oprot.writeBitSet(optionals, 3);
        if (struct.isSetSuccess()) {
          oprot.writeString(struct.success);
        }
        if (struct.isSetAuthError()) {
          struct.authError.write(oprot);
        }
        if (struct.isSetServerError()) {
          struct.serverError.write(oprot);
        }
      }

      @Override
      public void read(org.apache.thrift.protocol.TProtocol prot, createLecture_result struct) throws org.apache.thrift.TException {
        TTupleProtocol iprot = (TTupleProtocol) prot;
        BitSet incoming = iprot.readBitSet(3);
        if (incoming.get(0)) {
          struct.success = iprot.readString();
          struct.setSuccessIsSet(true);
        }
        if (incoming.get(1)) {
          struct.authError = new TAuthorizationException();
          struct.authError.read(iprot);
          struct.setAuthErrorIsSet(true);
        }
        if (incoming.get(2)) {
          struct.serverError = new TInternalServerError();
          struct.serverError.read(iprot);
          struct.setServerErrorIsSet(true);
        }
      }
    }

  }

  public static class updateLecture_args implements org.apache.thrift.TBase<updateLecture_args, updateLecture_args._Fields>, java.io.Serializable, Cloneable, Comparable<updateLecture_args>   {
    private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("updateLecture_args");

    private static final org.apache.thrift.protocol.TField USER_TOKEN_FIELD_DESC = new org.apache.thrift.protocol.TField("userToken", org.apache.thrift.protocol.TType.STRING, (short)1);
    private static final org.apache.thrift.protocol.TField LECTURE_ID_FIELD_DESC = new org.apache.thrift.protocol.TField("lectureId", org.apache.thrift.protocol.TType.STRING, (short)2);
    private static final org.apache.thrift.protocol.TField LECTURE_FIELD_DESC = new org.apache.thrift.protocol.TField("lecture", org.apache.thrift.protocol.TType.STRUCT, (short)3);

    private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
    static {
      schemes.put(StandardScheme.class, new updateLecture_argsStandardSchemeFactory());
      schemes.put(TupleScheme.class, new updateLecture_argsTupleSchemeFactory());
    }

    public String userToken; // required
    public String lectureId; // required
    public LectureWrite lecture; // required

    /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
    public enum _Fields implements org.apache.thrift.TFieldIdEnum {
      USER_TOKEN((short)1, "userToken"),
      LECTURE_ID((short)2, "lectureId"),
      LECTURE((short)3, "lecture");

      private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();

      static {
        for (_Fields field : EnumSet.allOf(_Fields.class)) {
          byName.put(field.getFieldName(), field);
        }
      }

      /**
       * Find the _Fields constant that matches fieldId, or null if its not found.
       */
      public static _Fields findByThriftId(int fieldId) {
        switch(fieldId) {
          case 1: // USER_TOKEN
            return USER_TOKEN;
          case 2: // LECTURE_ID
            return LECTURE_ID;
          case 3: // LECTURE
            return LECTURE;
          default:
            return null;
        }
      }

      /**
       * Find the _Fields constant that matches fieldId, throwing an exception
       * if it is not found.
       */
      public static _Fields findByThriftIdOrThrow(int fieldId) {
        _Fields fields = findByThriftId(fieldId);
        if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
        return fields;
      }

      /**
       * Find the _Fields constant that matches name, or null if its not found.
       */
      public static _Fields findByName(String name) {
        return byName.get(name);
      }

      private final short _thriftId;
      private final String _fieldName;

      _Fields(short thriftId, String fieldName) {
        _thriftId = thriftId;
        _fieldName = fieldName;
      }

      public short getThriftFieldId() {
        return _thriftId;
      }

      public String getFieldName() {
        return _fieldName;
      }
    }

    // isset id assignments
    public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
    static {
      Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
      tmpMap.put(_Fields.USER_TOKEN, new org.apache.thrift.meta_data.FieldMetaData("userToken", org.apache.thrift.TFieldRequirementType.DEFAULT, 
          new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING          , "Token")));
      tmpMap.put(_Fields.LECTURE_ID, new org.apache.thrift.meta_data.FieldMetaData("lectureId", org.apache.thrift.TFieldRequirementType.DEFAULT, 
          new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING          , "UUID")));
      tmpMap.put(_Fields.LECTURE, new org.apache.thrift.meta_data.FieldMetaData("lecture", org.apache.thrift.TFieldRequirementType.DEFAULT, 
          new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, LectureWrite.class)));
      metaDataMap = Collections.unmodifiableMap(tmpMap);
      org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(updateLecture_args.class, metaDataMap);
    }

    public updateLecture_args() {
    }

    public updateLecture_args(
      String userToken,
      String lectureId,
      LectureWrite lecture)
    {
      this();
      this.userToken = userToken;
      this.lectureId = lectureId;
      this.lecture = lecture;
    }

    /**
     * Performs a deep copy on <i>other</i>.
     */
    public updateLecture_args(updateLecture_args other) {
      if (other.isSetUserToken()) {
        this.userToken = other.userToken;
      }
      if (other.isSetLectureId()) {
        this.lectureId = other.lectureId;
      }
      if (other.isSetLecture()) {
        this.lecture = new LectureWrite(other.lecture);
      }
    }

    public updateLecture_args deepCopy() {
      return new updateLecture_args(this);
    }

    @Override
    public void clear() {
      this.userToken = null;
      this.lectureId = null;
      this.lecture = null;
    }

    public String getUserToken() {
      return this.userToken;
    }

    public updateLecture_args setUserToken(String userToken) {
      this.userToken = userToken;
      return this;
    }

    public void unsetUserToken() {
      this.userToken = null;
    }

    /** Returns true if field userToken is set (has been assigned a value) and false otherwise */
    public boolean isSetUserToken() {
      return this.userToken != null;
    }

    public void setUserTokenIsSet(boolean value) {
      if (!value) {
        this.userToken = null;
      }
    }

    public String getLectureId() {
      return this.lectureId;
    }

    public updateLecture_args setLectureId(String lectureId) {
      this.lectureId = lectureId;
      return this;
    }

    public void unsetLectureId() {
      this.lectureId = null;
    }

    /** Returns true if field lectureId is set (has been assigned a value) and false otherwise */
    public boolean isSetLectureId() {
      return this.lectureId != null;
    }

    public void setLectureIdIsSet(boolean value) {
      if (!value) {
        this.lectureId = null;
      }
    }

    public LectureWrite getLecture() {
      return this.lecture;
    }

    public updateLecture_args setLecture(LectureWrite lecture) {
      this.lecture = lecture;
      return this;
    }

    public void unsetLecture() {
      this.lecture = null;
    }

    /** Returns true if field lecture is set (has been assigned a value) and false otherwise */
    public boolean isSetLecture() {
      return this.lecture != null;
    }

    public void setLectureIsSet(boolean value) {
      if (!value) {
        this.lecture = null;
      }
    }

    public void setFieldValue(_Fields field, Object value) {
      switch (field) {
      case USER_TOKEN:
        if (value == null) {
          unsetUserToken();
        } else {
          setUserToken((String)value);
        }
        break;

      case LECTURE_ID:
        if (value == null) {
          unsetLectureId();
        } else {
          setLectureId((String)value);
        }
        break;

      case LECTURE:
        if (value == null) {
          unsetLecture();
        } else {
          setLecture((LectureWrite)value);
        }
        break;

      }
    }

    public Object getFieldValue(_Fields field) {
      switch (field) {
      case USER_TOKEN:
        return getUserToken();

      case LECTURE_ID:
        return getLectureId();

      case LECTURE:
        return getLecture();

      }
      throw new IllegalStateException();
    }

    /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
    public boolean isSet(_Fields field) {
      if (field == null) {
        throw new IllegalArgumentException();
      }

      switch (field) {
      case USER_TOKEN:
        return isSetUserToken();
      case LECTURE_ID:
        return isSetLectureId();
      case LECTURE:
        return isSetLecture();
      }
      throw new IllegalStateException();
    }

    @Override
    public boolean equals(Object that) {
      if (that == null)
        return false;
      if (that instanceof updateLecture_args)
        return this.equals((updateLecture_args)that);
      return false;
    }

    public boolean equals(updateLecture_args that) {
      if (that == null)
        return false;

      boolean this_present_userToken = true && this.isSetUserToken();
      boolean that_present_userToken = true && that.isSetUserToken();
      if (this_present_userToken || that_present_userToken) {
        if (!(this_present_userToken && that_present_userToken))
          return false;
        if (!this.userToken.equals(that.userToken))
          return false;
      }

      boolean this_present_lectureId = true && this.isSetLectureId();
      boolean that_present_lectureId = true && that.isSetLectureId();
      if (this_present_lectureId || that_present_lectureId) {
        if (!(this_present_lectureId && that_present_lectureId))
          return false;
        if (!this.lectureId.equals(that.lectureId))
          return false;
      }

      boolean this_present_lecture = true && this.isSetLecture();
      boolean that_present_lecture = true && that.isSetLecture();
      if (this_present_lecture || that_present_lecture) {
        if (!(this_present_lecture && that_present_lecture))
          return false;
        if (!this.lecture.equals(that.lecture))
          return false;
      }

      return true;
    }

    @Override
    public int hashCode() {
      return 0;
    }

    @Override
    public int compareTo(updateLecture_args other) {
      if (!getClass().equals(other.getClass())) {
        return getClass().getName().compareTo(other.getClass().getName());
      }

      int lastComparison = 0;

      lastComparison = Boolean.valueOf(isSetUserToken()).compareTo(other.isSetUserToken());
      if (lastComparison != 0) {
        return lastComparison;
      }
      if (isSetUserToken()) {
        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.userToken, other.userToken);
        if (lastComparison != 0) {
          return lastComparison;
        }
      }
      lastComparison = Boolean.valueOf(isSetLectureId()).compareTo(other.isSetLectureId());
      if (lastComparison != 0) {
        return lastComparison;
      }
      if (isSetLectureId()) {
        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.lectureId, other.lectureId);
        if (lastComparison != 0) {
          return lastComparison;
        }
      }
      lastComparison = Boolean.valueOf(isSetLecture()).compareTo(other.isSetLecture());
      if (lastComparison != 0) {
        return lastComparison;
      }
      if (isSetLecture()) {
        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.lecture, other.lecture);
        if (lastComparison != 0) {
          return lastComparison;
        }
      }
      return 0;
    }

    public _Fields fieldForId(int fieldId) {
      return _Fields.findByThriftId(fieldId);
    }

    public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
      schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
    }

    public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
      schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
    }

    @Override
    public String toString() {
      StringBuilder sb = new StringBuilder("updateLecture_args(");
      boolean first = true;

      sb.append("userToken:");
      if (this.userToken == null) {
        sb.append("null");
      } else {
        sb.append(this.userToken);
      }
      first = false;
      if (!first) sb.append(", ");
      sb.append("lectureId:");
      if (this.lectureId == null) {
        sb.append("null");
      } else {
        sb.append(this.lectureId);
      }
      first = false;
      if (!first) sb.append(", ");
      sb.append("lecture:");
      if (this.lecture == null) {
        sb.append("null");
      } else {
        sb.append(this.lecture);
      }
      first = false;
      sb.append(")");
      return sb.toString();
    }

    public void validate() throws org.apache.thrift.TException {
      // check for required fields
      // check for sub-struct validity
      if (lecture != null) {
        lecture.validate();
      }
    }

    private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
      try {
        write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
      } catch (org.apache.thrift.TException te) {
        throw new java.io.IOException(te);
      }
    }

    private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
      try {
        read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
      } catch (org.apache.thrift.TException te) {
        throw new java.io.IOException(te);
      }
    }

    private static class updateLecture_argsStandardSchemeFactory implements SchemeFactory {
      public updateLecture_argsStandardScheme getScheme() {
        return new updateLecture_argsStandardScheme();
      }
    }

    private static class updateLecture_argsStandardScheme extends StandardScheme<updateLecture_args> {

      public void read(org.apache.thrift.protocol.TProtocol iprot, updateLecture_args struct) throws org.apache.thrift.TException {
        org.apache.thrift.protocol.TField schemeField;
        iprot.readStructBegin();
        while (true)
        {
          schemeField = iprot.readFieldBegin();
          if (schemeField.type == org.apache.thrift.protocol.TType.STOP) { 
            break;
          }
          switch (schemeField.id) {
            case 1: // USER_TOKEN
              if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
                struct.userToken = iprot.readString();
                struct.setUserTokenIsSet(true);
              } else { 
                org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
              }
              break;
            case 2: // LECTURE_ID
              if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
                struct.lectureId = iprot.readString();
                struct.setLectureIdIsSet(true);
              } else { 
                org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
              }
              break;
            case 3: // LECTURE
              if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
                struct.lecture = new LectureWrite();
                struct.lecture.read(iprot);
                struct.setLectureIsSet(true);
              } else { 
                org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
              }
              break;
            default:
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
          }
          iprot.readFieldEnd();
        }
        iprot.readStructEnd();

        // check for required fields of primitive type, which can't be checked in the validate method
        struct.validate();
      }

      public void write(org.apache.thrift.protocol.TProtocol oprot, updateLecture_args struct) throws org.apache.thrift.TException {
        struct.validate();

        oprot.writeStructBegin(STRUCT_DESC);
        if (struct.userToken != null) {
          oprot.writeFieldBegin(USER_TOKEN_FIELD_DESC);
          oprot.writeString(struct.userToken);
          oprot.writeFieldEnd();
        }
        if (struct.lectureId != null) {
          oprot.writeFieldBegin(LECTURE_ID_FIELD_DESC);
          oprot.writeString(struct.lectureId);
          oprot.writeFieldEnd();
        }
        if (struct.lecture != null) {
          oprot.writeFieldBegin(LECTURE_FIELD_DESC);
          struct.lecture.write(oprot);
          oprot.writeFieldEnd();
        }
        oprot.writeFieldStop();
        oprot.writeStructEnd();
      }

    }

    private static class updateLecture_argsTupleSchemeFactory implements SchemeFactory {
      public updateLecture_argsTupleScheme getScheme() {
        return new updateLecture_argsTupleScheme();
      }
    }

    private static class updateLecture_argsTupleScheme extends TupleScheme<updateLecture_args> {

      @Override
      public void write(org.apache.thrift.protocol.TProtocol prot, updateLecture_args struct) throws org.apache.thrift.TException {
        TTupleProtocol oprot = (TTupleProtocol) prot;
        BitSet optionals = new BitSet();
        if (struct.isSetUserToken()) {
          optionals.set(0);
        }
        if (struct.isSetLectureId()) {
          optionals.set(1);
        }
        if (struct.isSetLecture()) {
          optionals.set(2);
        }
        oprot.writeBitSet(optionals, 3);
        if (struct.isSetUserToken()) {
          oprot.writeString(struct.userToken);
        }
        if (struct.isSetLectureId()) {
          oprot.writeString(struct.lectureId);
        }
        if (struct.isSetLecture()) {
          struct.lecture.write(oprot);
        }
      }

      @Override
      public void read(org.apache.thrift.protocol.TProtocol prot, updateLecture_args struct) throws org.apache.thrift.TException {
        TTupleProtocol iprot = (TTupleProtocol) prot;
        BitSet incoming = iprot.readBitSet(3);
        if (incoming.get(0)) {
          struct.userToken = iprot.readString();
          struct.setUserTokenIsSet(true);
        }
        if (incoming.get(1)) {
          struct.lectureId = iprot.readString();
          struct.setLectureIdIsSet(true);
        }
        if (incoming.get(2)) {
          struct.lecture = new LectureWrite();
          struct.lecture.read(iprot);
          struct.setLectureIsSet(true);
        }
      }
    }

  }

  public static class updateLecture_result implements org.apache.thrift.TBase<updateLecture_result, updateLecture_result._Fields>, java.io.Serializable, Cloneable, Comparable<updateLecture_result>   {
    private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("updateLecture_result");

    private static final org.apache.thrift.protocol.TField AUTH_ERROR_FIELD_DESC = new org.apache.thrift.protocol.TField("authError", org.apache.thrift.protocol.TType.STRUCT, (short)1);
    private static final org.apache.thrift.protocol.TField NOT_FOUND_FIELD_DESC = new org.apache.thrift.protocol.TField("notFound", org.apache.thrift.protocol.TType.STRUCT, (short)2);
    private static final org.apache.thrift.protocol.TField SERVER_ERROR_FIELD_DESC = new org.apache.thrift.protocol.TField("serverError", org.apache.thrift.protocol.TType.STRUCT, (short)3);

    private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
    static {
      schemes.put(StandardScheme.class, new updateLecture_resultStandardSchemeFactory());
      schemes.put(TupleScheme.class, new updateLecture_resultTupleSchemeFactory());
    }

    public TAuthorizationException authError; // required
    public TNotFoundException notFound; // required
    public TInternalServerError serverError; // required

    /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
    public enum _Fields implements org.apache.thrift.TFieldIdEnum {
      AUTH_ERROR((short)1, "authError"),
      NOT_FOUND((short)2, "notFound"),
      SERVER_ERROR((short)3, "serverError");

      private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();

      static {
        for (_Fields field : EnumSet.allOf(_Fields.class)) {
          byName.put(field.getFieldName(), field);
        }
      }

      /**
       * Find the _Fields constant that matches fieldId, or null if its not found.
       */
      public static _Fields findByThriftId(int fieldId) {
        switch(fieldId) {
          case 1: // AUTH_ERROR
            return AUTH_ERROR;
          case 2: // NOT_FOUND
            return NOT_FOUND;
          case 3: // SERVER_ERROR
            return SERVER_ERROR;
          default:
            return null;
        }
      }

      /**
       * Find the _Fields constant that matches fieldId, throwing an exception
       * if it is not found.
       */
      public static _Fields findByThriftIdOrThrow(int fieldId) {
        _Fields fields = findByThriftId(fieldId);
        if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
        return fields;
      }

      /**
       * Find the _Fields constant that matches name, or null if its not found.
       */
      public static _Fields findByName(String name) {
        return byName.get(name);
      }

      private final short _thriftId;
      private final String _fieldName;

      _Fields(short thriftId, String fieldName) {
        _thriftId = thriftId;
        _fieldName = fieldName;
      }

      public short getThriftFieldId() {
        return _thriftId;
      }

      public String getFieldName() {
        return _fieldName;
      }
    }

    // isset id assignments
    public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
    static {
      Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
      tmpMap.put(_Fields.AUTH_ERROR, new org.apache.thrift.meta_data.FieldMetaData("authError", org.apache.thrift.TFieldRequirementType.DEFAULT, 
          new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT)));
      tmpMap.put(_Fields.NOT_FOUND, new org.apache.thrift.meta_data.FieldMetaData("notFound", org.apache.thrift.TFieldRequirementType.DEFAULT, 
          new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT)));
      tmpMap.put(_Fields.SERVER_ERROR, new org.apache.thrift.meta_data.FieldMetaData("serverError", org.apache.thrift.TFieldRequirementType.DEFAULT, 
          new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT)));
      metaDataMap = Collections.unmodifiableMap(tmpMap);
      org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(updateLecture_result.class, metaDataMap);
    }

    public updateLecture_result() {
    }

    public updateLecture_result(
      TAuthorizationException authError,
      TNotFoundException notFound,
      TInternalServerError serverError)
    {
      this();
      this.authError = authError;
      this.notFound = notFound;
      this.serverError = serverError;
    }

    /**
     * Performs a deep copy on <i>other</i>.
     */
    public updateLecture_result(updateLecture_result other) {
      if (other.isSetAuthError()) {
        this.authError = new TAuthorizationException(other.authError);
      }
      if (other.isSetNotFound()) {
        this.notFound = new TNotFoundException(other.notFound);
      }
      if (other.isSetServerError()) {
        this.serverError = new TInternalServerError(other.serverError);
      }
    }

    public updateLecture_result deepCopy() {
      return new updateLecture_result(this);
    }

    @Override
    public void clear() {
      this.authError = null;
      this.notFound = null;
      this.serverError = null;
    }

    public TAuthorizationException getAuthError() {
      return this.authError;
    }

    public updateLecture_result setAuthError(TAuthorizationException authError) {
      this.authError = authError;
      return this;
    }

    public void unsetAuthError() {
      this.authError = null;
    }

    /** Returns true if field authError is set (has been assigned a value) and false otherwise */
    public boolean isSetAuthError() {
      return this.authError != null;
    }

    public void setAuthErrorIsSet(boolean value) {
      if (!value) {
        this.authError = null;
      }
    }

    public TNotFoundException getNotFound() {
      return this.notFound;
    }

    public updateLecture_result setNotFound(TNotFoundException notFound) {
      this.notFound = notFound;
      return this;
    }

    public void unsetNotFound() {
      this.notFound = null;
    }

    /** Returns true if field notFound is set (has been assigned a value) and false otherwise */
    public boolean isSetNotFound() {
      return this.notFound != null;
    }

    public void setNotFoundIsSet(boolean value) {
      if (!value) {
        this.notFound = null;
      }
    }

    public TInternalServerError getServerError() {
      return this.serverError;
    }

    public updateLecture_result setServerError(TInternalServerError serverError) {
      this.serverError = serverError;
      return this;
    }

    public void unsetServerError() {
      this.serverError = null;
    }

    /** Returns true if field serverError is set (has been assigned a value) and false otherwise */
    public boolean isSetServerError() {
      return this.serverError != null;
    }

    public void setServerErrorIsSet(boolean value) {
      if (!value) {
        this.serverError = null;
      }
    }

    public void setFieldValue(_Fields field, Object value) {
      switch (field) {
      case AUTH_ERROR:
        if (value == null) {
          unsetAuthError();
        } else {
          setAuthError((TAuthorizationException)value);
        }
        break;

      case NOT_FOUND:
        if (value == null) {
          unsetNotFound();
        } else {
          setNotFound((TNotFoundException)value);
        }
        break;

      case SERVER_ERROR:
        if (value == null) {
          unsetServerError();
        } else {
          setServerError((TInternalServerError)value);
        }
        break;

      }
    }

    public Object getFieldValue(_Fields field) {
      switch (field) {
      case AUTH_ERROR:
        return getAuthError();

      case NOT_FOUND:
        return getNotFound();

      case SERVER_ERROR:
        return getServerError();

      }
      throw new IllegalStateException();
    }

    /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
    public boolean isSet(_Fields field) {
      if (field == null) {
        throw new IllegalArgumentException();
      }

      switch (field) {
      case AUTH_ERROR:
        return isSetAuthError();
      case NOT_FOUND:
        return isSetNotFound();
      case SERVER_ERROR:
        return isSetServerError();
      }
      throw new IllegalStateException();
    }

    @Override
    public boolean equals(Object that) {
      if (that == null)
        return false;
      if (that instanceof updateLecture_result)
        return this.equals((updateLecture_result)that);
      return false;
    }

    public boolean equals(updateLecture_result that) {
      if (that == null)
        return false;

      boolean this_present_authError = true && this.isSetAuthError();
      boolean that_present_authError = true && that.isSetAuthError();
      if (this_present_authError || that_present_authError) {
        if (!(this_present_authError && that_present_authError))
          return false;
        if (!this.authError.equals(that.authError))
          return false;
      }

      boolean this_present_notFound = true && this.isSetNotFound();
      boolean that_present_notFound = true && that.isSetNotFound();
      if (this_present_notFound || that_present_notFound) {
        if (!(this_present_notFound && that_present_notFound))
          return false;
        if (!this.notFound.equals(that.notFound))
          return false;
      }

      boolean this_present_serverError = true && this.isSetServerError();
      boolean that_present_serverError = true && that.isSetServerError();
      if (this_present_serverError || that_present_serverError) {
        if (!(this_present_serverError && that_present_serverError))
          return false;
        if (!this.serverError.equals(that.serverError))
          return false;
      }

      return true;
    }

    @Override
    public int hashCode() {
      return 0;
    }

    @Override
    public int compareTo(updateLecture_result other) {
      if (!getClass().equals(other.getClass())) {
        return getClass().getName().compareTo(other.getClass().getName());
      }

      int lastComparison = 0;

      lastComparison = Boolean.valueOf(isSetAuthError()).compareTo(other.isSetAuthError());
      if (lastComparison != 0) {
        return lastComparison;
      }
      if (isSetAuthError()) {
        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.authError, other.authError);
        if (lastComparison != 0) {
          return lastComparison;
        }
      }
      lastComparison = Boolean.valueOf(isSetNotFound()).compareTo(other.isSetNotFound());
      if (lastComparison != 0) {
        return lastComparison;
      }
      if (isSetNotFound()) {
        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.notFound, other.notFound);
        if (lastComparison != 0) {
          return lastComparison;
        }
      }
      lastComparison = Boolean.valueOf(isSetServerError()).compareTo(other.isSetServerError());
      if (lastComparison != 0) {
        return lastComparison;
      }
      if (isSetServerError()) {
        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.serverError, other.serverError);
        if (lastComparison != 0) {
          return lastComparison;
        }
      }
      return 0;
    }

    public _Fields fieldForId(int fieldId) {
      return _Fields.findByThriftId(fieldId);
    }

    public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
      schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
    }

    public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
      schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
      }

    @Override
    public String toString() {
      StringBuilder sb = new StringBuilder("updateLecture_result(");
      boolean first = true;

      sb.append("authError:");
      if (this.authError == null) {
        sb.append("null");
      } else {
        sb.append(this.authError);
      }
      first = false;
      if (!first) sb.append(", ");
      sb.append("notFound:");
      if (this.notFound == null) {
        sb.append("null");
      } else {
        sb.append(this.notFound);
      }
      first = false;
      if (!first) sb.append(", ");
      sb.append("serverError:");
      if (this.serverError == null) {
        sb.append("null");
      } else {
        sb.append(this.serverError);
      }
      first = false;
      sb.append(")");
      return sb.toString();
    }

    public void validate() throws org.apache.thrift.TException {
      // check for required fields
      // check for sub-struct validity
    }

    private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
      try {
        write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
      } catch (org.apache.thrift.TException te) {
        throw new java.io.IOException(te);
      }
    }

    private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
      try {
        read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
      } catch (org.apache.thrift.TException te) {
        throw new java.io.IOException(te);
      }
    }

    private static class updateLecture_resultStandardSchemeFactory implements SchemeFactory {
      public updateLecture_resultStandardScheme getScheme() {
        return new updateLecture_resultStandardScheme();
      }
    }

    private static class updateLecture_resultStandardScheme extends StandardScheme<updateLecture_result> {

      public void read(org.apache.thrift.protocol.TProtocol iprot, updateLecture_result struct) throws org.apache.thrift.TException {
        org.apache.thrift.protocol.TField schemeField;
        iprot.readStructBegin();
        while (true)
        {
          schemeField = iprot.readFieldBegin();
          if (schemeField.type == org.apache.thrift.protocol.TType.STOP) { 
            break;
          }
          switch (schemeField.id) {
            case 1: // AUTH_ERROR
              if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
                struct.authError = new TAuthorizationException();
                struct.authError.read(iprot);
                struct.setAuthErrorIsSet(true);
              } else { 
                org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
              }
              break;
            case 2: // NOT_FOUND
              if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
                struct.notFound = new TNotFoundException();
                struct.notFound.read(iprot);
                struct.setNotFoundIsSet(true);
              } else { 
                org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
              }
              break;
            case 3: // SERVER_ERROR
              if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
                struct.serverError = new TInternalServerError();
                struct.serverError.read(iprot);
                struct.setServerErrorIsSet(true);
              } else { 
                org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
              }
              break;
            default:
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
          }
          iprot.readFieldEnd();
        }
        iprot.readStructEnd();

        // check for required fields of primitive type, which can't be checked in the validate method
        struct.validate();
      }

      public void write(org.apache.thrift.protocol.TProtocol oprot, updateLecture_result struct) throws org.apache.thrift.TException {
        struct.validate();

        oprot.writeStructBegin(STRUCT_DESC);
        if (struct.authError != null) {
          oprot.writeFieldBegin(AUTH_ERROR_FIELD_DESC);
          struct.authError.write(oprot);
          oprot.writeFieldEnd();
        }
        if (struct.notFound != null) {
          oprot.writeFieldBegin(NOT_FOUND_FIELD_DESC);
          struct.notFound.write(oprot);
          oprot.writeFieldEnd();
        }
        if (struct.serverError != null) {
          oprot.writeFieldBegin(SERVER_ERROR_FIELD_DESC);
          struct.serverError.write(oprot);
          oprot.writeFieldEnd();
        }
        oprot.writeFieldStop();
        oprot.writeStructEnd();
      }

    }

    private static class updateLecture_resultTupleSchemeFactory implements SchemeFactory {
      public updateLecture_resultTupleScheme getScheme() {
        return new updateLecture_resultTupleScheme();
      }
    }

    private static class updateLecture_resultTupleScheme extends TupleScheme<updateLecture_result> {

      @Override
      public void write(org.apache.thrift.protocol.TProtocol prot, updateLecture_result struct) throws org.apache.thrift.TException {
        TTupleProtocol oprot = (TTupleProtocol) prot;
        BitSet optionals = new BitSet();
        if (struct.isSetAuthError()) {
          optionals.set(0);
        }
        if (struct.isSetNotFound()) {
          optionals.set(1);
        }
        if (struct.isSetServerError()) {
          optionals.set(2);
        }
        oprot.writeBitSet(optionals, 3);
        if (struct.isSetAuthError()) {
          struct.authError.write(oprot);
        }
        if (struct.isSetNotFound()) {
          struct.notFound.write(oprot);
        }
        if (struct.isSetServerError()) {
          struct.serverError.write(oprot);
        }
      }

      @Override
      public void read(org.apache.thrift.protocol.TProtocol prot, updateLecture_result struct) throws org.apache.thrift.TException {
        TTupleProtocol iprot = (TTupleProtocol) prot;
        BitSet incoming = iprot.readBitSet(3);
        if (incoming.get(0)) {
          struct.authError = new TAuthorizationException();
          struct.authError.read(iprot);
          struct.setAuthErrorIsSet(true);
        }
        if (incoming.get(1)) {
          struct.notFound = new TNotFoundException();
          struct.notFound.read(iprot);
          struct.setNotFoundIsSet(true);
        }
        if (incoming.get(2)) {
          struct.serverError = new TInternalServerError();
          struct.serverError.read(iprot);
          struct.setServerErrorIsSet(true);
        }
      }
    }

  }

  public static class getLectureList_args implements org.apache.thrift.TBase<getLectureList_args, getLectureList_args._Fields>, java.io.Serializable, Cloneable, Comparable<getLectureList_args>   {
    private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getLectureList_args");

    private static final org.apache.thrift.protocol.TField USER_TOKEN_FIELD_DESC = new org.apache.thrift.protocol.TField("userToken", org.apache.thrift.protocol.TType.STRING, (short)1);
    private static final org.apache.thrift.protocol.TField PAGE_FIELD_DESC = new org.apache.thrift.protocol.TField("page", org.apache.thrift.protocol.TType.I32, (short)2);

    private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
    static {
      schemes.put(StandardScheme.class, new getLectureList_argsStandardSchemeFactory());
      schemes.put(TupleScheme.class, new getLectureList_argsTupleSchemeFactory());
    }

    public String userToken; // required
    public int page; // required

    /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
    public enum _Fields implements org.apache.thrift.TFieldIdEnum {
      USER_TOKEN((short)1, "userToken"),
      PAGE((short)2, "page");

      private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();

      static {
        for (_Fields field : EnumSet.allOf(_Fields.class)) {
          byName.put(field.getFieldName(), field);
        }
      }

      /**
       * Find the _Fields constant that matches fieldId, or null if its not found.
       */
      public static _Fields findByThriftId(int fieldId) {
        switch(fieldId) {
          case 1: // USER_TOKEN
            return USER_TOKEN;
          case 2: // PAGE
            return PAGE;
          default:
            return null;
        }
      }

      /**
       * Find the _Fields constant that matches fieldId, throwing an exception
       * if it is not found.
       */
      public static _Fields findByThriftIdOrThrow(int fieldId) {
        _Fields fields = findByThriftId(fieldId);
        if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
        return fields;
      }

      /**
       * Find the _Fields constant that matches name, or null if its not found.
       */
      public static _Fields findByName(String name) {
        return byName.get(name);
      }

      private final short _thriftId;
      private final String _fieldName;

      _Fields(short thriftId, String fieldName) {
        _thriftId = thriftId;
        _fieldName = fieldName;
      }

      public short getThriftFieldId() {
        return _thriftId;
      }

      public String getFieldName() {
        return _fieldName;
      }
    }

    // isset id assignments
    private static final int __PAGE_ISSET_ID = 0;
    private byte __isset_bitfield = 0;
    public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
    static {
      Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
      tmpMap.put(_Fields.USER_TOKEN, new org.apache.thrift.meta_data.FieldMetaData("userToken", org.apache.thrift.TFieldRequirementType.DEFAULT, 
          new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING          , "Token")));
      tmpMap.put(_Fields.PAGE, new org.apache.thrift.meta_data.FieldMetaData("page", org.apache.thrift.TFieldRequirementType.DEFAULT, 
          new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32)));
      metaDataMap = Collections.unmodifiableMap(tmpMap);
      org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getLectureList_args.class, metaDataMap);
    }

    public getLectureList_args() {
    }

    public getLectureList_args(
      String userToken,
      int page)
    {
      this();
      this.userToken = userToken;
      this.page = page;
      setPageIsSet(true);
    }

    /**
     * Performs a deep copy on <i>other</i>.
     */
    public getLectureList_args(getLectureList_args other) {
      __isset_bitfield = other.__isset_bitfield;
      if (other.isSetUserToken()) {
        this.userToken = other.userToken;
      }
      this.page = other.page;
    }

    public getLectureList_args deepCopy() {
      return new getLectureList_args(this);
    }

    @Override
    public void clear() {
      this.userToken = null;
      setPageIsSet(false);
      this.page = 0;
    }

    public String getUserToken() {
      return this.userToken;
    }

    public getLectureList_args setUserToken(String userToken) {
      this.userToken = userToken;
      return this;
    }

    public void unsetUserToken() {
      this.userToken = null;
    }

    /** Returns true if field userToken is set (has been assigned a value) and false otherwise */
    public boolean isSetUserToken() {
      return this.userToken != null;
    }

    public void setUserTokenIsSet(boolean value) {
      if (!value) {
        this.userToken = null;
      }
    }

    public int getPage() {
      return this.page;
    }

    public getLectureList_args setPage(int page) {
      this.page = page;
      setPageIsSet(true);
      return this;
    }

    public void unsetPage() {
      __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __PAGE_ISSET_ID);
    }

    /** Returns true if field page is set (has been assigned a value) and false otherwise */
    public boolean isSetPage() {
      return EncodingUtils.testBit(__isset_bitfield, __PAGE_ISSET_ID);
    }

    public void setPageIsSet(boolean value) {
      __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __PAGE_ISSET_ID, value);
    }

    public void setFieldValue(_Fields field, Object value) {
      switch (field) {
      case USER_TOKEN:
        if (value == null) {
          unsetUserToken();
        } else {
          setUserToken((String)value);
        }
        break;

      case PAGE:
        if (value == null) {
          unsetPage();
        } else {
          setPage((Integer)value);
        }
        break;

      }
    }

    public Object getFieldValue(_Fields field) {
      switch (field) {
      case USER_TOKEN:
        return getUserToken();

      case PAGE:
        return Integer.valueOf(getPage());

      }
      throw new IllegalStateException();
    }

    /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
    public boolean isSet(_Fields field) {
      if (field == null) {
        throw new IllegalArgumentException();
      }

      switch (field) {
      case USER_TOKEN:
        return isSetUserToken();
      case PAGE:
        return isSetPage();
      }
      throw new IllegalStateException();
    }

    @Override
    public boolean equals(Object that) {
      if (that == null)
        return false;
      if (that instanceof getLectureList_args)
        return this.equals((getLectureList_args)that);
      return false;
    }

    public boolean equals(getLectureList_args that) {
      if (that == null)
        return false;

      boolean this_present_userToken = true && this.isSetUserToken();
      boolean that_present_userToken = true && that.isSetUserToken();
      if (this_present_userToken || that_present_userToken) {
        if (!(this_present_userToken && that_present_userToken))
          return false;
        if (!this.userToken.equals(that.userToken))
          return false;
      }

      boolean this_present_page = true;
      boolean that_present_page = true;
      if (this_present_page || that_present_page) {
        if (!(this_present_page && that_present_page))
          return false;
        if (this.page != that.page)
          return false;
      }

      return true;
    }

    @Override
    public int hashCode() {
      return 0;
    }

    @Override
    public int compareTo(getLectureList_args other) {
      if (!getClass().equals(other.getClass())) {
        return getClass().getName().compareTo(other.getClass().getName());
      }

      int lastComparison = 0;

      lastComparison = Boolean.valueOf(isSetUserToken()).compareTo(other.isSetUserToken());
      if (lastComparison != 0) {
        return lastComparison;
      }
      if (isSetUserToken()) {
        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.userToken, other.userToken);
        if (lastComparison != 0) {
          return lastComparison;
        }
      }
      lastComparison = Boolean.valueOf(isSetPage()).compareTo(other.isSetPage());
      if (lastComparison != 0) {
        return lastComparison;
      }
      if (isSetPage()) {
        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.page, other.page);
        if (lastComparison != 0) {
          return lastComparison;
        }
      }
      return 0;
    }

    public _Fields fieldForId(int fieldId) {
      return _Fields.findByThriftId(fieldId);
    }

    public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
      schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
    }

    public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
      schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
    }

    @Override
    public String toString() {
      StringBuilder sb = new StringBuilder("getLectureList_args(");
      boolean first = true;

      sb.append("userToken:");
      if (this.userToken == null) {
        sb.append("null");
      } else {
        sb.append(this.userToken);
      }
      first = false;
      if (!first) sb.append(", ");
      sb.append("page:");
      sb.append(this.page);
      first = false;
      sb.append(")");
      return sb.toString();
    }

    public void validate() throws org.apache.thrift.TException {
      // check for required fields
      // check for sub-struct validity
    }

    private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
      try {
        write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
      } catch (org.apache.thrift.TException te) {
        throw new java.io.IOException(te);
      }
    }

    private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
      try {
        // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor.
        __isset_bitfield = 0;
        read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
      } catch (org.apache.thrift.TException te) {
        throw new java.io.IOException(te);
      }
    }

    private static class getLectureList_argsStandardSchemeFactory implements SchemeFactory {
      public getLectureList_argsStandardScheme getScheme() {
        return new getLectureList_argsStandardScheme();
      }
    }

    private static class getLectureList_argsStandardScheme extends StandardScheme<getLectureList_args> {

      public void read(org.apache.thrift.protocol.TProtocol iprot, getLectureList_args struct) throws org.apache.thrift.TException {
        org.apache.thrift.protocol.TField schemeField;
        iprot.readStructBegin();
        while (true)
        {
          schemeField = iprot.readFieldBegin();
          if (schemeField.type == org.apache.thrift.protocol.TType.STOP) { 
            break;
          }
          switch (schemeField.id) {
            case 1: // USER_TOKEN
              if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
                struct.userToken = iprot.readString();
                struct.setUserTokenIsSet(true);
              } else { 
                org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
              }
              break;
            case 2: // PAGE
              if (schemeField.type == org.apache.thrift.protocol.TType.I32) {
                struct.page = iprot.readI32();
                struct.setPageIsSet(true);
              } else { 
                org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
              }
              break;
            default:
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
          }
          iprot.readFieldEnd();
        }
        iprot.readStructEnd();

        // check for required fields of primitive type, which can't be checked in the validate method
        struct.validate();
      }

      public void write(org.apache.thrift.protocol.TProtocol oprot, getLectureList_args struct) throws org.apache.thrift.TException {
        struct.validate();

        oprot.writeStructBegin(STRUCT_DESC);
        if (struct.userToken != null) {
          oprot.writeFieldBegin(USER_TOKEN_FIELD_DESC);
          oprot.writeString(struct.userToken);
          oprot.writeFieldEnd();
        }
        oprot.writeFieldBegin(PAGE_FIELD_DESC);
        oprot.writeI32(struct.page);
        oprot.writeFieldEnd();
        oprot.writeFieldStop();
        oprot.writeStructEnd();
      }

    }

    private static class getLectureList_argsTupleSchemeFactory implements SchemeFactory {
      public getLectureList_argsTupleScheme getScheme() {
        return new getLectureList_argsTupleScheme();
      }
    }

    private static class getLectureList_argsTupleScheme extends TupleScheme<getLectureList_args> {

      @Override
      public void write(org.apache.thrift.protocol.TProtocol prot, getLectureList_args struct) throws org.apache.thrift.TException {
        TTupleProtocol oprot = (TTupleProtocol) prot;
        BitSet optionals = new BitSet();
        if (struct.isSetUserToken()) {
          optionals.set(0);
        }
        if (struct.isSetPage()) {
          optionals.set(1);
        }
        oprot.writeBitSet(optionals, 2);
        if (struct.isSetUserToken()) {
          oprot.writeString(struct.userToken);
        }
        if (struct.isSetPage()) {
          oprot.writeI32(struct.page);
        }
      }

      @Override
      public void read(org.apache.thrift.protocol.TProtocol prot, getLectureList_args struct) throws org.apache.thrift.TException {
        TTupleProtocol iprot = (TTupleProtocol) prot;
        BitSet incoming = iprot.readBitSet(2);
        if (incoming.get(0)) {
          struct.userToken = iprot.readString();
          struct.setUserTokenIsSet(true);
        }
        if (incoming.get(1)) {
          struct.page = iprot.readI32();
          struct.setPageIsSet(true);
        }
      }
    }

  }

  public static class getLectureList_result implements org.apache.thrift.TBase<getLectureList_result, getLectureList_result._Fields>, java.io.Serializable, Cloneable, Comparable<getLectureList_result>   {
    private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getLectureList_result");

    private static final org.apache.thrift.protocol.TField SUCCESS_FIELD_DESC = new org.apache.thrift.protocol.TField("success", org.apache.thrift.protocol.TType.LIST, (short)0);
    private static final org.apache.thrift.protocol.TField AUTH_ERROR_FIELD_DESC = new org.apache.thrift.protocol.TField("authError", org.apache.thrift.protocol.TType.STRUCT, (short)1);
    private static final org.apache.thrift.protocol.TField SERVER_ERROR_FIELD_DESC = new org.apache.thrift.protocol.TField("serverError", org.apache.thrift.protocol.TType.STRUCT, (short)2);

    private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
    static {
      schemes.put(StandardScheme.class, new getLectureList_resultStandardSchemeFactory());
      schemes.put(TupleScheme.class, new getLectureList_resultTupleSchemeFactory());
    }

    public List<LectureSummary> success; // required
    public TAuthorizationException authError; // required
    public TInternalServerError serverError; // required

    /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
    public enum _Fields implements org.apache.thrift.TFieldIdEnum {
      SUCCESS((short)0, "success"),
      AUTH_ERROR((short)1, "authError"),
      SERVER_ERROR((short)2, "serverError");

      private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();

      static {
        for (_Fields field : EnumSet.allOf(_Fields.class)) {
          byName.put(field.getFieldName(), field);
        }
      }

      /**
       * Find the _Fields constant that matches fieldId, or null if its not found.
       */
      public static _Fields findByThriftId(int fieldId) {
        switch(fieldId) {
          case 0: // SUCCESS
            return SUCCESS;
          case 1: // AUTH_ERROR
            return AUTH_ERROR;
          case 2: // SERVER_ERROR
            return SERVER_ERROR;
          default:
            return null;
        }
      }

      /**
       * Find the _Fields constant that matches fieldId, throwing an exception
       * if it is not found.
       */
      public static _Fields findByThriftIdOrThrow(int fieldId) {
        _Fields fields = findByThriftId(fieldId);
        if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
        return fields;
      }

      /**
       * Find the _Fields constant that matches name, or null if its not found.
       */
      public static _Fields findByName(String name) {
        return byName.get(name);
      }

      private final short _thriftId;
      private final String _fieldName;

      _Fields(short thriftId, String fieldName) {
        _thriftId = thriftId;
        _fieldName = fieldName;
      }

      public short getThriftFieldId() {
        return _thriftId;
      }

      public String getFieldName() {
        return _fieldName;
      }
    }

    // isset id assignments
    public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
    static {
      Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
      tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, 
          new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST, 
              new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, LectureSummary.class))));
      tmpMap.put(_Fields.AUTH_ERROR, new org.apache.thrift.meta_data.FieldMetaData("authError", org.apache.thrift.TFieldRequirementType.DEFAULT, 
          new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT)));
      tmpMap.put(_Fields.SERVER_ERROR, new org.apache.thrift.meta_data.FieldMetaData("serverError", org.apache.thrift.TFieldRequirementType.DEFAULT, 
          new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT)));
      metaDataMap = Collections.unmodifiableMap(tmpMap);
      org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getLectureList_result.class, metaDataMap);
    }

    public getLectureList_result() {
    }

    public getLectureList_result(
      List<LectureSummary> success,
      TAuthorizationException authError,
      TInternalServerError serverError)
    {
      this();
      this.success = success;
      this.authError = authError;
      this.serverError = serverError;
    }

    /**
     * Performs a deep copy on <i>other</i>.
     */
    public getLectureList_result(getLectureList_result other) {
      if (other.isSetSuccess()) {
        List<LectureSummary> __this__success = new ArrayList<LectureSummary>(other.success.size());
        for (LectureSummary other_element : other.success) {
          __this__success.add(new LectureSummary(other_element));
        }
        this.success = __this__success;
      }
      if (other.isSetAuthError()) {
        this.authError = new TAuthorizationException(other.authError);
      }
      if (other.isSetServerError()) {
        this.serverError = new TInternalServerError(other.serverError);
      }
    }

    public getLectureList_result deepCopy() {
      return new getLectureList_result(this);
    }

    @Override
    public void clear() {
      this.success = null;
      this.authError = null;
      this.serverError = null;
    }

    public int getSuccessSize() {
      return (this.success == null) ? 0 : this.success.size();
    }

    public java.util.Iterator<LectureSummary> getSuccessIterator() {
      return (this.success == null) ? null : this.success.iterator();
    }

    public void addToSuccess(LectureSummary elem) {
      if (this.success == null) {
        this.success = new ArrayList<LectureSummary>();
      }
      this.success.add(elem);
    }

    public List<LectureSummary> getSuccess() {
      return this.success;
    }

    public getLectureList_result setSuccess(List<LectureSummary> success) {
      this.success = success;
      return this;
    }

    public void unsetSuccess() {
      this.success = null;
    }

    /** Returns true if field success is set (has been assigned a value) and false otherwise */
    public boolean isSetSuccess() {
      return this.success != null;
    }

    public void setSuccessIsSet(boolean value) {
      if (!value) {
        this.success = null;
      }
    }

    public TAuthorizationException getAuthError() {
      return this.authError;
    }

    public getLectureList_result setAuthError(TAuthorizationException authError) {
      this.authError = authError;
      return this;
    }

    public void unsetAuthError() {
      this.authError = null;
    }

    /** Returns true if field authError is set (has been assigned a value) and false otherwise */
    public boolean isSetAuthError() {
      return this.authError != null;
    }

    public void setAuthErrorIsSet(boolean value) {
      if (!value) {
        this.authError = null;
      }
    }

    public TInternalServerError getServerError() {
      return this.serverError;
    }

    public getLectureList_result setServerError(TInternalServerError serverError) {
      this.serverError = serverError;
      return this;
    }

    public void unsetServerError() {
      this.serverError = null;
    }

    /** Returns true if field serverError is set (has been assigned a value) and false otherwise */
    public boolean isSetServerError() {
      return this.serverError != null;
    }

    public void setServerErrorIsSet(boolean value) {
      if (!value) {
        this.serverError = null;
      }
    }

    public void setFieldValue(_Fields field, Object value) {
      switch (field) {
      case SUCCESS:
        if (value == null) {
          unsetSuccess();
        } else {
          setSuccess((List<LectureSummary>)value);
        }
        break;

      case AUTH_ERROR:
        if (value == null) {
          unsetAuthError();
        } else {
          setAuthError((TAuthorizationException)value);
        }
        break;

      case SERVER_ERROR:
        if (value == null) {
          unsetServerError();
        } else {
          setServerError((TInternalServerError)value);
        }
        break;

      }
    }

    public Object getFieldValue(_Fields field) {
      switch (field) {
      case SUCCESS:
        return getSuccess();

      case AUTH_ERROR:
        return getAuthError();

      case SERVER_ERROR:
        return getServerError();

      }
      throw new IllegalStateException();
    }

    /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
    public boolean isSet(_Fields field) {
      if (field == null) {
        throw new IllegalArgumentException();
      }

      switch (field) {
      case SUCCESS:
        return isSetSuccess();
      case AUTH_ERROR:
        return isSetAuthError();
      case SERVER_ERROR:
        return isSetServerError();
      }
      throw new IllegalStateException();
    }

    @Override
    public boolean equals(Object that) {
      if (that == null)
        return false;
      if (that instanceof getLectureList_result)
        return this.equals((getLectureList_result)that);
      return false;
    }

    public boolean equals(getLectureList_result that) {
      if (that == null)
        return false;

      boolean this_present_success = true && this.isSetSuccess();
      boolean that_present_success = true && that.isSetSuccess();
      if (this_present_success || that_present_success) {
        if (!(this_present_success && that_present_success))
          return false;
        if (!this.success.equals(that.success))
          return false;
      }

      boolean this_present_authError = true && this.isSetAuthError();
      boolean that_present_authError = true && that.isSetAuthError();
      if (this_present_authError || that_present_authError) {
        if (!(this_present_authError && that_present_authError))
          return false;
        if (!this.authError.equals(that.authError))
          return false;
      }

      boolean this_present_serverError = true && this.isSetServerError();
      boolean that_present_serverError = true && that.isSetServerError();
      if (this_present_serverError || that_present_serverError) {
        if (!(this_present_serverError && that_present_serverError))
          return false;
        if (!this.serverError.equals(that.serverError))
          return false;
      }

      return true;
    }

    @Override
    public int hashCode() {
      return 0;
    }

    @Override
    public int compareTo(getLectureList_result other) {
      if (!getClass().equals(other.getClass())) {
        return getClass().getName().compareTo(other.getClass().getName());
      }

      int lastComparison = 0;

      lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(other.isSetSuccess());
      if (lastComparison != 0) {
        return lastComparison;
      }
      if (isSetSuccess()) {
        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, other.success);
        if (lastComparison != 0) {
          return lastComparison;
        }
      }
      lastComparison = Boolean.valueOf(isSetAuthError()).compareTo(other.isSetAuthError());
      if (lastComparison != 0) {
        return lastComparison;
      }
      if (isSetAuthError()) {
        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.authError, other.authError);
        if (lastComparison != 0) {
          return lastComparison;
        }
      }
      lastComparison = Boolean.valueOf(isSetServerError()).compareTo(other.isSetServerError());
      if (lastComparison != 0) {
        return lastComparison;
      }
      if (isSetServerError()) {
        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.serverError, other.serverError);
        if (lastComparison != 0) {
          return lastComparison;
        }
      }
      return 0;
    }

    public _Fields fieldForId(int fieldId) {
      return _Fields.findByThriftId(fieldId);
    }

    public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
      schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
    }

    public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
      schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
      }

    @Override
    public String toString() {
      StringBuilder sb = new StringBuilder("getLectureList_result(");
      boolean first = true;

      sb.append("success:");
      if (this.success == null) {
        sb.append("null");
      } else {
        sb.append(this.success);
      }
      first = false;
      if (!first) sb.append(", ");
      sb.append("authError:");
      if (this.authError == null) {
        sb.append("null");
      } else {
        sb.append(this.authError);
      }
      first = false;
      if (!first) sb.append(", ");
      sb.append("serverError:");
      if (this.serverError == null) {
        sb.append("null");
      } else {
        sb.append(this.serverError);
      }
      first = false;
      sb.append(")");
      return sb.toString();
    }

    public void validate() throws org.apache.thrift.TException {
      // check for required fields
      // check for sub-struct validity
    }

    private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
      try {
        write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
      } catch (org.apache.thrift.TException te) {
        throw new java.io.IOException(te);
      }
    }

    private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
      try {
        read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
      } catch (org.apache.thrift.TException te) {
        throw new java.io.IOException(te);
      }
    }

    private static class getLectureList_resultStandardSchemeFactory implements SchemeFactory {
      public getLectureList_resultStandardScheme getScheme() {
        return new getLectureList_resultStandardScheme();
      }
    }

    private static class getLectureList_resultStandardScheme extends StandardScheme<getLectureList_result> {

      public void read(org.apache.thrift.protocol.TProtocol iprot, getLectureList_result struct) throws org.apache.thrift.TException {
        org.apache.thrift.protocol.TField schemeField;
        iprot.readStructBegin();
        while (true)
        {
          schemeField = iprot.readFieldBegin();
          if (schemeField.type == org.apache.thrift.protocol.TType.STOP) { 
            break;
          }
          switch (schemeField.id) {
            case 0: // SUCCESS
              if (schemeField.type == org.apache.thrift.protocol.TType.LIST) {
                {
                  org.apache.thrift.protocol.TList _list206 = iprot.readListBegin();
                  struct.success = new ArrayList<LectureSummary>(_list206.size);
                  for (int _i207 = 0; _i207 < _list206.size; ++_i207)
                  {
                    LectureSummary _elem208;
                    _elem208 = new LectureSummary();
                    _elem208.read(iprot);
                    struct.success.add(_elem208);
                  }
                  iprot.readListEnd();
                }
                struct.setSuccessIsSet(true);
              } else { 
                org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
              }
              break;
            case 1: // AUTH_ERROR
              if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
                struct.authError = new TAuthorizationException();
                struct.authError.read(iprot);
                struct.setAuthErrorIsSet(true);
              } else { 
                org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
              }
              break;
            case 2: // SERVER_ERROR
              if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
                struct.serverError = new TInternalServerError();
                struct.serverError.read(iprot);
                struct.setServerErrorIsSet(true);
              } else { 
                org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
              }
              break;
            default:
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
          }
          iprot.readFieldEnd();
        }
        iprot.readStructEnd();

        // check for required fields of primitive type, which can't be checked in the validate method
        struct.validate();
      }

      public void write(org.apache.thrift.protocol.TProtocol oprot, getLectureList_result struct) throws org.apache.thrift.TException {
        struct.validate();

        oprot.writeStructBegin(STRUCT_DESC);
        if (struct.success != null) {
          oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
          {
            oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.success.size()));
            for (LectureSummary _iter209 : struct.success)
            {
              _iter209.write(oprot);
            }
            oprot.writeListEnd();
          }
          oprot.writeFieldEnd();
        }
        if (struct.authError != null) {
          oprot.writeFieldBegin(AUTH_ERROR_FIELD_DESC);
          struct.authError.write(oprot);
          oprot.writeFieldEnd();
        }
        if (struct.serverError != null) {
          oprot.writeFieldBegin(SERVER_ERROR_FIELD_DESC);
          struct.serverError.write(oprot);
          oprot.writeFieldEnd();
        }
        oprot.writeFieldStop();
        oprot.writeStructEnd();
      }

    }

    private static class getLectureList_resultTupleSchemeFactory implements SchemeFactory {
      public getLectureList_resultTupleScheme getScheme() {
        return new getLectureList_resultTupleScheme();
      }
    }

    private static class getLectureList_resultTupleScheme extends TupleScheme<getLectureList_result> {

      @Override
      public void write(org.apache.thrift.protocol.TProtocol prot, getLectureList_result struct) throws org.apache.thrift.TException {
        TTupleProtocol oprot = (TTupleProtocol) prot;
        BitSet optionals = new BitSet();
        if (struct.isSetSuccess()) {
          optionals.set(0);
        }
        if (struct.isSetAuthError()) {
          optionals.set(1);
        }
        if (struct.isSetServerError()) {
          optionals.set(2);
        }
        oprot.writeBitSet(optionals, 3);
        if (struct.isSetSuccess()) {
          {
            oprot.writeI32(struct.success.size());
            for (LectureSummary _iter210 : struct.success)
            {
              _iter210.write(oprot);
            }
          }
        }
        if (struct.isSetAuthError()) {
          struct.authError.write(oprot);
        }
        if (struct.isSetServerError()) {
          struct.serverError.write(oprot);
        }
      }

      @Override
      public void read(org.apache.thrift.protocol.TProtocol prot, getLectureList_result struct) throws org.apache.thrift.TException {
        TTupleProtocol iprot = (TTupleProtocol) prot;
        BitSet incoming = iprot.readBitSet(3);
        if (incoming.get(0)) {
          {
            org.apache.thrift.protocol.TList _list211 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32());
            struct.success = new ArrayList<LectureSummary>(_list211.size);
            for (int _i212 = 0; _i212 < _list211.size; ++_i212)
            {
              LectureSummary _elem213;
              _elem213 = new LectureSummary();
              _elem213.read(iprot);
              struct.success.add(_elem213);
            }
          }
          struct.setSuccessIsSet(true);
        }
        if (incoming.get(1)) {
          struct.authError = new TAuthorizationException();
          struct.authError.read(iprot);
          struct.setAuthErrorIsSet(true);
        }
        if (incoming.get(2)) {
          struct.serverError = new TInternalServerError();
          struct.serverError.read(iprot);
          struct.setServerErrorIsSet(true);
        }
      }
    }

  }

  public static class getLectureDetails_args implements org.apache.thrift.TBase<getLectureDetails_args, getLectureDetails_args._Fields>, java.io.Serializable, Cloneable, Comparable<getLectureDetails_args>   {
    private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getLectureDetails_args");

    private static final org.apache.thrift.protocol.TField USER_TOKEN_FIELD_DESC = new org.apache.thrift.protocol.TField("userToken", org.apache.thrift.protocol.TType.STRING, (short)1);
    private static final org.apache.thrift.protocol.TField LECTURE_ID_FIELD_DESC = new org.apache.thrift.protocol.TField("lectureId", org.apache.thrift.protocol.TType.STRING, (short)2);

    private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
    static {
      schemes.put(StandardScheme.class, new getLectureDetails_argsStandardSchemeFactory());
      schemes.put(TupleScheme.class, new getLectureDetails_argsTupleSchemeFactory());
    }

    public String userToken; // required
    public String lectureId; // required

    /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
    public enum _Fields implements org.apache.thrift.TFieldIdEnum {
      USER_TOKEN((short)1, "userToken"),
      LECTURE_ID((short)2, "lectureId");

      private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();

      static {
        for (_Fields field : EnumSet.allOf(_Fields.class)) {
          byName.put(field.getFieldName(), field);
        }
      }

      /**
       * Find the _Fields constant that matches fieldId, or null if its not found.
       */
      public static _Fields findByThriftId(int fieldId) {
        switch(fieldId) {
          case 1: // USER_TOKEN
            return USER_TOKEN;
          case 2: // LECTURE_ID
            return LECTURE_ID;
          default:
            return null;
        }
      }

      /**
       * Find the _Fields constant that matches fieldId, throwing an exception
       * if it is not found.
       */
      public static _Fields findByThriftIdOrThrow(int fieldId) {
        _Fields fields = findByThriftId(fieldId);
        if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
        return fields;
      }

      /**
       * Find the _Fields constant that matches name, or null if its not found.
       */
      public static _Fields findByName(String name) {
        return byName.get(name);
      }

      private final short _thriftId;
      private final String _fieldName;

      _Fields(short thriftId, String fieldName) {
        _thriftId = thriftId;
        _fieldName = fieldName;
      }

      public short getThriftFieldId() {
        return _thriftId;
      }

      public String getFieldName() {
        return _fieldName;
      }
    }

    // isset id assignments
    public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
    static {
      Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
      tmpMap.put(_Fields.USER_TOKEN, new org.apache.thrift.meta_data.FieldMetaData("userToken", org.apache.thrift.TFieldRequirementType.DEFAULT, 
          new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING          , "Token")));
      tmpMap.put(_Fields.LECTURE_ID, new org.apache.thrift.meta_data.FieldMetaData("lectureId", org.apache.thrift.TFieldRequirementType.DEFAULT, 
          new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING          , "UUID")));
      metaDataMap = Collections.unmodifiableMap(tmpMap);
      org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getLectureDetails_args.class, metaDataMap);
    }

    public getLectureDetails_args() {
    }

    public getLectureDetails_args(
      String userToken,
      String lectureId)
    {
      this();
      this.userToken = userToken;
      this.lectureId = lectureId;
    }

    /**
     * Performs a deep copy on <i>other</i>.
     */
    public getLectureDetails_args(getLectureDetails_args other) {
      if (other.isSetUserToken()) {
        this.userToken = other.userToken;
      }
      if (other.isSetLectureId()) {
        this.lectureId = other.lectureId;
      }
    }

    public getLectureDetails_args deepCopy() {
      return new getLectureDetails_args(this);
    }

    @Override
    public void clear() {
      this.userToken = null;
      this.lectureId = null;
    }

    public String getUserToken() {
      return this.userToken;
    }

    public getLectureDetails_args setUserToken(String userToken) {
      this.userToken = userToken;
      return this;
    }

    public void unsetUserToken() {
      this.userToken = null;
    }

    /** Returns true if field userToken is set (has been assigned a value) and false otherwise */
    public boolean isSetUserToken() {
      return this.userToken != null;
    }

    public void setUserTokenIsSet(boolean value) {
      if (!value) {
        this.userToken = null;
      }
    }

    public String getLectureId() {
      return this.lectureId;
    }

    public getLectureDetails_args setLectureId(String lectureId) {
      this.lectureId = lectureId;
      return this;
    }

    public void unsetLectureId() {
      this.lectureId = null;
    }

    /** Returns true if field lectureId is set (has been assigned a value) and false otherwise */
    public boolean isSetLectureId() {
      return this.lectureId != null;
    }

    public void setLectureIdIsSet(boolean value) {
      if (!value) {
        this.lectureId = null;
      }
    }

    public void setFieldValue(_Fields field, Object value) {
      switch (field) {
      case USER_TOKEN:
        if (value == null) {
          unsetUserToken();
        } else {
          setUserToken((String)value);
        }
        break;

      case LECTURE_ID:
        if (value == null) {
          unsetLectureId();
        } else {
          setLectureId((String)value);
        }
        break;

      }
    }

    public Object getFieldValue(_Fields field) {
      switch (field) {
      case USER_TOKEN:
        return getUserToken();

      case LECTURE_ID:
        return getLectureId();

      }
      throw new IllegalStateException();
    }

    /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
    public boolean isSet(_Fields field) {
      if (field == null) {
        throw new IllegalArgumentException();
      }

      switch (field) {
      case USER_TOKEN:
        return isSetUserToken();
      case LECTURE_ID:
        return isSetLectureId();
      }
      throw new IllegalStateException();
    }

    @Override
    public boolean equals(Object that) {
      if (that == null)
        return false;
      if (that instanceof getLectureDetails_args)
        return this.equals((getLectureDetails_args)that);
      return false;
    }

    public boolean equals(getLectureDetails_args that) {
      if (that == null)
        return false;

      boolean this_present_userToken = true && this.isSetUserToken();
      boolean that_present_userToken = true && that.isSetUserToken();
      if (this_present_userToken || that_present_userToken) {
        if (!(this_present_userToken && that_present_userToken))
          return false;
        if (!this.userToken.equals(that.userToken))
          return false;
      }

      boolean this_present_lectureId = true && this.isSetLectureId();
      boolean that_present_lectureId = true && that.isSetLectureId();
      if (this_present_lectureId || that_present_lectureId) {
        if (!(this_present_lectureId && that_present_lectureId))
          return false;
        if (!this.lectureId.equals(that.lectureId))
          return false;
      }

      return true;
    }

    @Override
    public int hashCode() {
      return 0;
    }

    @Override
    public int compareTo(getLectureDetails_args other) {
      if (!getClass().equals(other.getClass())) {
        return getClass().getName().compareTo(other.getClass().getName());
      }

      int lastComparison = 0;

      lastComparison = Boolean.valueOf(isSetUserToken()).compareTo(other.isSetUserToken());
      if (lastComparison != 0) {
        return lastComparison;
      }
      if (isSetUserToken()) {
        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.userToken, other.userToken);
        if (lastComparison != 0) {
          return lastComparison;
        }
      }
      lastComparison = Boolean.valueOf(isSetLectureId()).compareTo(other.isSetLectureId());
      if (lastComparison != 0) {
        return lastComparison;
      }
      if (isSetLectureId()) {
        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.lectureId, other.lectureId);
        if (lastComparison != 0) {
          return lastComparison;
        }
      }
      return 0;
    }

    public _Fields fieldForId(int fieldId) {
      return _Fields.findByThriftId(fieldId);
    }

    public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
      schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
    }

    public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
      schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
    }

    @Override
    public String toString() {
      StringBuilder sb = new StringBuilder("getLectureDetails_args(");
      boolean first = true;

      sb.append("userToken:");
      if (this.userToken == null) {
        sb.append("null");
      } else {
        sb.append(this.userToken);
      }
      first = false;
      if (!first) sb.append(", ");
      sb.append("lectureId:");
      if (this.lectureId == null) {
        sb.append("null");
      } else {
        sb.append(this.lectureId);
      }
      first = false;
      sb.append(")");
      return sb.toString();
    }

    public void validate() throws org.apache.thrift.TException {
      // check for required fields
      // check for sub-struct validity
    }

    private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
      try {
        write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
      } catch (org.apache.thrift.TException te) {
        throw new java.io.IOException(te);
      }
    }

    private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
      try {
        read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
      } catch (org.apache.thrift.TException te) {
        throw new java.io.IOException(te);
      }
    }

    private static class getLectureDetails_argsStandardSchemeFactory implements SchemeFactory {
      public getLectureDetails_argsStandardScheme getScheme() {
        return new getLectureDetails_argsStandardScheme();
      }
    }

    private static class getLectureDetails_argsStandardScheme extends StandardScheme<getLectureDetails_args> {

      public void read(org.apache.thrift.protocol.TProtocol iprot, getLectureDetails_args struct) throws org.apache.thrift.TException {
        org.apache.thrift.protocol.TField schemeField;
        iprot.readStructBegin();
        while (true)
        {
          schemeField = iprot.readFieldBegin();
          if (schemeField.type == org.apache.thrift.protocol.TType.STOP) { 
            break;
          }
          switch (schemeField.id) {
            case 1: // USER_TOKEN
              if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
                struct.userToken = iprot.readString();
                struct.setUserTokenIsSet(true);
              } else { 
                org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
              }
              break;
            case 2: // LECTURE_ID
              if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
                struct.lectureId = iprot.readString();
                struct.setLectureIdIsSet(true);
              } else { 
                org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
              }
              break;
            default:
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
          }
          iprot.readFieldEnd();
        }
        iprot.readStructEnd();

        // check for required fields of primitive type, which can't be checked in the validate method
        struct.validate();
      }

      public void write(org.apache.thrift.protocol.TProtocol oprot, getLectureDetails_args struct) throws org.apache.thrift.TException {
        struct.validate();

        oprot.writeStructBegin(STRUCT_DESC);
        if (struct.userToken != null) {
          oprot.writeFieldBegin(USER_TOKEN_FIELD_DESC);
          oprot.writeString(struct.userToken);
          oprot.writeFieldEnd();
        }
        if (struct.lectureId != null) {
          oprot.writeFieldBegin(LECTURE_ID_FIELD_DESC);
          oprot.writeString(struct.lectureId);
          oprot.writeFieldEnd();
        }
        oprot.writeFieldStop();
        oprot.writeStructEnd();
      }

    }

    private static class getLectureDetails_argsTupleSchemeFactory implements SchemeFactory {
      public getLectureDetails_argsTupleScheme getScheme() {
        return new getLectureDetails_argsTupleScheme();
      }
    }

    private static class getLectureDetails_argsTupleScheme extends TupleScheme<getLectureDetails_args> {

      @Override
      public void write(org.apache.thrift.protocol.TProtocol prot, getLectureDetails_args struct) throws org.apache.thrift.TException {
        TTupleProtocol oprot = (TTupleProtocol) prot;
        BitSet optionals = new BitSet();
        if (struct.isSetUserToken()) {
          optionals.set(0);
        }
        if (struct.isSetLectureId()) {
          optionals.set(1);
        }
        oprot.writeBitSet(optionals, 2);
        if (struct.isSetUserToken()) {
          oprot.writeString(struct.userToken);
        }
        if (struct.isSetLectureId()) {
          oprot.writeString(struct.lectureId);
        }
      }

      @Override
      public void read(org.apache.thrift.protocol.TProtocol prot, getLectureDetails_args struct) throws org.apache.thrift.TException {
        TTupleProtocol iprot = (TTupleProtocol) prot;
        BitSet incoming = iprot.readBitSet(2);
        if (incoming.get(0)) {
          struct.userToken = iprot.readString();
          struct.setUserTokenIsSet(true);
        }
        if (incoming.get(1)) {
          struct.lectureId = iprot.readString();
          struct.setLectureIdIsSet(true);
        }
      }
    }

  }

  public static class getLectureDetails_result implements org.apache.thrift.TBase<getLectureDetails_result, getLectureDetails_result._Fields>, java.io.Serializable, Cloneable, Comparable<getLectureDetails_result>   {
    private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getLectureDetails_result");

    private static final org.apache.thrift.protocol.TField SUCCESS_FIELD_DESC = new org.apache.thrift.protocol.TField("success", org.apache.thrift.protocol.TType.STRUCT, (short)0);
    private static final org.apache.thrift.protocol.TField AUTH_ERROR_FIELD_DESC = new org.apache.thrift.protocol.TField("authError", org.apache.thrift.protocol.TType.STRUCT, (short)1);
    private static final org.apache.thrift.protocol.TField NOT_FOUND_FIELD_DESC = new org.apache.thrift.protocol.TField("notFound", org.apache.thrift.protocol.TType.STRUCT, (short)2);
    private static final org.apache.thrift.protocol.TField SERVER_ERROR_FIELD_DESC = new org.apache.thrift.protocol.TField("serverError", org.apache.thrift.protocol.TType.STRUCT, (short)3);

    private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
    static {
      schemes.put(StandardScheme.class, new getLectureDetails_resultStandardSchemeFactory());
      schemes.put(TupleScheme.class, new getLectureDetails_resultTupleSchemeFactory());
    }

    public LectureRead success; // required
    public TAuthorizationException authError; // required
    public TNotFoundException notFound; // required
    public TInternalServerError serverError; // required

    /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
    public enum _Fields implements org.apache.thrift.TFieldIdEnum {
      SUCCESS((short)0, "success"),
      AUTH_ERROR((short)1, "authError"),
      NOT_FOUND((short)2, "notFound"),
      SERVER_ERROR((short)3, "serverError");

      private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();

      static {
        for (_Fields field : EnumSet.allOf(_Fields.class)) {
          byName.put(field.getFieldName(), field);
        }
      }

      /**
       * Find the _Fields constant that matches fieldId, or null if its not found.
       */
      public static _Fields findByThriftId(int fieldId) {
        switch(fieldId) {
          case 0: // SUCCESS
            return SUCCESS;
          case 1: // AUTH_ERROR
            return AUTH_ERROR;
          case 2: // NOT_FOUND
            return NOT_FOUND;
          case 3: // SERVER_ERROR
            return SERVER_ERROR;
          default:
            return null;
        }
      }

      /**
       * Find the _Fields constant that matches fieldId, throwing an exception
       * if it is not found.
       */
      public static _Fields findByThriftIdOrThrow(int fieldId) {
        _Fields fields = findByThriftId(fieldId);
        if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
        return fields;
      }

      /**
       * Find the _Fields constant that matches name, or null if its not found.
       */
      public static _Fields findByName(String name) {
        return byName.get(name);
      }

      private final short _thriftId;
      private final String _fieldName;

      _Fields(short thriftId, String fieldName) {
        _thriftId = thriftId;
        _fieldName = fieldName;
      }

      public short getThriftFieldId() {
        return _thriftId;
      }

      public String getFieldName() {
        return _fieldName;
      }
    }

    // isset id assignments
    public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
    static {
      Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
      tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, 
          new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, LectureRead.class)));
      tmpMap.put(_Fields.AUTH_ERROR, new org.apache.thrift.meta_data.FieldMetaData("authError", org.apache.thrift.TFieldRequirementType.DEFAULT, 
          new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT)));
      tmpMap.put(_Fields.NOT_FOUND, new org.apache.thrift.meta_data.FieldMetaData("notFound", org.apache.thrift.TFieldRequirementType.DEFAULT, 
          new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT)));
      tmpMap.put(_Fields.SERVER_ERROR, new org.apache.thrift.meta_data.FieldMetaData("serverError", org.apache.thrift.TFieldRequirementType.DEFAULT, 
          new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT)));
      metaDataMap = Collections.unmodifiableMap(tmpMap);
      org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getLectureDetails_result.class, metaDataMap);
    }

    public getLectureDetails_result() {
    }

    public getLectureDetails_result(
      LectureRead success,
      TAuthorizationException authError,
      TNotFoundException notFound,
      TInternalServerError serverError)
    {
      this();
      this.success = success;
      this.authError = authError;
      this.notFound = notFound;
      this.serverError = serverError;
    }

    /**
     * Performs a deep copy on <i>other</i>.
     */
    public getLectureDetails_result(getLectureDetails_result other) {
      if (other.isSetSuccess()) {
        this.success = new LectureRead(other.success);
      }
      if (other.isSetAuthError()) {
        this.authError = new TAuthorizationException(other.authError);
      }
      if (other.isSetNotFound()) {
        this.notFound = new TNotFoundException(other.notFound);
      }
      if (other.isSetServerError()) {
        this.serverError = new TInternalServerError(other.serverError);
      }
    }

    public getLectureDetails_result deepCopy() {
      return new getLectureDetails_result(this);
    }

    @Override
    public void clear() {
      this.success = null;
      this.authError = null;
      this.notFound = null;
      this.serverError = null;
    }

    public LectureRead getSuccess() {
      return this.success;
    }

    public getLectureDetails_result setSuccess(LectureRead success) {
      this.success = success;
      return this;
    }

    public void unsetSuccess() {
      this.success = null;
    }

    /** Returns true if field success is set (has been assigned a value) and false otherwise */
    public boolean isSetSuccess() {
      return this.success != null;
    }

    public void setSuccessIsSet(boolean value) {
      if (!value) {
        this.success = null;
      }
    }

    public TAuthorizationException getAuthError() {
      return this.authError;
    }

    public getLectureDetails_result setAuthError(TAuthorizationException authError) {
      this.authError = authError;
      return this;
    }

    public void unsetAuthError() {
      this.authError = null;
    }

    /** Returns true if field authError is set (has been assigned a value) and false otherwise */
    public boolean isSetAuthError() {
      return this.authError != null;
    }

    public void setAuthErrorIsSet(boolean value) {
      if (!value) {
        this.authError = null;
      }
    }

    public TNotFoundException getNotFound() {
      return this.notFound;
    }

    public getLectureDetails_result setNotFound(TNotFoundException notFound) {
      this.notFound = notFound;
      return this;
    }

    public void unsetNotFound() {
      this.notFound = null;
    }

    /** Returns true if field notFound is set (has been assigned a value) and false otherwise */
    public boolean isSetNotFound() {
      return this.notFound != null;
    }

    public void setNotFoundIsSet(boolean value) {
      if (!value) {
        this.notFound = null;
      }
    }

    public TInternalServerError getServerError() {
      return this.serverError;
    }

    public getLectureDetails_result setServerError(TInternalServerError serverError) {
      this.serverError = serverError;
      return this;
    }

    public void unsetServerError() {
      this.serverError = null;
    }

    /** Returns true if field serverError is set (has been assigned a value) and false otherwise */
    public boolean isSetServerError() {
      return this.serverError != null;
    }

    public void setServerErrorIsSet(boolean value) {
      if (!value) {
        this.serverError = null;
      }
    }

    public void setFieldValue(_Fields field, Object value) {
      switch (field) {
      case SUCCESS:
        if (value == null) {
          unsetSuccess();
        } else {
          setSuccess((LectureRead)value);
        }
        break;

      case AUTH_ERROR:
        if (value == null) {
          unsetAuthError();
        } else {
          setAuthError((TAuthorizationException)value);
        }
        break;

      case NOT_FOUND:
        if (value == null) {
          unsetNotFound();
        } else {
          setNotFound((TNotFoundException)value);
        }
        break;

      case SERVER_ERROR:
        if (value == null) {
          unsetServerError();
        } else {
          setServerError((TInternalServerError)value);
        }
        break;

      }
    }

    public Object getFieldValue(_Fields field) {
      switch (field) {
      case SUCCESS:
        return getSuccess();

      case AUTH_ERROR:
        return getAuthError();

      case NOT_FOUND:
        return getNotFound();

      case SERVER_ERROR:
        return getServerError();

      }
      throw new IllegalStateException();
    }

    /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
    public boolean isSet(_Fields field) {
      if (field == null) {
        throw new IllegalArgumentException();
      }

      switch (field) {
      case SUCCESS:
        return isSetSuccess();
      case AUTH_ERROR:
        return isSetAuthError();
      case NOT_FOUND:
        return isSetNotFound();
      case SERVER_ERROR:
        return isSetServerError();
      }
      throw new IllegalStateException();
    }

    @Override
    public boolean equals(Object that) {
      if (that == null)
        return false;
      if (that instanceof getLectureDetails_result)
        return this.equals((getLectureDetails_result)that);
      return false;
    }

    public boolean equals(getLectureDetails_result that) {
      if (that == null)
        return false;

      boolean this_present_success = true && this.isSetSuccess();
      boolean that_present_success = true && that.isSetSuccess();
      if (this_present_success || that_present_success) {
        if (!(this_present_success && that_present_success))
          return false;
        if (!this.success.equals(that.success))
          return false;
      }

      boolean this_present_authError = true && this.isSetAuthError();
      boolean that_present_authError = true && that.isSetAuthError();
      if (this_present_authError || that_present_authError) {
        if (!(this_present_authError && that_present_authError))
          return false;
        if (!this.authError.equals(that.authError))
          return false;
      }

      boolean this_present_notFound = true && this.isSetNotFound();
      boolean that_present_notFound = true && that.isSetNotFound();
      if (this_present_notFound || that_present_notFound) {
        if (!(this_present_notFound && that_present_notFound))
          return false;
        if (!this.notFound.equals(that.notFound))
          return false;
      }

      boolean this_present_serverError = true && this.isSetServerError();
      boolean that_present_serverError = true && that.isSetServerError();
      if (this_present_serverError || that_present_serverError) {
        if (!(this_present_serverError && that_present_serverError))
          return false;
        if (!this.serverError.equals(that.serverError))
          return false;
      }

      return true;
    }

    @Override
    public int hashCode() {
      return 0;
    }

    @Override
    public int compareTo(getLectureDetails_result other) {
      if (!getClass().equals(other.getClass())) {
        return getClass().getName().compareTo(other.getClass().getName());
      }

      int lastComparison = 0;

      lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(other.isSetSuccess());
      if (lastComparison != 0) {
        return lastComparison;
      }
      if (isSetSuccess()) {
        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, other.success);
        if (lastComparison != 0) {
          return lastComparison;
        }
      }
      lastComparison = Boolean.valueOf(isSetAuthError()).compareTo(other.isSetAuthError());
      if (lastComparison != 0) {
        return lastComparison;
      }
      if (isSetAuthError()) {
        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.authError, other.authError);
        if (lastComparison != 0) {
          return lastComparison;
        }
      }
      lastComparison = Boolean.valueOf(isSetNotFound()).compareTo(other.isSetNotFound());
      if (lastComparison != 0) {
        return lastComparison;
      }
      if (isSetNotFound()) {
        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.notFound, other.notFound);
        if (lastComparison != 0) {
          return lastComparison;
        }
      }
      lastComparison = Boolean.valueOf(isSetServerError()).compareTo(other.isSetServerError());
      if (lastComparison != 0) {
        return lastComparison;
      }
      if (isSetServerError()) {
        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.serverError, other.serverError);
        if (lastComparison != 0) {
          return lastComparison;
        }
      }
      return 0;
    }

    public _Fields fieldForId(int fieldId) {
      return _Fields.findByThriftId(fieldId);
    }

    public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
      schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
    }

    public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
      schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
      }

    @Override
    public String toString() {
      StringBuilder sb = new StringBuilder("getLectureDetails_result(");
      boolean first = true;

      sb.append("success:");
      if (this.success == null) {
        sb.append("null");
      } else {
        sb.append(this.success);
      }
      first = false;
      if (!first) sb.append(", ");
      sb.append("authError:");
      if (this.authError == null) {
        sb.append("null");
      } else {
        sb.append(this.authError);
      }
      first = false;
      if (!first) sb.append(", ");
      sb.append("notFound:");
      if (this.notFound == null) {
        sb.append("null");
      } else {
        sb.append(this.notFound);
      }
      first = false;
      if (!first) sb.append(", ");
      sb.append("serverError:");
      if (this.serverError == null) {
        sb.append("null");
      } else {
        sb.append(this.serverError);
      }
      first = false;
      sb.append(")");
      return sb.toString();
    }

    public void validate() throws org.apache.thrift.TException {
      // check for required fields
      // check for sub-struct validity
      if (success != null) {
        success.validate();
      }
    }

    private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
      try {
        write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
      } catch (org.apache.thrift.TException te) {
        throw new java.io.IOException(te);
      }
    }

    private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
      try {
        read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
      } catch (org.apache.thrift.TException te) {
        throw new java.io.IOException(te);
      }
    }

    private static class getLectureDetails_resultStandardSchemeFactory implements SchemeFactory {
      public getLectureDetails_resultStandardScheme getScheme() {
        return new getLectureDetails_resultStandardScheme();
      }
    }

    private static class getLectureDetails_resultStandardScheme extends StandardScheme<getLectureDetails_result> {

      public void read(org.apache.thrift.protocol.TProtocol iprot, getLectureDetails_result struct) throws org.apache.thrift.TException {
        org.apache.thrift.protocol.TField schemeField;
        iprot.readStructBegin();
        while (true)
        {
          schemeField = iprot.readFieldBegin();
          if (schemeField.type == org.apache.thrift.protocol.TType.STOP) { 
            break;
          }
          switch (schemeField.id) {
            case 0: // SUCCESS
              if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
                struct.success = new LectureRead();
                struct.success.read(iprot);
                struct.setSuccessIsSet(true);
              } else { 
                org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
              }
              break;
            case 1: // AUTH_ERROR
              if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
                struct.authError = new TAuthorizationException();
                struct.authError.read(iprot);
                struct.setAuthErrorIsSet(true);
              } else { 
                org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
              }
              break;
            case 2: // NOT_FOUND
              if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
                struct.notFound = new TNotFoundException();
                struct.notFound.read(iprot);
                struct.setNotFoundIsSet(true);
              } else { 
                org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
              }
              break;
            case 3: // SERVER_ERROR
              if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
                struct.serverError = new TInternalServerError();
                struct.serverError.read(iprot);
                struct.setServerErrorIsSet(true);
              } else { 
                org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
              }
              break;
            default:
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
          }
          iprot.readFieldEnd();
        }
        iprot.readStructEnd();

        // check for required fields of primitive type, which can't be checked in the validate method
        struct.validate();
      }

      public void write(org.apache.thrift.protocol.TProtocol oprot, getLectureDetails_result struct) throws org.apache.thrift.TException {
        struct.validate();

        oprot.writeStructBegin(STRUCT_DESC);
        if (struct.success != null) {
          oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
          struct.success.write(oprot);
          oprot.writeFieldEnd();
        }
        if (struct.authError != null) {
          oprot.writeFieldBegin(AUTH_ERROR_FIELD_DESC);
          struct.authError.write(oprot);
          oprot.writeFieldEnd();
        }
        if (struct.notFound != null) {
          oprot.writeFieldBegin(NOT_FOUND_FIELD_DESC);
          struct.notFound.write(oprot);
          oprot.writeFieldEnd();
        }
        if (struct.serverError != null) {
          oprot.writeFieldBegin(SERVER_ERROR_FIELD_DESC);
          struct.serverError.write(oprot);
          oprot.writeFieldEnd();
        }
        oprot.writeFieldStop();
        oprot.writeStructEnd();
      }

    }

    private static class getLectureDetails_resultTupleSchemeFactory implements SchemeFactory {
      public getLectureDetails_resultTupleScheme getScheme() {
        return new getLectureDetails_resultTupleScheme();
      }
    }

    private static class getLectureDetails_resultTupleScheme extends TupleScheme<getLectureDetails_result> {

      @Override
      public void write(org.apache.thrift.protocol.TProtocol prot, getLectureDetails_result struct) throws org.apache.thrift.TException {
        TTupleProtocol oprot = (TTupleProtocol) prot;
        BitSet optionals = new BitSet();
        if (struct.isSetSuccess()) {
          optionals.set(0);
        }
        if (struct.isSetAuthError()) {
          optionals.set(1);
        }
        if (struct.isSetNotFound()) {
          optionals.set(2);
        }
        if (struct.isSetServerError()) {
          optionals.set(3);
        }
        oprot.writeBitSet(optionals, 4);
        if (struct.isSetSuccess()) {
          struct.success.write(oprot);
        }
        if (struct.isSetAuthError()) {
          struct.authError.write(oprot);
        }
        if (struct.isSetNotFound()) {
          struct.notFound.write(oprot);
        }
        if (struct.isSetServerError()) {
          struct.serverError.write(oprot);
        }
      }

      @Override
      public void read(org.apache.thrift.protocol.TProtocol prot, getLectureDetails_result struct) throws org.apache.thrift.TException {
        TTupleProtocol iprot = (TTupleProtocol) prot;
        BitSet incoming = iprot.readBitSet(4);
        if (incoming.get(0)) {
          struct.success = new LectureRead();
          struct.success.read(iprot);
          struct.setSuccessIsSet(true);
        }
        if (incoming.get(1)) {
          struct.authError = new TAuthorizationException();
          struct.authError.read(iprot);
          struct.setAuthErrorIsSet(true);
        }
        if (incoming.get(2)) {
          struct.notFound = new TNotFoundException();
          struct.notFound.read(iprot);
          struct.setNotFoundIsSet(true);
        }
        if (incoming.get(3)) {
          struct.serverError = new TInternalServerError();
          struct.serverError.read(iprot);
          struct.setServerErrorIsSet(true);
        }
      }
    }

  }

  public static class deleteLecture_args implements org.apache.thrift.TBase<deleteLecture_args, deleteLecture_args._Fields>, java.io.Serializable, Cloneable, Comparable<deleteLecture_args>   {
    private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("deleteLecture_args");

    private static final org.apache.thrift.protocol.TField USER_TOKEN_FIELD_DESC = new org.apache.thrift.protocol.TField("userToken", org.apache.thrift.protocol.TType.STRING, (short)1);
    private static final org.apache.thrift.protocol.TField LECTURE_ID_FIELD_DESC = new org.apache.thrift.protocol.TField("lectureId", org.apache.thrift.protocol.TType.STRING, (short)2);

    private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
    static {
      schemes.put(StandardScheme.class, new deleteLecture_argsStandardSchemeFactory());
      schemes.put(TupleScheme.class, new deleteLecture_argsTupleSchemeFactory());
    }

    public String userToken; // required
    public String lectureId; // required

    /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
    public enum _Fields implements org.apache.thrift.TFieldIdEnum {
      USER_TOKEN((short)1, "userToken"),
      LECTURE_ID((short)2, "lectureId");

      private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();

      static {
        for (_Fields field : EnumSet.allOf(_Fields.class)) {
          byName.put(field.getFieldName(), field);
        }
      }

      /**
       * Find the _Fields constant that matches fieldId, or null if its not found.
       */
      public static _Fields findByThriftId(int fieldId) {
        switch(fieldId) {
          case 1: // USER_TOKEN
            return USER_TOKEN;
          case 2: // LECTURE_ID
            return LECTURE_ID;
          default:
            return null;
        }
      }

      /**
       * Find the _Fields constant that matches fieldId, throwing an exception
       * if it is not found.
       */
      public static _Fields findByThriftIdOrThrow(int fieldId) {
        _Fields fields = findByThriftId(fieldId);
        if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
        return fields;
      }

      /**
       * Find the _Fields constant that matches name, or null if its not found.
       */
      public static _Fields findByName(String name) {
        return byName.get(name);
      }

      private final short _thriftId;
      private final String _fieldName;

      _Fields(short thriftId, String fieldName) {
        _thriftId = thriftId;
        _fieldName = fieldName;
      }

      public short getThriftFieldId() {
        return _thriftId;
      }

      public String getFieldName() {
        return _fieldName;
      }
    }

    // isset id assignments
    public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
    static {
      Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
      tmpMap.put(_Fields.USER_TOKEN, new org.apache.thrift.meta_data.FieldMetaData("userToken", org.apache.thrift.TFieldRequirementType.DEFAULT, 
          new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING          , "Token")));
      tmpMap.put(_Fields.LECTURE_ID, new org.apache.thrift.meta_data.FieldMetaData("lectureId", org.apache.thrift.TFieldRequirementType.DEFAULT, 
          new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING          , "UUID")));
      metaDataMap = Collections.unmodifiableMap(tmpMap);
      org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(deleteLecture_args.class, metaDataMap);
    }

    public deleteLecture_args() {
    }

    public deleteLecture_args(
      String userToken,
      String lectureId)
    {
      this();
      this.userToken = userToken;
      this.lectureId = lectureId;
    }

    /**
     * Performs a deep copy on <i>other</i>.
     */
    public deleteLecture_args(deleteLecture_args other) {
      if (other.isSetUserToken()) {
        this.userToken = other.userToken;
      }
      if (other.isSetLectureId()) {
        this.lectureId = other.lectureId;
      }
    }

    public deleteLecture_args deepCopy() {
      return new deleteLecture_args(this);
    }

    @Override
    public void clear() {
      this.userToken = null;
      this.lectureId = null;
    }

    public String getUserToken() {
      return this.userToken;
    }

    public deleteLecture_args setUserToken(String userToken) {
      this.userToken = userToken;
      return this;
    }

    public void unsetUserToken() {
      this.userToken = null;
    }

    /** Returns true if field userToken is set (has been assigned a value) and false otherwise */
    public boolean isSetUserToken() {
      return this.userToken != null;
    }

    public void setUserTokenIsSet(boolean value) {
      if (!value) {
        this.userToken = null;
      }
    }

    public String getLectureId() {
      return this.lectureId;
    }

    public deleteLecture_args setLectureId(String lectureId) {
      this.lectureId = lectureId;
      return this;
    }

    public void unsetLectureId() {
      this.lectureId = null;
    }

    /** Returns true if field lectureId is set (has been assigned a value) and false otherwise */
    public boolean isSetLectureId() {
      return this.lectureId != null;
    }

    public void setLectureIdIsSet(boolean value) {
      if (!value) {
        this.lectureId = null;
      }
    }

    public void setFieldValue(_Fields field, Object value) {
      switch (field) {
      case USER_TOKEN:
        if (value == null) {
          unsetUserToken();
        } else {
          setUserToken((String)value);
        }
        break;

      case LECTURE_ID:
        if (value == null) {
          unsetLectureId();
        } else {
          setLectureId((String)value);
        }
        break;

      }
    }

    public Object getFieldValue(_Fields field) {
      switch (field) {
      case USER_TOKEN:
        return getUserToken();

      case LECTURE_ID:
        return getLectureId();

      }
      throw new IllegalStateException();
    }

    /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
    public boolean isSet(_Fields field) {
      if (field == null) {
        throw new IllegalArgumentException();
      }

      switch (field) {
      case USER_TOKEN:
        return isSetUserToken();
      case LECTURE_ID:
        return isSetLectureId();
      }
      throw new IllegalStateException();
    }

    @Override
    public boolean equals(Object that) {
      if (that == null)
        return false;
      if (that instanceof deleteLecture_args)
        return this.equals((deleteLecture_args)that);
      return false;
    }

    public boolean equals(deleteLecture_args that) {
      if (that == null)
        return false;

      boolean this_present_userToken = true && this.isSetUserToken();
      boolean that_present_userToken = true && that.isSetUserToken();
      if (this_present_userToken || that_present_userToken) {
        if (!(this_present_userToken && that_present_userToken))
          return false;
        if (!this.userToken.equals(that.userToken))
          return false;
      }

      boolean this_present_lectureId = true && this.isSetLectureId();
      boolean that_present_lectureId = true && that.isSetLectureId();
      if (this_present_lectureId || that_present_lectureId) {
        if (!(this_present_lectureId && that_present_lectureId))
          return false;
        if (!this.lectureId.equals(that.lectureId))
          return false;
      }

      return true;
    }

    @Override
    public int hashCode() {
      return 0;
    }

    @Override
    public int compareTo(deleteLecture_args other) {
      if (!getClass().equals(other.getClass())) {
        return getClass().getName().compareTo(other.getClass().getName());
      }

      int lastComparison = 0;

      lastComparison = Boolean.valueOf(isSetUserToken()).compareTo(other.isSetUserToken());
      if (lastComparison != 0) {
        return lastComparison;
      }
      if (isSetUserToken()) {
        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.userToken, other.userToken);
        if (lastComparison != 0) {
          return lastComparison;
        }
      }
      lastComparison = Boolean.valueOf(isSetLectureId()).compareTo(other.isSetLectureId());
      if (lastComparison != 0) {
        return lastComparison;
      }
      if (isSetLectureId()) {
        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.lectureId, other.lectureId);
        if (lastComparison != 0) {
          return lastComparison;
        }
      }
      return 0;
    }

    public _Fields fieldForId(int fieldId) {
      return _Fields.findByThriftId(fieldId);
    }

    public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
      schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
    }

    public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
      schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
    }

    @Override
    public String toString() {
      StringBuilder sb = new StringBuilder("deleteLecture_args(");
      boolean first = true;

      sb.append("userToken:");
      if (this.userToken == null) {
        sb.append("null");
      } else {
        sb.append(this.userToken);
      }
      first = false;
      if (!first) sb.append(", ");
      sb.append("lectureId:");
      if (this.lectureId == null) {
        sb.append("null");
      } else {
        sb.append(this.lectureId);
      }
      first = false;
      sb.append(")");
      return sb.toString();
    }

    public void validate() throws org.apache.thrift.TException {
      // check for required fields
      // check for sub-struct validity
    }

    private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
      try {
        write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
      } catch (org.apache.thrift.TException te) {
        throw new java.io.IOException(te);
      }
    }

    private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
      try {
        read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
      } catch (org.apache.thrift.TException te) {
        throw new java.io.IOException(te);
      }
    }

    private static class deleteLecture_argsStandardSchemeFactory implements SchemeFactory {
      public deleteLecture_argsStandardScheme getScheme() {
        return new deleteLecture_argsStandardScheme();
      }
    }

    private static class deleteLecture_argsStandardScheme extends StandardScheme<deleteLecture_args> {

      public void read(org.apache.thrift.protocol.TProtocol iprot, deleteLecture_args struct) throws org.apache.thrift.TException {
        org.apache.thrift.protocol.TField schemeField;
        iprot.readStructBegin();
        while (true)
        {
          schemeField = iprot.readFieldBegin();
          if (schemeField.type == org.apache.thrift.protocol.TType.STOP) { 
            break;
          }
          switch (schemeField.id) {
            case 1: // USER_TOKEN
              if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
                struct.userToken = iprot.readString();
                struct.setUserTokenIsSet(true);
              } else { 
                org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
              }
              break;
            case 2: // LECTURE_ID
              if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
                struct.lectureId = iprot.readString();
                struct.setLectureIdIsSet(true);
              } else { 
                org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
              }
              break;
            default:
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
          }
          iprot.readFieldEnd();
        }
        iprot.readStructEnd();

        // check for required fields of primitive type, which can't be checked in the validate method
        struct.validate();
      }

      public void write(org.apache.thrift.protocol.TProtocol oprot, deleteLecture_args struct) throws org.apache.thrift.TException {
        struct.validate();

        oprot.writeStructBegin(STRUCT_DESC);
        if (struct.userToken != null) {
          oprot.writeFieldBegin(USER_TOKEN_FIELD_DESC);
          oprot.writeString(struct.userToken);
          oprot.writeFieldEnd();
        }
        if (struct.lectureId != null) {
          oprot.writeFieldBegin(LECTURE_ID_FIELD_DESC);
          oprot.writeString(struct.lectureId);
          oprot.writeFieldEnd();
        }
        oprot.writeFieldStop();
        oprot.writeStructEnd();
      }

    }

    private static class deleteLecture_argsTupleSchemeFactory implements SchemeFactory {
      public deleteLecture_argsTupleScheme getScheme() {
        return new deleteLecture_argsTupleScheme();
      }
    }

    private static class deleteLecture_argsTupleScheme extends TupleScheme<deleteLecture_args> {

      @Override
      public void write(org.apache.thrift.protocol.TProtocol prot, deleteLecture_args struct) throws org.apache.thrift.TException {
        TTupleProtocol oprot = (TTupleProtocol) prot;
        BitSet optionals = new BitSet();
        if (struct.isSetUserToken()) {
          optionals.set(0);
        }
        if (struct.isSetLectureId()) {
          optionals.set(1);
        }
        oprot.writeBitSet(optionals, 2);
        if (struct.isSetUserToken()) {
          oprot.writeString(struct.userToken);
        }
        if (struct.isSetLectureId()) {
          oprot.writeString(struct.lectureId);
        }
      }

      @Override
      public void read(org.apache.thrift.protocol.TProtocol prot, deleteLecture_args struct) throws org.apache.thrift.TException {
        TTupleProtocol iprot = (TTupleProtocol) prot;
        BitSet incoming = iprot.readBitSet(2);
        if (incoming.get(0)) {
          struct.userToken = iprot.readString();
          struct.setUserTokenIsSet(true);
        }
        if (incoming.get(1)) {
          struct.lectureId = iprot.readString();
          struct.setLectureIdIsSet(true);
        }
      }
    }

  }

  public static class deleteLecture_result implements org.apache.thrift.TBase<deleteLecture_result, deleteLecture_result._Fields>, java.io.Serializable, Cloneable, Comparable<deleteLecture_result>   {
    private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("deleteLecture_result");

    private static final org.apache.thrift.protocol.TField AUTH_ERROR_FIELD_DESC = new org.apache.thrift.protocol.TField("authError", org.apache.thrift.protocol.TType.STRUCT, (short)1);
    private static final org.apache.thrift.protocol.TField NOT_FOUND_FIELD_DESC = new org.apache.thrift.protocol.TField("notFound", org.apache.thrift.protocol.TType.STRUCT, (short)2);
    private static final org.apache.thrift.protocol.TField SERVER_ERROR_FIELD_DESC = new org.apache.thrift.protocol.TField("serverError", org.apache.thrift.protocol.TType.STRUCT, (short)3);

    private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
    static {
      schemes.put(StandardScheme.class, new deleteLecture_resultStandardSchemeFactory());
      schemes.put(TupleScheme.class, new deleteLecture_resultTupleSchemeFactory());
    }

    public TAuthorizationException authError; // required
    public TNotFoundException notFound; // required
    public TInternalServerError serverError; // required

    /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
    public enum _Fields implements org.apache.thrift.TFieldIdEnum {
      AUTH_ERROR((short)1, "authError"),
      NOT_FOUND((short)2, "notFound"),
      SERVER_ERROR((short)3, "serverError");

      private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();

      static {
        for (_Fields field : EnumSet.allOf(_Fields.class)) {
          byName.put(field.getFieldName(), field);
        }
      }

      /**
       * Find the _Fields constant that matches fieldId, or null if its not found.
       */
      public static _Fields findByThriftId(int fieldId) {
        switch(fieldId) {
          case 1: // AUTH_ERROR
            return AUTH_ERROR;
          case 2: // NOT_FOUND
            return NOT_FOUND;
          case 3: // SERVER_ERROR
            return SERVER_ERROR;
          default:
            return null;
        }
      }

      /**
       * Find the _Fields constant that matches fieldId, throwing an exception
       * if it is not found.
       */
      public static _Fields findByThriftIdOrThrow(int fieldId) {
        _Fields fields = findByThriftId(fieldId);
        if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
        return fields;
      }

      /**
       * Find the _Fields constant that matches name, or null if its not found.
       */
      public static _Fields findByName(String name) {
        return byName.get(name);
      }

      private final short _thriftId;
      private final String _fieldName;

      _Fields(short thriftId, String fieldName) {
        _thriftId = thriftId;
        _fieldName = fieldName;
      }

      public short getThriftFieldId() {
        return _thriftId;
      }

      public String getFieldName() {
        return _fieldName;
      }
    }

    // isset id assignments
    public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
    static {
      Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
      tmpMap.put(_Fields.AUTH_ERROR, new org.apache.thrift.meta_data.FieldMetaData("authError", org.apache.thrift.TFieldRequirementType.DEFAULT, 
          new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT)));
      tmpMap.put(_Fields.NOT_FOUND, new org.apache.thrift.meta_data.FieldMetaData("notFound", org.apache.thrift.TFieldRequirementType.DEFAULT, 
          new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT)));
      tmpMap.put(_Fields.SERVER_ERROR, new org.apache.thrift.meta_data.FieldMetaData("serverError", org.apache.thrift.TFieldRequirementType.DEFAULT, 
          new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT)));
      metaDataMap = Collections.unmodifiableMap(tmpMap);
      org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(deleteLecture_result.class, metaDataMap);
    }

    public deleteLecture_result() {
    }

    public deleteLecture_result(
      TAuthorizationException authError,
      TNotFoundException notFound,
      TInternalServerError serverError)
    {
      this();
      this.authError = authError;
      this.notFound = notFound;
      this.serverError = serverError;
    }

    /**
     * Performs a deep copy on <i>other</i>.
     */
    public deleteLecture_result(deleteLecture_result other) {
      if (other.isSetAuthError()) {
        this.authError = new TAuthorizationException(other.authError);
      }
      if (other.isSetNotFound()) {
        this.notFound = new TNotFoundException(other.notFound);
      }
      if (other.isSetServerError()) {
        this.serverError = new TInternalServerError(other.serverError);
      }
    }

    public deleteLecture_result deepCopy() {
      return new deleteLecture_result(this);
    }

    @Override
    public void clear() {
      this.authError = null;
      this.notFound = null;
      this.serverError = null;
    }

    public TAuthorizationException getAuthError() {
      return this.authError;
    }

    public deleteLecture_result setAuthError(TAuthorizationException authError) {
      this.authError = authError;
      return this;
    }

    public void unsetAuthError() {
      this.authError = null;
    }

    /** Returns true if field authError is set (has been assigned a value) and false otherwise */
    public boolean isSetAuthError() {
      return this.authError != null;
    }

    public void setAuthErrorIsSet(boolean value) {
      if (!value) {
        this.authError = null;
      }
    }

    public TNotFoundException getNotFound() {
      return this.notFound;
    }

    public deleteLecture_result setNotFound(TNotFoundException notFound) {
      this.notFound = notFound;
      return this;
    }

    public void unsetNotFound() {
      this.notFound = null;
    }

    /** Returns true if field notFound is set (has been assigned a value) and false otherwise */
    public boolean isSetNotFound() {
      return this.notFound != null;
    }

    public void setNotFoundIsSet(boolean value) {
      if (!value) {
        this.notFound = null;
      }
    }

    public TInternalServerError getServerError() {
      return this.serverError;
    }

    public deleteLecture_result setServerError(TInternalServerError serverError) {
      this.serverError = serverError;
      return this;
    }

    public void unsetServerError() {
      this.serverError = null;
    }

    /** Returns true if field serverError is set (has been assigned a value) and false otherwise */
    public boolean isSetServerError() {
      return this.serverError != null;
    }

    public void setServerErrorIsSet(boolean value) {
      if (!value) {
        this.serverError = null;
      }
    }

    public void setFieldValue(_Fields field, Object value) {
      switch (field) {
      case AUTH_ERROR:
        if (value == null) {
          unsetAuthError();
        } else {
          setAuthError((TAuthorizationException)value);
        }
        break;

      case NOT_FOUND:
        if (value == null) {
          unsetNotFound();
        } else {
          setNotFound((TNotFoundException)value);
        }
        break;

      case SERVER_ERROR:
        if (value == null) {
          unsetServerError();
        } else {
          setServerError((TInternalServerError)value);
        }
        break;

      }
    }

    public Object getFieldValue(_Fields field) {
      switch (field) {
      case AUTH_ERROR:
        return getAuthError();

      case NOT_FOUND:
        return getNotFound();

      case SERVER_ERROR:
        return getServerError();

      }
      throw new IllegalStateException();
    }

    /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
    public boolean isSet(_Fields field) {
      if (field == null) {
        throw new IllegalArgumentException();
      }

      switch (field) {
      case AUTH_ERROR:
        return isSetAuthError();
      case NOT_FOUND:
        return isSetNotFound();
      case SERVER_ERROR:
        return isSetServerError();
      }
      throw new IllegalStateException();
    }

    @Override
    public boolean equals(Object that) {
      if (that == null)
        return false;
      if (that instanceof deleteLecture_result)
        return this.equals((deleteLecture_result)that);
      return false;
    }

    public boolean equals(deleteLecture_result that) {
      if (that == null)
        return false;

      boolean this_present_authError = true && this.isSetAuthError();
      boolean that_present_authError = true && that.isSetAuthError();
      if (this_present_authError || that_present_authError) {
        if (!(this_present_authError && that_present_authError))
          return false;
        if (!this.authError.equals(that.authError))
          return false;
      }

      boolean this_present_notFound = true && this.isSetNotFound();
      boolean that_present_notFound = true && that.isSetNotFound();
      if (this_present_notFound || that_present_notFound) {
        if (!(this_present_notFound && that_present_notFound))
          return false;
        if (!this.notFound.equals(that.notFound))
          return false;
      }

      boolean this_present_serverError = true && this.isSetServerError();
      boolean that_present_serverError = true && that.isSetServerError();
      if (this_present_serverError || that_present_serverError) {
        if (!(this_present_serverError && that_present_serverError))
          return false;
        if (!this.serverError.equals(that.serverError))
          return false;
      }

      return true;
    }

    @Override
    public int hashCode() {
      return 0;
    }

    @Override
    public int compareTo(deleteLecture_result other) {
      if (!getClass().equals(other.getClass())) {
        return getClass().getName().compareTo(other.getClass().getName());
      }

      int lastComparison = 0;

      lastComparison = Boolean.valueOf(isSetAuthError()).compareTo(other.isSetAuthError());
      if (lastComparison != 0) {
        return lastComparison;
      }
      if (isSetAuthError()) {
        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.authError, other.authError);
        if (lastComparison != 0) {
          return lastComparison;
        }
      }
      lastComparison = Boolean.valueOf(isSetNotFound()).compareTo(other.isSetNotFound());
      if (lastComparison != 0) {
        return lastComparison;
      }
      if (isSetNotFound()) {
        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.notFound, other.notFound);
        if (lastComparison != 0) {
          return lastComparison;
        }
      }
      lastComparison = Boolean.valueOf(isSetServerError()).compareTo(other.isSetServerError());
      if (lastComparison != 0) {
        return lastComparison;
      }
      if (isSetServerError()) {
        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.serverError, other.serverError);
        if (lastComparison != 0) {
          return lastComparison;
        }
      }
      return 0;
    }

    public _Fields fieldForId(int fieldId) {
      return _Fields.findByThriftId(fieldId);
    }

    public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
      schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
    }

    public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
      schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
      }

    @Override
    public String toString() {
      StringBuilder sb = new StringBuilder("deleteLecture_result(");
      boolean first = true;

      sb.append("authError:");
      if (this.authError == null) {
        sb.append("null");
      } else {
        sb.append(this.authError);
      }
      first = false;
      if (!first) sb.append(", ");
      sb.append("notFound:");
      if (this.notFound == null) {
        sb.append("null");
      } else {
        sb.append(this.notFound);
      }
      first = false;
      if (!first) sb.append(", ");
      sb.append("serverError:");
      if (this.serverError == null) {
        sb.append("null");
      } else {
        sb.append(this.serverError);
      }
      first = false;
      sb.append(")");
      return sb.toString();
    }

    public void validate() throws org.apache.thrift.TException {
      // check for required fields
      // check for sub-struct validity
    }

    private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
      try {
        write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
      } catch (org.apache.thrift.TException te) {
        throw new java.io.IOException(te);
      }
    }

    private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
      try {
        read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
      } catch (org.apache.thrift.TException te) {
        throw new java.io.IOException(te);
      }
    }

    private static class deleteLecture_resultStandardSchemeFactory implements SchemeFactory {
      public deleteLecture_resultStandardScheme getScheme() {
        return new deleteLecture_resultStandardScheme();
      }
    }

    private static class deleteLecture_resultStandardScheme extends StandardScheme<deleteLecture_result> {

      public void read(org.apache.thrift.protocol.TProtocol iprot, deleteLecture_result struct) throws org.apache.thrift.TException {
        org.apache.thrift.protocol.TField schemeField;
        iprot.readStructBegin();
        while (true)
        {
          schemeField = iprot.readFieldBegin();
          if (schemeField.type == org.apache.thrift.protocol.TType.STOP) { 
            break;
          }
          switch (schemeField.id) {
            case 1: // AUTH_ERROR
              if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
                struct.authError = new TAuthorizationException();
                struct.authError.read(iprot);
                struct.setAuthErrorIsSet(true);
              } else { 
                org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
              }
              break;
            case 2: // NOT_FOUND
              if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
                struct.notFound = new TNotFoundException();
                struct.notFound.read(iprot);
                struct.setNotFoundIsSet(true);
              } else { 
                org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
              }
              break;
            case 3: // SERVER_ERROR
              if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
                struct.serverError = new TInternalServerError();
                struct.serverError.read(iprot);
                struct.setServerErrorIsSet(true);
              } else { 
                org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
              }
              break;
            default:
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
          }
          iprot.readFieldEnd();
        }
        iprot.readStructEnd();

        // check for required fields of primitive type, which can't be checked in the validate method
        struct.validate();
      }

      public void write(org.apache.thrift.protocol.TProtocol oprot, deleteLecture_result struct) throws org.apache.thrift.TException {
        struct.validate();

        oprot.writeStructBegin(STRUCT_DESC);
        if (struct.authError != null) {
          oprot.writeFieldBegin(AUTH_ERROR_FIELD_DESC);
          struct.authError.write(oprot);
          oprot.writeFieldEnd();
        }
        if (struct.notFound != null) {
          oprot.writeFieldBegin(NOT_FOUND_FIELD_DESC);
          struct.notFound.write(oprot);
          oprot.writeFieldEnd();
        }
        if (struct.serverError != null) {
          oprot.writeFieldBegin(SERVER_ERROR_FIELD_DESC);
          struct.serverError.write(oprot);
          oprot.writeFieldEnd();
        }
        oprot.writeFieldStop();
        oprot.writeStructEnd();
      }

    }

    private static class deleteLecture_resultTupleSchemeFactory implements SchemeFactory {
      public deleteLecture_resultTupleScheme getScheme() {
        return new deleteLecture_resultTupleScheme();
      }
    }

    private static class deleteLecture_resultTupleScheme extends TupleScheme<deleteLecture_result> {

      @Override
      public void write(org.apache.thrift.protocol.TProtocol prot, deleteLecture_result struct) throws org.apache.thrift.TException {
        TTupleProtocol oprot = (TTupleProtocol) prot;
        BitSet optionals = new BitSet();
        if (struct.isSetAuthError()) {
          optionals.set(0);
        }
        if (struct.isSetNotFound()) {
          optionals.set(1);
        }
        if (struct.isSetServerError()) {
          optionals.set(2);
        }
        oprot.writeBitSet(optionals, 3);
        if (struct.isSetAuthError()) {
          struct.authError.write(oprot);
        }
        if (struct.isSetNotFound()) {
          struct.notFound.write(oprot);
        }
        if (struct.isSetServerError()) {
          struct.serverError.write(oprot);
        }
      }

      @Override
      public void read(org.apache.thrift.protocol.TProtocol prot, deleteLecture_result struct) throws org.apache.thrift.TException {
        TTupleProtocol iprot = (TTupleProtocol) prot;
        BitSet incoming = iprot.readBitSet(3);
        if (incoming.get(0)) {
          struct.authError = new TAuthorizationException();
          struct.authError.read(iprot);
          struct.setAuthErrorIsSet(true);
        }
        if (incoming.get(1)) {
          struct.notFound = new TNotFoundException();
          struct.notFound.read(iprot);
          struct.setNotFoundIsSet(true);
        }
        if (incoming.get(2)) {
          struct.serverError = new TInternalServerError();
          struct.serverError.read(iprot);
          struct.setServerErrorIsSet(true);
        }
      }
    }

  }

  public static class writeLecturePermissions_args implements org.apache.thrift.TBase<writeLecturePermissions_args, writeLecturePermissions_args._Fields>, java.io.Serializable, Cloneable, Comparable<writeLecturePermissions_args>   {
    private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("writeLecturePermissions_args");

    private static final org.apache.thrift.protocol.TField USER_TOKEN_FIELD_DESC = new org.apache.thrift.protocol.TField("userToken", org.apache.thrift.protocol.TType.STRING, (short)1);
    private static final org.apache.thrift.protocol.TField LECTURE_ID_FIELD_DESC = new org.apache.thrift.protocol.TField("lectureId", org.apache.thrift.protocol.TType.STRING, (short)2);
    private static final org.apache.thrift.protocol.TField PERMISSIONS_FIELD_DESC = new org.apache.thrift.protocol.TField("permissions", org.apache.thrift.protocol.TType.MAP, (short)3);

    private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
    static {
      schemes.put(StandardScheme.class, new writeLecturePermissions_argsStandardSchemeFactory());
      schemes.put(TupleScheme.class, new writeLecturePermissions_argsTupleSchemeFactory());
    }

    public String userToken; // required
    public String lectureId; // required
    public Map<String,LecturePermissions> permissions; // required

    /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
    public enum _Fields implements org.apache.thrift.TFieldIdEnum {
      USER_TOKEN((short)1, "userToken"),
      LECTURE_ID((short)2, "lectureId"),
      PERMISSIONS((short)3, "permissions");

      private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();

      static {
        for (_Fields field : EnumSet.allOf(_Fields.class)) {
          byName.put(field.getFieldName(), field);
        }
      }

      /**
       * Find the _Fields constant that matches fieldId, or null if its not found.
       */
      public static _Fields findByThriftId(int fieldId) {
        switch(fieldId) {
          case 1: // USER_TOKEN
            return USER_TOKEN;
          case 2: // LECTURE_ID
            return LECTURE_ID;
          case 3: // PERMISSIONS
            return PERMISSIONS;
          default:
            return null;
        }
      }

      /**
       * Find the _Fields constant that matches fieldId, throwing an exception
       * if it is not found.
       */
      public static _Fields findByThriftIdOrThrow(int fieldId) {
        _Fields fields = findByThriftId(fieldId);
        if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
        return fields;
      }

      /**
       * Find the _Fields constant that matches name, or null if its not found.
       */
      public static _Fields findByName(String name) {
        return byName.get(name);
      }

      private final short _thriftId;
      private final String _fieldName;

      _Fields(short thriftId, String fieldName) {
        _thriftId = thriftId;
        _fieldName = fieldName;
      }

      public short getThriftFieldId() {
        return _thriftId;
      }

      public String getFieldName() {
        return _fieldName;
      }
    }

    // isset id assignments
    public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
    static {
      Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
      tmpMap.put(_Fields.USER_TOKEN, new org.apache.thrift.meta_data.FieldMetaData("userToken", org.apache.thrift.TFieldRequirementType.DEFAULT, 
          new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING          , "Token")));
      tmpMap.put(_Fields.LECTURE_ID, new org.apache.thrift.meta_data.FieldMetaData("lectureId", org.apache.thrift.TFieldRequirementType.DEFAULT, 
          new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING          , "UUID")));
      tmpMap.put(_Fields.PERMISSIONS, new org.apache.thrift.meta_data.FieldMetaData("permissions", org.apache.thrift.TFieldRequirementType.DEFAULT, 
          new org.apache.thrift.meta_data.MapMetaData(org.apache.thrift.protocol.TType.MAP, 
              new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING              , "UUID"), 
              new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, LecturePermissions.class))));
      metaDataMap = Collections.unmodifiableMap(tmpMap);
      org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(writeLecturePermissions_args.class, metaDataMap);
    }

    public writeLecturePermissions_args() {
    }

    public writeLecturePermissions_args(
      String userToken,
      String lectureId,
      Map<String,LecturePermissions> permissions)
    {
      this();
      this.userToken = userToken;
      this.lectureId = lectureId;
      this.permissions = permissions;
    }

    /**
     * Performs a deep copy on <i>other</i>.
     */
    public writeLecturePermissions_args(writeLecturePermissions_args other) {
      if (other.isSetUserToken()) {
        this.userToken = other.userToken;
      }
      if (other.isSetLectureId()) {
        this.lectureId = other.lectureId;
      }
      if (other.isSetPermissions()) {
        Map<String,LecturePermissions> __this__permissions = new HashMap<String,LecturePermissions>(other.permissions.size());
        for (Map.Entry<String, LecturePermissions> other_element : other.permissions.entrySet()) {

          String other_element_key = other_element.getKey();
          LecturePermissions other_element_value = other_element.getValue();

          String __this__permissions_copy_key = other_element_key;

          LecturePermissions __this__permissions_copy_value = new LecturePermissions(other_element_value);

          __this__permissions.put(__this__permissions_copy_key, __this__permissions_copy_value);
        }
        this.permissions = __this__permissions;
      }
    }

    public writeLecturePermissions_args deepCopy() {
      return new writeLecturePermissions_args(this);
    }

    @Override
    public void clear() {
      this.userToken = null;
      this.lectureId = null;
      this.permissions = null;
    }

    public String getUserToken() {
      return this.userToken;
    }

    public writeLecturePermissions_args setUserToken(String userToken) {
      this.userToken = userToken;
      return this;
    }

    public void unsetUserToken() {
      this.userToken = null;
    }

    /** Returns true if field userToken is set (has been assigned a value) and false otherwise */
    public boolean isSetUserToken() {
      return this.userToken != null;
    }

    public void setUserTokenIsSet(boolean value) {
      if (!value) {
        this.userToken = null;
      }
    }

    public String getLectureId() {
      return this.lectureId;
    }

    public writeLecturePermissions_args setLectureId(String lectureId) {
      this.lectureId = lectureId;
      return this;
    }

    public void unsetLectureId() {
      this.lectureId = null;
    }

    /** Returns true if field lectureId is set (has been assigned a value) and false otherwise */
    public boolean isSetLectureId() {
      return this.lectureId != null;
    }

    public void setLectureIdIsSet(boolean value) {
      if (!value) {
        this.lectureId = null;
      }
    }

    public int getPermissionsSize() {
      return (this.permissions == null) ? 0 : this.permissions.size();
    }

    public void putToPermissions(String key, LecturePermissions val) {
      if (this.permissions == null) {
        this.permissions = new HashMap<String,LecturePermissions>();
      }
      this.permissions.put(key, val);
    }

    public Map<String,LecturePermissions> getPermissions() {
      return this.permissions;
    }

    public writeLecturePermissions_args setPermissions(Map<String,LecturePermissions> permissions) {
      this.permissions = permissions;
      return this;
    }

    public void unsetPermissions() {
      this.permissions = null;
    }

    /** Returns true if field permissions is set (has been assigned a value) and false otherwise */
    public boolean isSetPermissions() {
      return this.permissions != null;
    }

    public void setPermissionsIsSet(boolean value) {
      if (!value) {
        this.permissions = null;
      }
    }

    public void setFieldValue(_Fields field, Object value) {
      switch (field) {
      case USER_TOKEN:
        if (value == null) {
          unsetUserToken();
        } else {
          setUserToken((String)value);
        }
        break;

      case LECTURE_ID:
        if (value == null) {
          unsetLectureId();
        } else {
          setLectureId((String)value);
        }
        break;

      case PERMISSIONS:
        if (value == null) {
          unsetPermissions();
        } else {
          setPermissions((Map<String,LecturePermissions>)value);
        }
        break;

      }
    }

    public Object getFieldValue(_Fields field) {
      switch (field) {
      case USER_TOKEN:
        return getUserToken();

      case LECTURE_ID:
        return getLectureId();

      case PERMISSIONS:
        return getPermissions();

      }
      throw new IllegalStateException();
    }

    /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
    public boolean isSet(_Fields field) {
      if (field == null) {
        throw new IllegalArgumentException();
      }

      switch (field) {
      case USER_TOKEN:
        return isSetUserToken();
      case LECTURE_ID:
        return isSetLectureId();
      case PERMISSIONS:
        return isSetPermissions();
      }
      throw new IllegalStateException();
    }

    @Override
    public boolean equals(Object that) {
      if (that == null)
        return false;
      if (that instanceof writeLecturePermissions_args)
        return this.equals((writeLecturePermissions_args)that);
      return false;
    }

    public boolean equals(writeLecturePermissions_args that) {
      if (that == null)
        return false;

      boolean this_present_userToken = true && this.isSetUserToken();
      boolean that_present_userToken = true && that.isSetUserToken();
      if (this_present_userToken || that_present_userToken) {
        if (!(this_present_userToken && that_present_userToken))
          return false;
        if (!this.userToken.equals(that.userToken))
          return false;
      }

      boolean this_present_lectureId = true && this.isSetLectureId();
      boolean that_present_lectureId = true && that.isSetLectureId();
      if (this_present_lectureId || that_present_lectureId) {
        if (!(this_present_lectureId && that_present_lectureId))
          return false;
        if (!this.lectureId.equals(that.lectureId))
          return false;
      }

      boolean this_present_permissions = true && this.isSetPermissions();
      boolean that_present_permissions = true && that.isSetPermissions();
      if (this_present_permissions || that_present_permissions) {
        if (!(this_present_permissions && that_present_permissions))
          return false;
        if (!this.permissions.equals(that.permissions))
          return false;
      }

      return true;
    }

    @Override
    public int hashCode() {
      return 0;
    }

    @Override
    public int compareTo(writeLecturePermissions_args other) {
      if (!getClass().equals(other.getClass())) {
        return getClass().getName().compareTo(other.getClass().getName());
      }

      int lastComparison = 0;

      lastComparison = Boolean.valueOf(isSetUserToken()).compareTo(other.isSetUserToken());
      if (lastComparison != 0) {
        return lastComparison;
      }
      if (isSetUserToken()) {
        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.userToken, other.userToken);
        if (lastComparison != 0) {
          return lastComparison;
        }
      }
      lastComparison = Boolean.valueOf(isSetLectureId()).compareTo(other.isSetLectureId());
      if (lastComparison != 0) {
        return lastComparison;
      }
      if (isSetLectureId()) {
        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.lectureId, other.lectureId);
        if (lastComparison != 0) {
          return lastComparison;
        }
      }
      lastComparison = Boolean.valueOf(isSetPermissions()).compareTo(other.isSetPermissions());
      if (lastComparison != 0) {
        return lastComparison;
      }
      if (isSetPermissions()) {
        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.permissions, other.permissions);
        if (lastComparison != 0) {
          return lastComparison;
        }
      }
      return 0;
    }

    public _Fields fieldForId(int fieldId) {
      return _Fields.findByThriftId(fieldId);
    }

    public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
      schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
    }

    public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
      schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
    }

    @Override
    public String toString() {
      StringBuilder sb = new StringBuilder("writeLecturePermissions_args(");
      boolean first = true;

      sb.append("userToken:");
      if (this.userToken == null) {
        sb.append("null");
      } else {
        sb.append(this.userToken);
      }
      first = false;
      if (!first) sb.append(", ");
      sb.append("lectureId:");
      if (this.lectureId == null) {
        sb.append("null");
      } else {
        sb.append(this.lectureId);
      }
      first = false;
      if (!first) sb.append(", ");
      sb.append("permissions:");
      if (this.permissions == null) {
        sb.append("null");
      } else {
        sb.append(this.permissions);
      }
      first = false;
      sb.append(")");
      return sb.toString();
    }

    public void validate() throws org.apache.thrift.TException {
      // check for required fields
      // check for sub-struct validity
    }

    private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
      try {
        write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
      } catch (org.apache.thrift.TException te) {
        throw new java.io.IOException(te);
      }
    }

    private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
      try {
        read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
      } catch (org.apache.thrift.TException te) {
        throw new java.io.IOException(te);
      }
    }

    private static class writeLecturePermissions_argsStandardSchemeFactory implements SchemeFactory {
      public writeLecturePermissions_argsStandardScheme getScheme() {
        return new writeLecturePermissions_argsStandardScheme();
      }
    }

    private static class writeLecturePermissions_argsStandardScheme extends StandardScheme<writeLecturePermissions_args> {

      public void read(org.apache.thrift.protocol.TProtocol iprot, writeLecturePermissions_args struct) throws org.apache.thrift.TException {
        org.apache.thrift.protocol.TField schemeField;
        iprot.readStructBegin();
        while (true)
        {
          schemeField = iprot.readFieldBegin();
          if (schemeField.type == org.apache.thrift.protocol.TType.STOP) { 
            break;
          }
          switch (schemeField.id) {
            case 1: // USER_TOKEN
              if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
                struct.userToken = iprot.readString();
                struct.setUserTokenIsSet(true);
              } else { 
                org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
              }
              break;
            case 2: // LECTURE_ID
              if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
                struct.lectureId = iprot.readString();
                struct.setLectureIdIsSet(true);
              } else { 
                org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
              }
              break;
            case 3: // PERMISSIONS
              if (schemeField.type == org.apache.thrift.protocol.TType.MAP) {
                {
                  org.apache.thrift.protocol.TMap _map214 = iprot.readMapBegin();
                  struct.permissions = new HashMap<String,LecturePermissions>(2*_map214.size);
                  for (int _i215 = 0; _i215 < _map214.size; ++_i215)
                  {
                    String _key216;
                    LecturePermissions _val217;
                    _key216 = iprot.readString();
                    _val217 = new LecturePermissions();
                    _val217.read(iprot);
                    struct.permissions.put(_key216, _val217);
                  }
                  iprot.readMapEnd();
                }
                struct.setPermissionsIsSet(true);
              } else { 
                org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
              }
              break;
            default:
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
          }
          iprot.readFieldEnd();
        }
        iprot.readStructEnd();

        // check for required fields of primitive type, which can't be checked in the validate method
        struct.validate();
      }

      public void write(org.apache.thrift.protocol.TProtocol oprot, writeLecturePermissions_args struct) throws org.apache.thrift.TException {
        struct.validate();

        oprot.writeStructBegin(STRUCT_DESC);
        if (struct.userToken != null) {
          oprot.writeFieldBegin(USER_TOKEN_FIELD_DESC);
          oprot.writeString(struct.userToken);
          oprot.writeFieldEnd();
        }
        if (struct.lectureId != null) {
          oprot.writeFieldBegin(LECTURE_ID_FIELD_DESC);
          oprot.writeString(struct.lectureId);
          oprot.writeFieldEnd();
        }
        if (struct.permissions != null) {
          oprot.writeFieldBegin(PERMISSIONS_FIELD_DESC);
          {
            oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRUCT, struct.permissions.size()));
            for (Map.Entry<String, LecturePermissions> _iter218 : struct.permissions.entrySet())
            {
              oprot.writeString(_iter218.getKey());
              _iter218.getValue().write(oprot);
            }
            oprot.writeMapEnd();
          }
          oprot.writeFieldEnd();
        }
        oprot.writeFieldStop();
        oprot.writeStructEnd();
      }

    }

    private static class writeLecturePermissions_argsTupleSchemeFactory implements SchemeFactory {
      public writeLecturePermissions_argsTupleScheme getScheme() {
        return new writeLecturePermissions_argsTupleScheme();
      }
    }

    private static class writeLecturePermissions_argsTupleScheme extends TupleScheme<writeLecturePermissions_args> {

      @Override
      public void write(org.apache.thrift.protocol.TProtocol prot, writeLecturePermissions_args struct) throws org.apache.thrift.TException {
        TTupleProtocol oprot = (TTupleProtocol) prot;
        BitSet optionals = new BitSet();
        if (struct.isSetUserToken()) {
          optionals.set(0);
        }
        if (struct.isSetLectureId()) {
          optionals.set(1);
        }
        if (struct.isSetPermissions()) {
          optionals.set(2);
        }
        oprot.writeBitSet(optionals, 3);
        if (struct.isSetUserToken()) {
          oprot.writeString(struct.userToken);
        }
        if (struct.isSetLectureId()) {
          oprot.writeString(struct.lectureId);
        }
        if (struct.isSetPermissions()) {
          {
            oprot.writeI32(struct.permissions.size());
            for (Map.Entry<String, LecturePermissions> _iter219 : struct.permissions.entrySet())
            {
              oprot.writeString(_iter219.getKey());
              _iter219.getValue().write(oprot);
            }
          }
        }
      }

      @Override
      public void read(org.apache.thrift.protocol.TProtocol prot, writeLecturePermissions_args struct) throws org.apache.thrift.TException {
        TTupleProtocol iprot = (TTupleProtocol) prot;
        BitSet incoming = iprot.readBitSet(3);
        if (incoming.get(0)) {
          struct.userToken = iprot.readString();
          struct.setUserTokenIsSet(true);
        }
        if (incoming.get(1)) {
          struct.lectureId = iprot.readString();
          struct.setLectureIdIsSet(true);
        }
        if (incoming.get(2)) {
          {
            org.apache.thrift.protocol.TMap _map220 = new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRUCT, iprot.readI32());
            struct.permissions = new HashMap<String,LecturePermissions>(2*_map220.size);
            for (int _i221 = 0; _i221 < _map220.size; ++_i221)
            {
              String _key222;
              LecturePermissions _val223;
              _key222 = iprot.readString();
              _val223 = new LecturePermissions();
              _val223.read(iprot);
              struct.permissions.put(_key222, _val223);
            }
          }
          struct.setPermissionsIsSet(true);
        }
      }
    }

  }

  public static class writeLecturePermissions_result implements org.apache.thrift.TBase<writeLecturePermissions_result, writeLecturePermissions_result._Fields>, java.io.Serializable, Cloneable, Comparable<writeLecturePermissions_result>   {
    private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("writeLecturePermissions_result");

    private static final org.apache.thrift.protocol.TField AUTH_ERROR_FIELD_DESC = new org.apache.thrift.protocol.TField("authError", org.apache.thrift.protocol.TType.STRUCT, (short)1);
    private static final org.apache.thrift.protocol.TField NOT_FOUND_FIELD_DESC = new org.apache.thrift.protocol.TField("notFound", org.apache.thrift.protocol.TType.STRUCT, (short)2);
    private static final org.apache.thrift.protocol.TField SERVER_ERROR_FIELD_DESC = new org.apache.thrift.protocol.TField("serverError", org.apache.thrift.protocol.TType.STRUCT, (short)3);

    private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
    static {
      schemes.put(StandardScheme.class, new writeLecturePermissions_resultStandardSchemeFactory());
      schemes.put(TupleScheme.class, new writeLecturePermissions_resultTupleSchemeFactory());
    }

    public TAuthorizationException authError; // required
    public TNotFoundException notFound; // required
    public TInternalServerError serverError; // required

    /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
    public enum _Fields implements org.apache.thrift.TFieldIdEnum {
      AUTH_ERROR((short)1, "authError"),
      NOT_FOUND((short)2, "notFound"),
      SERVER_ERROR((short)3, "serverError");

      private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();

      static {
        for (_Fields field : EnumSet.allOf(_Fields.class)) {
          byName.put(field.getFieldName(), field);
        }
      }

      /**
       * Find the _Fields constant that matches fieldId, or null if its not found.
       */
      public static _Fields findByThriftId(int fieldId) {
        switch(fieldId) {
          case 1: // AUTH_ERROR
            return AUTH_ERROR;
          case 2: // NOT_FOUND
            return NOT_FOUND;
          case 3: // SERVER_ERROR
            return SERVER_ERROR;
          default:
            return null;
        }
      }

      /**
       * Find the _Fields constant that matches fieldId, throwing an exception
       * if it is not found.
       */
      public static _Fields findByThriftIdOrThrow(int fieldId) {
        _Fields fields = findByThriftId(fieldId);
        if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
        return fields;
      }

      /**
       * Find the _Fields constant that matches name, or null if its not found.
       */
      public static _Fields findByName(String name) {
        return byName.get(name);
      }

      private final short _thriftId;
      private final String _fieldName;

      _Fields(short thriftId, String fieldName) {
        _thriftId = thriftId;
        _fieldName = fieldName;
      }

      public short getThriftFieldId() {
        return _thriftId;
      }

      public String getFieldName() {
        return _fieldName;
      }
    }

    // isset id assignments
    public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
    static {
      Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
      tmpMap.put(_Fields.AUTH_ERROR, new org.apache.thrift.meta_data.FieldMetaData("authError", org.apache.thrift.TFieldRequirementType.DEFAULT, 
          new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT)));
      tmpMap.put(_Fields.NOT_FOUND, new org.apache.thrift.meta_data.FieldMetaData("notFound", org.apache.thrift.TFieldRequirementType.DEFAULT, 
          new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT)));
      tmpMap.put(_Fields.SERVER_ERROR, new org.apache.thrift.meta_data.FieldMetaData("serverError", org.apache.thrift.TFieldRequirementType.DEFAULT, 
          new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT)));
      metaDataMap = Collections.unmodifiableMap(tmpMap);
      org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(writeLecturePermissions_result.class, metaDataMap);
    }

    public writeLecturePermissions_result() {
    }

    public writeLecturePermissions_result(
      TAuthorizationException authError,
      TNotFoundException notFound,
      TInternalServerError serverError)
    {
      this();
      this.authError = authError;
      this.notFound = notFound;
      this.serverError = serverError;
    }

    /**
     * Performs a deep copy on <i>other</i>.
     */
    public writeLecturePermissions_result(writeLecturePermissions_result other) {
      if (other.isSetAuthError()) {
        this.authError = new TAuthorizationException(other.authError);
      }
      if (other.isSetNotFound()) {
        this.notFound = new TNotFoundException(other.notFound);
      }
      if (other.isSetServerError()) {
        this.serverError = new TInternalServerError(other.serverError);
      }
    }

    public writeLecturePermissions_result deepCopy() {
      return new writeLecturePermissions_result(this);
    }

    @Override
    public void clear() {
      this.authError = null;
      this.notFound = null;
      this.serverError = null;
    }

    public TAuthorizationException getAuthError() {
      return this.authError;
    }

    public writeLecturePermissions_result setAuthError(TAuthorizationException authError) {
      this.authError = authError;
      return this;
    }

    public void unsetAuthError() {
      this.authError = null;
    }

    /** Returns true if field authError is set (has been assigned a value) and false otherwise */
    public boolean isSetAuthError() {
      return this.authError != null;
    }

    public void setAuthErrorIsSet(boolean value) {
      if (!value) {
        this.authError = null;
      }
    }

    public TNotFoundException getNotFound() {
      return this.notFound;
    }

    public writeLecturePermissions_result setNotFound(TNotFoundException notFound) {
      this.notFound = notFound;
      return this;
    }

    public void unsetNotFound() {
      this.notFound = null;
    }

    /** Returns true if field notFound is set (has been assigned a value) and false otherwise */
    public boolean isSetNotFound() {
      return this.notFound != null;
    }

    public void setNotFoundIsSet(boolean value) {
      if (!value) {
        this.notFound = null;
      }
    }

    public TInternalServerError getServerError() {
      return this.serverError;
    }

    public writeLecturePermissions_result setServerError(TInternalServerError serverError) {
      this.serverError = serverError;
      return this;
    }

    public void unsetServerError() {
      this.serverError = null;
    }

    /** Returns true if field serverError is set (has been assigned a value) and false otherwise */
    public boolean isSetServerError() {
      return this.serverError != null;
    }

    public void setServerErrorIsSet(boolean value) {
      if (!value) {
        this.serverError = null;
      }
    }

    public void setFieldValue(_Fields field, Object value) {
      switch (field) {
      case AUTH_ERROR:
        if (value == null) {
          unsetAuthError();
        } else {
          setAuthError((TAuthorizationException)value);
        }
        break;

      case NOT_FOUND:
        if (value == null) {
          unsetNotFound();
        } else {
          setNotFound((TNotFoundException)value);
        }
        break;

      case SERVER_ERROR:
        if (value == null) {
          unsetServerError();
        } else {
          setServerError((TInternalServerError)value);
        }
        break;

      }
    }

    public Object getFieldValue(_Fields field) {
      switch (field) {
      case AUTH_ERROR:
        return getAuthError();

      case NOT_FOUND:
        return getNotFound();

      case SERVER_ERROR:
        return getServerError();

      }
      throw new IllegalStateException();
    }

    /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
    public boolean isSet(_Fields field) {
      if (field == null) {
        throw new IllegalArgumentException();
      }

      switch (field) {
      case AUTH_ERROR:
        return isSetAuthError();
      case NOT_FOUND:
        return isSetNotFound();
      case SERVER_ERROR:
        return isSetServerError();
      }
      throw new IllegalStateException();
    }

    @Override
    public boolean equals(Object that) {
      if (that == null)
        return false;
      if (that instanceof writeLecturePermissions_result)
        return this.equals((writeLecturePermissions_result)that);
      return false;
    }

    public boolean equals(writeLecturePermissions_result that) {
      if (that == null)
        return false;

      boolean this_present_authError = true && this.isSetAuthError();
      boolean that_present_authError = true && that.isSetAuthError();
      if (this_present_authError || that_present_authError) {
        if (!(this_present_authError && that_present_authError))
          return false;
        if (!this.authError.equals(that.authError))
          return false;
      }

      boolean this_present_notFound = true && this.isSetNotFound();
      boolean that_present_notFound = true && that.isSetNotFound();
      if (this_present_notFound || that_present_notFound) {
        if (!(this_present_notFound && that_present_notFound))
          return false;
        if (!this.notFound.equals(that.notFound))
          return false;
      }

      boolean this_present_serverError = true && this.isSetServerError();
      boolean that_present_serverError = true && that.isSetServerError();
      if (this_present_serverError || that_present_serverError) {
        if (!(this_present_serverError && that_present_serverError))
          return false;
        if (!this.serverError.equals(that.serverError))
          return false;
      }

      return true;
    }

    @Override
    public int hashCode() {
      return 0;
    }

    @Override
    public int compareTo(writeLecturePermissions_result other) {
      if (!getClass().equals(other.getClass())) {
        return getClass().getName().compareTo(other.getClass().getName());
      }

      int lastComparison = 0;

      lastComparison = Boolean.valueOf(isSetAuthError()).compareTo(other.isSetAuthError());
      if (lastComparison != 0) {
        return lastComparison;
      }
      if (isSetAuthError()) {
        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.authError, other.authError);
        if (lastComparison != 0) {
          return lastComparison;
        }
      }
      lastComparison = Boolean.valueOf(isSetNotFound()).compareTo(other.isSetNotFound());
      if (lastComparison != 0) {
        return lastComparison;
      }
      if (isSetNotFound()) {
        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.notFound, other.notFound);
        if (lastComparison != 0) {
          return lastComparison;
        }
      }
      lastComparison = Boolean.valueOf(isSetServerError()).compareTo(other.isSetServerError());
      if (lastComparison != 0) {
        return lastComparison;
      }
      if (isSetServerError()) {
        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.serverError, other.serverError);
        if (lastComparison != 0) {
          return lastComparison;
        }
      }
      return 0;
    }

    public _Fields fieldForId(int fieldId) {
      return _Fields.findByThriftId(fieldId);
    }

    public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
      schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
    }

    public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
      schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
      }

    @Override
    public String toString() {
      StringBuilder sb = new StringBuilder("writeLecturePermissions_result(");
      boolean first = true;

      sb.append("authError:");
      if (this.authError == null) {
        sb.append("null");
      } else {
        sb.append(this.authError);
      }
      first = false;
      if (!first) sb.append(", ");
      sb.append("notFound:");
      if (this.notFound == null) {
        sb.append("null");
      } else {
        sb.append(this.notFound);
      }
      first = false;
      if (!first) sb.append(", ");
      sb.append("serverError:");
      if (this.serverError == null) {
        sb.append("null");
      } else {
        sb.append(this.serverError);
      }
      first = false;
      sb.append(")");
      return sb.toString();
    }

    public void validate() throws org.apache.thrift.TException {
      // check for required fields
      // check for sub-struct validity
    }

    private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
      try {
        write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
      } catch (org.apache.thrift.TException te) {
        throw new java.io.IOException(te);
      }
    }

    private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
      try {
        read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
      } catch (org.apache.thrift.TException te) {
        throw new java.io.IOException(te);
      }
    }

    private static class writeLecturePermissions_resultStandardSchemeFactory implements SchemeFactory {
      public writeLecturePermissions_resultStandardScheme getScheme() {
        return new writeLecturePermissions_resultStandardScheme();
      }
    }

    private static class writeLecturePermissions_resultStandardScheme extends StandardScheme<writeLecturePermissions_result> {

      public void read(org.apache.thrift.protocol.TProtocol iprot, writeLecturePermissions_result struct) throws org.apache.thrift.TException {
        org.apache.thrift.protocol.TField schemeField;
        iprot.readStructBegin();
        while (true)
        {
          schemeField = iprot.readFieldBegin();
          if (schemeField.type == org.apache.thrift.protocol.TType.STOP) { 
            break;
          }
          switch (schemeField.id) {
            case 1: // AUTH_ERROR
              if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
                struct.authError = new TAuthorizationException();
                struct.authError.read(iprot);
                struct.setAuthErrorIsSet(true);
              } else { 
                org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
              }
              break;
            case 2: // NOT_FOUND
              if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
                struct.notFound = new TNotFoundException();
                struct.notFound.read(iprot);
                struct.setNotFoundIsSet(true);
              } else { 
                org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
              }
              break;
            case 3: // SERVER_ERROR
              if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
                struct.serverError = new TInternalServerError();
                struct.serverError.read(iprot);
                struct.setServerErrorIsSet(true);
              } else { 
                org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
              }
              break;
            default:
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
          }
          iprot.readFieldEnd();
        }
        iprot.readStructEnd();

        // check for required fields of primitive type, which can't be checked in the validate method
        struct.validate();
      }

      public void write(org.apache.thrift.protocol.TProtocol oprot, writeLecturePermissions_result struct) throws org.apache.thrift.TException {
        struct.validate();

        oprot.writeStructBegin(STRUCT_DESC);
        if (struct.authError != null) {
          oprot.writeFieldBegin(AUTH_ERROR_FIELD_DESC);
          struct.authError.write(oprot);
          oprot.writeFieldEnd();
        }
        if (struct.notFound != null) {
          oprot.writeFieldBegin(NOT_FOUND_FIELD_DESC);
          struct.notFound.write(oprot);
          oprot.writeFieldEnd();
        }
        if (struct.serverError != null) {
          oprot.writeFieldBegin(SERVER_ERROR_FIELD_DESC);
          struct.serverError.write(oprot);
          oprot.writeFieldEnd();
        }
        oprot.writeFieldStop();
        oprot.writeStructEnd();
      }

    }

    private static class writeLecturePermissions_resultTupleSchemeFactory implements SchemeFactory {
      public writeLecturePermissions_resultTupleScheme getScheme() {
        return new writeLecturePermissions_resultTupleScheme();
      }
    }

    private static class writeLecturePermissions_resultTupleScheme extends TupleScheme<writeLecturePermissions_result> {

      @Override
      public void write(org.apache.thrift.protocol.TProtocol prot, writeLecturePermissions_result struct) throws org.apache.thrift.TException {
        TTupleProtocol oprot = (TTupleProtocol) prot;
        BitSet optionals = new BitSet();
        if (struct.isSetAuthError()) {
          optionals.set(0);
        }
        if (struct.isSetNotFound()) {
          optionals.set(1);
        }
        if (struct.isSetServerError()) {
          optionals.set(2);
        }
        oprot.writeBitSet(optionals, 3);
        if (struct.isSetAuthError()) {
          struct.authError.write(oprot);
        }
        if (struct.isSetNotFound()) {
          struct.notFound.write(oprot);
        }
        if (struct.isSetServerError()) {
          struct.serverError.write(oprot);
        }
      }

      @Override
      public void read(org.apache.thrift.protocol.TProtocol prot, writeLecturePermissions_result struct) throws org.apache.thrift.TException {
        TTupleProtocol iprot = (TTupleProtocol) prot;
        BitSet incoming = iprot.readBitSet(3);
        if (incoming.get(0)) {
          struct.authError = new TAuthorizationException();
          struct.authError.read(iprot);
          struct.setAuthErrorIsSet(true);
        }
        if (incoming.get(1)) {
          struct.notFound = new TNotFoundException();
          struct.notFound.read(iprot);
          struct.setNotFoundIsSet(true);
        }
        if (incoming.get(2)) {
          struct.serverError = new TInternalServerError();
          struct.serverError.read(iprot);
          struct.setServerErrorIsSet(true);
        }
      }
    }

  }

  public static class getLecturePermissions_args implements org.apache.thrift.TBase<getLecturePermissions_args, getLecturePermissions_args._Fields>, java.io.Serializable, Cloneable, Comparable<getLecturePermissions_args>   {
    private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getLecturePermissions_args");

    private static final org.apache.thrift.protocol.TField USER_TOKEN_FIELD_DESC = new org.apache.thrift.protocol.TField("userToken", org.apache.thrift.protocol.TType.STRING, (short)1);
    private static final org.apache.thrift.protocol.TField LECTURE_ID_FIELD_DESC = new org.apache.thrift.protocol.TField("lectureId", org.apache.thrift.protocol.TType.STRING, (short)2);

    private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
    static {
      schemes.put(StandardScheme.class, new getLecturePermissions_argsStandardSchemeFactory());
      schemes.put(TupleScheme.class, new getLecturePermissions_argsTupleSchemeFactory());
    }

    public String userToken; // required
    public String lectureId; // required

    /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
    public enum _Fields implements org.apache.thrift.TFieldIdEnum {
      USER_TOKEN((short)1, "userToken"),
      LECTURE_ID((short)2, "lectureId");

      private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();

      static {
        for (_Fields field : EnumSet.allOf(_Fields.class)) {
          byName.put(field.getFieldName(), field);
        }
      }

      /**
       * Find the _Fields constant that matches fieldId, or null if its not found.
       */
      public static _Fields findByThriftId(int fieldId) {
        switch(fieldId) {
          case 1: // USER_TOKEN
            return USER_TOKEN;
          case 2: // LECTURE_ID
            return LECTURE_ID;
          default:
            return null;
        }
      }

      /**
       * Find the _Fields constant that matches fieldId, throwing an exception
       * if it is not found.
       */
      public static _Fields findByThriftIdOrThrow(int fieldId) {
        _Fields fields = findByThriftId(fieldId);
        if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
        return fields;
      }

      /**
       * Find the _Fields constant that matches name, or null if its not found.
       */
      public static _Fields findByName(String name) {
        return byName.get(name);
      }

      private final short _thriftId;
      private final String _fieldName;

      _Fields(short thriftId, String fieldName) {
        _thriftId = thriftId;
        _fieldName = fieldName;
      }

      public short getThriftFieldId() {
        return _thriftId;
      }

      public String getFieldName() {
        return _fieldName;
      }
    }

    // isset id assignments
    public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
    static {
      Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
      tmpMap.put(_Fields.USER_TOKEN, new org.apache.thrift.meta_data.FieldMetaData("userToken", org.apache.thrift.TFieldRequirementType.DEFAULT, 
          new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING          , "Token")));
      tmpMap.put(_Fields.LECTURE_ID, new org.apache.thrift.meta_data.FieldMetaData("lectureId", org.apache.thrift.TFieldRequirementType.DEFAULT, 
          new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING          , "UUID")));
      metaDataMap = Collections.unmodifiableMap(tmpMap);
      org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getLecturePermissions_args.class, metaDataMap);
    }

    public getLecturePermissions_args() {
    }

    public getLecturePermissions_args(
      String userToken,
      String lectureId)
    {
      this();
      this.userToken = userToken;
      this.lectureId = lectureId;
    }

    /**
     * Performs a deep copy on <i>other</i>.
     */
    public getLecturePermissions_args(getLecturePermissions_args other) {
      if (other.isSetUserToken()) {
        this.userToken = other.userToken;
      }
      if (other.isSetLectureId()) {
        this.lectureId = other.lectureId;
      }
    }

    public getLecturePermissions_args deepCopy() {
      return new getLecturePermissions_args(this);
    }

    @Override
    public void clear() {
      this.userToken = null;
      this.lectureId = null;
    }

    public String getUserToken() {
      return this.userToken;
    }

    public getLecturePermissions_args setUserToken(String userToken) {
      this.userToken = userToken;
      return this;
    }

    public void unsetUserToken() {
      this.userToken = null;
    }

    /** Returns true if field userToken is set (has been assigned a value) and false otherwise */
    public boolean isSetUserToken() {
      return this.userToken != null;
    }

    public void setUserTokenIsSet(boolean value) {
      if (!value) {
        this.userToken = null;
      }
    }

    public String getLectureId() {
      return this.lectureId;
    }

    public getLecturePermissions_args setLectureId(String lectureId) {
      this.lectureId = lectureId;
      return this;
    }

    public void unsetLectureId() {
      this.lectureId = null;
    }

    /** Returns true if field lectureId is set (has been assigned a value) and false otherwise */
    public boolean isSetLectureId() {
      return this.lectureId != null;
    }

    public void setLectureIdIsSet(boolean value) {
      if (!value) {
        this.lectureId = null;
      }
    }

    public void setFieldValue(_Fields field, Object value) {
      switch (field) {
      case USER_TOKEN:
        if (value == null) {
          unsetUserToken();
        } else {
          setUserToken((String)value);
        }
        break;

      case LECTURE_ID:
        if (value == null) {
          unsetLectureId();
        } else {
          setLectureId((String)value);
        }
        break;

      }
    }

    public Object getFieldValue(_Fields field) {
      switch (field) {
      case USER_TOKEN:
        return getUserToken();

      case LECTURE_ID:
        return getLectureId();

      }
      throw new IllegalStateException();
    }

    /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
    public boolean isSet(_Fields field) {
      if (field == null) {
        throw new IllegalArgumentException();
      }

      switch (field) {
      case USER_TOKEN:
        return isSetUserToken();
      case LECTURE_ID:
        return isSetLectureId();
      }
      throw new IllegalStateException();
    }

    @Override
    public boolean equals(Object that) {
      if (that == null)
        return false;
      if (that instanceof getLecturePermissions_args)
        return this.equals((getLecturePermissions_args)that);
      return false;
    }

    public boolean equals(getLecturePermissions_args that) {
      if (that == null)
        return false;

      boolean this_present_userToken = true && this.isSetUserToken();
      boolean that_present_userToken = true && that.isSetUserToken();
      if (this_present_userToken || that_present_userToken) {
        if (!(this_present_userToken && that_present_userToken))
          return false;
        if (!this.userToken.equals(that.userToken))
          return false;
      }

      boolean this_present_lectureId = true && this.isSetLectureId();
      boolean that_present_lectureId = true && that.isSetLectureId();
      if (this_present_lectureId || that_present_lectureId) {
        if (!(this_present_lectureId && that_present_lectureId))
          return false;
        if (!this.lectureId.equals(that.lectureId))
          return false;
      }

      return true;
    }

    @Override
    public int hashCode() {
      return 0;
    }

    @Override
    public int compareTo(getLecturePermissions_args other) {
      if (!getClass().equals(other.getClass())) {
        return getClass().getName().compareTo(other.getClass().getName());
      }

      int lastComparison = 0;

      lastComparison = Boolean.valueOf(isSetUserToken()).compareTo(other.isSetUserToken());
      if (lastComparison != 0) {
        return lastComparison;
      }
      if (isSetUserToken()) {
        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.userToken, other.userToken);
        if (lastComparison != 0) {
          return lastComparison;
        }
      }
      lastComparison = Boolean.valueOf(isSetLectureId()).compareTo(other.isSetLectureId());
      if (lastComparison != 0) {
        return lastComparison;
      }
      if (isSetLectureId()) {
        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.lectureId, other.lectureId);
        if (lastComparison != 0) {
          return lastComparison;
        }
      }
      return 0;
    }

    public _Fields fieldForId(int fieldId) {
      return _Fields.findByThriftId(fieldId);
    }

    public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
      schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
    }

    public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
      schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
    }

    @Override
    public String toString() {
      StringBuilder sb = new StringBuilder("getLecturePermissions_args(");
      boolean first = true;

      sb.append("userToken:");
      if (this.userToken == null) {
        sb.append("null");
      } else {
        sb.append(this.userToken);
      }
      first = false;
      if (!first) sb.append(", ");
      sb.append("lectureId:");
      if (this.lectureId == null) {
        sb.append("null");
      } else {
        sb.append(this.lectureId);
      }
      first = false;
      sb.append(")");
      return sb.toString();
    }

    public void validate() throws org.apache.thrift.TException {
      // check for required fields
      // check for sub-struct validity
    }

    private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
      try {
        write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
      } catch (org.apache.thrift.TException te) {
        throw new java.io.IOException(te);
      }
    }

    private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
      try {
        read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
      } catch (org.apache.thrift.TException te) {
        throw new java.io.IOException(te);
      }
    }

    private static class getLecturePermissions_argsStandardSchemeFactory implements SchemeFactory {
      public getLecturePermissions_argsStandardScheme getScheme() {
        return new getLecturePermissions_argsStandardScheme();
      }
    }

    private static class getLecturePermissions_argsStandardScheme extends StandardScheme<getLecturePermissions_args> {

      public void read(org.apache.thrift.protocol.TProtocol iprot, getLecturePermissions_args struct) throws org.apache.thrift.TException {
        org.apache.thrift.protocol.TField schemeField;
        iprot.readStructBegin();
        while (true)
        {
          schemeField = iprot.readFieldBegin();
          if (schemeField.type == org.apache.thrift.protocol.TType.STOP) { 
            break;
          }
          switch (schemeField.id) {
            case 1: // USER_TOKEN
              if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
                struct.userToken = iprot.readString();
                struct.setUserTokenIsSet(true);
              } else { 
                org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
              }
              break;
            case 2: // LECTURE_ID
              if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
                struct.lectureId = iprot.readString();
                struct.setLectureIdIsSet(true);
              } else { 
                org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
              }
              break;
            default:
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
          }
          iprot.readFieldEnd();
        }
        iprot.readStructEnd();

        // check for required fields of primitive type, which can't be checked in the validate method
        struct.validate();
      }

      public void write(org.apache.thrift.protocol.TProtocol oprot, getLecturePermissions_args struct) throws org.apache.thrift.TException {
        struct.validate();

        oprot.writeStructBegin(STRUCT_DESC);
        if (struct.userToken != null) {
          oprot.writeFieldBegin(USER_TOKEN_FIELD_DESC);
          oprot.writeString(struct.userToken);
          oprot.writeFieldEnd();
        }
        if (struct.lectureId != null) {
          oprot.writeFieldBegin(LECTURE_ID_FIELD_DESC);
          oprot.writeString(struct.lectureId);
          oprot.writeFieldEnd();
        }
        oprot.writeFieldStop();
        oprot.writeStructEnd();
      }

    }

    private static class getLecturePermissions_argsTupleSchemeFactory implements SchemeFactory {
      public getLecturePermissions_argsTupleScheme getScheme() {
        return new getLecturePermissions_argsTupleScheme();
      }
    }

    private static class getLecturePermissions_argsTupleScheme extends TupleScheme<getLecturePermissions_args> {

      @Override
      public void write(org.apache.thrift.protocol.TProtocol prot, getLecturePermissions_args struct) throws org.apache.thrift.TException {
        TTupleProtocol oprot = (TTupleProtocol) prot;
        BitSet optionals = new BitSet();
        if (struct.isSetUserToken()) {
          optionals.set(0);
        }
        if (struct.isSetLectureId()) {
          optionals.set(1);
        }
        oprot.writeBitSet(optionals, 2);
        if (struct.isSetUserToken()) {
          oprot.writeString(struct.userToken);
        }
        if (struct.isSetLectureId()) {
          oprot.writeString(struct.lectureId);
        }
      }

      @Override
      public void read(org.apache.thrift.protocol.TProtocol prot, getLecturePermissions_args struct) throws org.apache.thrift.TException {
        TTupleProtocol iprot = (TTupleProtocol) prot;
        BitSet incoming = iprot.readBitSet(2);
        if (incoming.get(0)) {
          struct.userToken = iprot.readString();
          struct.setUserTokenIsSet(true);
        }
        if (incoming.get(1)) {
          struct.lectureId = iprot.readString();
          struct.setLectureIdIsSet(true);
        }
      }
    }

  }

  public static class getLecturePermissions_result implements org.apache.thrift.TBase<getLecturePermissions_result, getLecturePermissions_result._Fields>, java.io.Serializable, Cloneable, Comparable<getLecturePermissions_result>   {
    private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getLecturePermissions_result");

    private static final org.apache.thrift.protocol.TField SUCCESS_FIELD_DESC = new org.apache.thrift.protocol.TField("success", org.apache.thrift.protocol.TType.MAP, (short)0);
    private static final org.apache.thrift.protocol.TField AUTH_ERROR_FIELD_DESC = new org.apache.thrift.protocol.TField("authError", org.apache.thrift.protocol.TType.STRUCT, (short)1);
    private static final org.apache.thrift.protocol.TField NOT_FOUND_FIELD_DESC = new org.apache.thrift.protocol.TField("notFound", org.apache.thrift.protocol.TType.STRUCT, (short)2);
    private static final org.apache.thrift.protocol.TField SERVER_ERROR_FIELD_DESC = new org.apache.thrift.protocol.TField("serverError", org.apache.thrift.protocol.TType.STRUCT, (short)3);

    private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
    static {
      schemes.put(StandardScheme.class, new getLecturePermissions_resultStandardSchemeFactory());
      schemes.put(TupleScheme.class, new getLecturePermissions_resultTupleSchemeFactory());
    }

    public Map<String,LecturePermissions> success; // required
    public TAuthorizationException authError; // required
    public TNotFoundException notFound; // required
    public TInternalServerError serverError; // required

    /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
    public enum _Fields implements org.apache.thrift.TFieldIdEnum {
      SUCCESS((short)0, "success"),
      AUTH_ERROR((short)1, "authError"),
      NOT_FOUND((short)2, "notFound"),
      SERVER_ERROR((short)3, "serverError");

      private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();

      static {
        for (_Fields field : EnumSet.allOf(_Fields.class)) {
          byName.put(field.getFieldName(), field);
        }
      }

      /**
       * Find the _Fields constant that matches fieldId, or null if its not found.
       */
      public static _Fields findByThriftId(int fieldId) {
        switch(fieldId) {
          case 0: // SUCCESS
            return SUCCESS;
          case 1: // AUTH_ERROR
            return AUTH_ERROR;
          case 2: // NOT_FOUND
            return NOT_FOUND;
          case 3: // SERVER_ERROR
            return SERVER_ERROR;
          default:
            return null;
        }
      }

      /**
       * Find the _Fields constant that matches fieldId, throwing an exception
       * if it is not found.
       */
      public static _Fields findByThriftIdOrThrow(int fieldId) {
        _Fields fields = findByThriftId(fieldId);
        if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
        return fields;
      }

      /**
       * Find the _Fields constant that matches name, or null if its not found.
       */
      public static _Fields findByName(String name) {
        return byName.get(name);
      }

      private final short _thriftId;
      private final String _fieldName;

      _Fields(short thriftId, String fieldName) {
        _thriftId = thriftId;
        _fieldName = fieldName;
      }

      public short getThriftFieldId() {
        return _thriftId;
      }

      public String getFieldName() {
        return _fieldName;
      }
    }

    // isset id assignments
    public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
    static {
      Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
      tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, 
          new org.apache.thrift.meta_data.MapMetaData(org.apache.thrift.protocol.TType.MAP, 
              new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING              , "UUID"), 
              new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, LecturePermissions.class))));
      tmpMap.put(_Fields.AUTH_ERROR, new org.apache.thrift.meta_data.FieldMetaData("authError", org.apache.thrift.TFieldRequirementType.DEFAULT, 
          new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT)));
      tmpMap.put(_Fields.NOT_FOUND, new org.apache.thrift.meta_data.FieldMetaData("notFound", org.apache.thrift.TFieldRequirementType.DEFAULT, 
          new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT)));
      tmpMap.put(_Fields.SERVER_ERROR, new org.apache.thrift.meta_data.FieldMetaData("serverError", org.apache.thrift.TFieldRequirementType.DEFAULT, 
          new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT)));
      metaDataMap = Collections.unmodifiableMap(tmpMap);
      org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getLecturePermissions_result.class, metaDataMap);
    }

    public getLecturePermissions_result() {
    }

    public getLecturePermissions_result(
      Map<String,LecturePermissions> success,
      TAuthorizationException authError,
      TNotFoundException notFound,
      TInternalServerError serverError)
    {
      this();
      this.success = success;
      this.authError = authError;
      this.notFound = notFound;
      this.serverError = serverError;
    }

    /**
     * Performs a deep copy on <i>other</i>.
     */
    public getLecturePermissions_result(getLecturePermissions_result other) {
      if (other.isSetSuccess()) {
        Map<String,LecturePermissions> __this__success = new HashMap<String,LecturePermissions>(other.success.size());
        for (Map.Entry<String, LecturePermissions> other_element : other.success.entrySet()) {

          String other_element_key = other_element.getKey();
          LecturePermissions other_element_value = other_element.getValue();

          String __this__success_copy_key = other_element_key;

          LecturePermissions __this__success_copy_value = new LecturePermissions(other_element_value);

          __this__success.put(__this__success_copy_key, __this__success_copy_value);
        }
        this.success = __this__success;
      }
      if (other.isSetAuthError()) {
        this.authError = new TAuthorizationException(other.authError);
      }
      if (other.isSetNotFound()) {
        this.notFound = new TNotFoundException(other.notFound);
      }
      if (other.isSetServerError()) {
        this.serverError = new TInternalServerError(other.serverError);
      }
    }

    public getLecturePermissions_result deepCopy() {
      return new getLecturePermissions_result(this);
    }

    @Override
    public void clear() {
      this.success = null;
      this.authError = null;
      this.notFound = null;
      this.serverError = null;
    }

    public int getSuccessSize() {
      return (this.success == null) ? 0 : this.success.size();
    }

    public void putToSuccess(String key, LecturePermissions val) {
      if (this.success == null) {
        this.success = new HashMap<String,LecturePermissions>();
      }
      this.success.put(key, val);
    }

    public Map<String,LecturePermissions> getSuccess() {
      return this.success;
    }

    public getLecturePermissions_result setSuccess(Map<String,LecturePermissions> success) {
      this.success = success;
      return this;
    }

    public void unsetSuccess() {
      this.success = null;
    }

    /** Returns true if field success is set (has been assigned a value) and false otherwise */
    public boolean isSetSuccess() {
      return this.success != null;
    }

    public void setSuccessIsSet(boolean value) {
      if (!value) {
        this.success = null;
      }
    }

    public TAuthorizationException getAuthError() {
      return this.authError;
    }

    public getLecturePermissions_result setAuthError(TAuthorizationException authError) {
      this.authError = authError;
      return this;
    }

    public void unsetAuthError() {
      this.authError = null;
    }

    /** Returns true if field authError is set (has been assigned a value) and false otherwise */
    public boolean isSetAuthError() {
      return this.authError != null;
    }

    public void setAuthErrorIsSet(boolean value) {
      if (!value) {
        this.authError = null;
      }
    }

    public TNotFoundException getNotFound() {
      return this.notFound;
    }

    public getLecturePermissions_result setNotFound(TNotFoundException notFound) {
      this.notFound = notFound;
      return this;
    }

    public void unsetNotFound() {
      this.notFound = null;
    }

    /** Returns true if field notFound is set (has been assigned a value) and false otherwise */
    public boolean isSetNotFound() {
      return this.notFound != null;
    }

    public void setNotFoundIsSet(boolean value) {
      if (!value) {
        this.notFound = null;
      }
    }

    public TInternalServerError getServerError() {
      return this.serverError;
    }

    public getLecturePermissions_result setServerError(TInternalServerError serverError) {
      this.serverError = serverError;
      return this;
    }

    public void unsetServerError() {
      this.serverError = null;
    }

    /** Returns true if field serverError is set (has been assigned a value) and false otherwise */
    public boolean isSetServerError() {
      return this.serverError != null;
    }

    public void setServerErrorIsSet(boolean value) {
      if (!value) {
        this.serverError = null;
      }
    }

    public void setFieldValue(_Fields field, Object value) {
      switch (field) {
      case SUCCESS:
        if (value == null) {
          unsetSuccess();
        } else {
          setSuccess((Map<String,LecturePermissions>)value);
        }
        break;

      case AUTH_ERROR:
        if (value == null) {
          unsetAuthError();
        } else {
          setAuthError((TAuthorizationException)value);
        }
        break;

      case NOT_FOUND:
        if (value == null) {
          unsetNotFound();
        } else {
          setNotFound((TNotFoundException)value);
        }
        break;

      case SERVER_ERROR:
        if (value == null) {
          unsetServerError();
        } else {
          setServerError((TInternalServerError)value);
        }
        break;

      }
    }

    public Object getFieldValue(_Fields field) {
      switch (field) {
      case SUCCESS:
        return getSuccess();

      case AUTH_ERROR:
        return getAuthError();

      case NOT_FOUND:
        return getNotFound();

      case SERVER_ERROR:
        return getServerError();

      }
      throw new IllegalStateException();
    }

    /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
    public boolean isSet(_Fields field) {
      if (field == null) {
        throw new IllegalArgumentException();
      }

      switch (field) {
      case SUCCESS:
        return isSetSuccess();
      case AUTH_ERROR:
        return isSetAuthError();
      case NOT_FOUND:
        return isSetNotFound();
      case SERVER_ERROR:
        return isSetServerError();
      }
      throw new IllegalStateException();
    }

    @Override
    public boolean equals(Object that) {
      if (that == null)
        return false;
      if (that instanceof getLecturePermissions_result)
        return this.equals((getLecturePermissions_result)that);
      return false;
    }

    public boolean equals(getLecturePermissions_result that) {
      if (that == null)
        return false;

      boolean this_present_success = true && this.isSetSuccess();
      boolean that_present_success = true && that.isSetSuccess();
      if (this_present_success || that_present_success) {
        if (!(this_present_success && that_present_success))
          return false;
        if (!this.success.equals(that.success))
          return false;
      }

      boolean this_present_authError = true && this.isSetAuthError();
      boolean that_present_authError = true && that.isSetAuthError();
      if (this_present_authError || that_present_authError) {
        if (!(this_present_authError && that_present_authError))
          return false;
        if (!this.authError.equals(that.authError))
          return false;
      }

      boolean this_present_notFound = true && this.isSetNotFound();
      boolean that_present_notFound = true && that.isSetNotFound();
      if (this_present_notFound || that_present_notFound) {
        if (!(this_present_notFound && that_present_notFound))
          return false;
        if (!this.notFound.equals(that.notFound))
          return false;
      }

      boolean this_present_serverError = true && this.isSetServerError();
      boolean that_present_serverError = true && that.isSetServerError();
      if (this_present_serverError || that_present_serverError) {
        if (!(this_present_serverError && that_present_serverError))
          return false;
        if (!this.serverError.equals(that.serverError))
          return false;
      }

      return true;
    }

    @Override
    public int hashCode() {
      return 0;
    }

    @Override
    public int compareTo(getLecturePermissions_result other) {
      if (!getClass().equals(other.getClass())) {
        return getClass().getName().compareTo(other.getClass().getName());
      }

      int lastComparison = 0;

      lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(other.isSetSuccess());
      if (lastComparison != 0) {
        return lastComparison;
      }
      if (isSetSuccess()) {
        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, other.success);
        if (lastComparison != 0) {
          return lastComparison;
        }
      }
      lastComparison = Boolean.valueOf(isSetAuthError()).compareTo(other.isSetAuthError());
      if (lastComparison != 0) {
        return lastComparison;
      }
      if (isSetAuthError()) {
        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.authError, other.authError);
        if (lastComparison != 0) {
          return lastComparison;
        }
      }
      lastComparison = Boolean.valueOf(isSetNotFound()).compareTo(other.isSetNotFound());
      if (lastComparison != 0) {
        return lastComparison;
      }
      if (isSetNotFound()) {
        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.notFound, other.notFound);
        if (lastComparison != 0) {
          return lastComparison;
        }
      }
      lastComparison = Boolean.valueOf(isSetServerError()).compareTo(other.isSetServerError());
      if (lastComparison != 0) {
        return lastComparison;
      }
      if (isSetServerError()) {
        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.serverError, other.serverError);
        if (lastComparison != 0) {
          return lastComparison;
        }
      }
      return 0;
    }

    public _Fields fieldForId(int fieldId) {
      return _Fields.findByThriftId(fieldId);
    }

    public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
      schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
    }

    public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
      schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
      }

    @Override
    public String toString() {
      StringBuilder sb = new StringBuilder("getLecturePermissions_result(");
      boolean first = true;

      sb.append("success:");
      if (this.success == null) {
        sb.append("null");
      } else {
        sb.append(this.success);
      }
      first = false;
      if (!first) sb.append(", ");
      sb.append("authError:");
      if (this.authError == null) {
        sb.append("null");
      } else {
        sb.append(this.authError);
      }
      first = false;
      if (!first) sb.append(", ");
      sb.append("notFound:");
      if (this.notFound == null) {
        sb.append("null");
      } else {
        sb.append(this.notFound);
      }
      first = false;
      if (!first) sb.append(", ");
      sb.append("serverError:");
      if (this.serverError == null) {
        sb.append("null");
      } else {
        sb.append(this.serverError);
      }
      first = false;
      sb.append(")");
      return sb.toString();
    }

    public void validate() throws org.apache.thrift.TException {
      // check for required fields
      // check for sub-struct validity
    }

    private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
      try {
        write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
      } catch (org.apache.thrift.TException te) {
        throw new java.io.IOException(te);
      }
    }

    private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
      try {
        read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
      } catch (org.apache.thrift.TException te) {
        throw new java.io.IOException(te);
      }
    }

    private static class getLecturePermissions_resultStandardSchemeFactory implements SchemeFactory {
      public getLecturePermissions_resultStandardScheme getScheme() {
        return new getLecturePermissions_resultStandardScheme();
      }
    }

    private static class getLecturePermissions_resultStandardScheme extends StandardScheme<getLecturePermissions_result> {

      public void read(org.apache.thrift.protocol.TProtocol iprot, getLecturePermissions_result struct) throws org.apache.thrift.TException {
        org.apache.thrift.protocol.TField schemeField;
        iprot.readStructBegin();
        while (true)
        {
          schemeField = iprot.readFieldBegin();
          if (schemeField.type == org.apache.thrift.protocol.TType.STOP) { 
            break;
          }
          switch (schemeField.id) {
            case 0: // SUCCESS
              if (schemeField.type == org.apache.thrift.protocol.TType.MAP) {
                {
                  org.apache.thrift.protocol.TMap _map224 = iprot.readMapBegin();
                  struct.success = new HashMap<String,LecturePermissions>(2*_map224.size);
                  for (int _i225 = 0; _i225 < _map224.size; ++_i225)
                  {
                    String _key226;
                    LecturePermissions _val227;
                    _key226 = iprot.readString();
                    _val227 = new LecturePermissions();
                    _val227.read(iprot);
                    struct.success.put(_key226, _val227);
                  }
                  iprot.readMapEnd();
                }
                struct.setSuccessIsSet(true);
              } else { 
                org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
              }
              break;
            case 1: // AUTH_ERROR
              if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
                struct.authError = new TAuthorizationException();
                struct.authError.read(iprot);
                struct.setAuthErrorIsSet(true);
              } else { 
                org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
              }
              break;
            case 2: // NOT_FOUND
              if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
                struct.notFound = new TNotFoundException();
                struct.notFound.read(iprot);
                struct.setNotFoundIsSet(true);
              } else { 
                org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
              }
              break;
            case 3: // SERVER_ERROR
              if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
                struct.serverError = new TInternalServerError();
                struct.serverError.read(iprot);
                struct.setServerErrorIsSet(true);
              } else { 
                org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
              }
              break;
            default:
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
          }
          iprot.readFieldEnd();
        }
        iprot.readStructEnd();

        // check for required fields of primitive type, which can't be checked in the validate method
        struct.validate();
      }

      public void write(org.apache.thrift.protocol.TProtocol oprot, getLecturePermissions_result struct) throws org.apache.thrift.TException {
        struct.validate();

        oprot.writeStructBegin(STRUCT_DESC);
        if (struct.success != null) {
          oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
          {
            oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRUCT, struct.success.size()));
            for (Map.Entry<String, LecturePermissions> _iter228 : struct.success.entrySet())
            {
              oprot.writeString(_iter228.getKey());
              _iter228.getValue().write(oprot);
            }
            oprot.writeMapEnd();
          }
          oprot.writeFieldEnd();
        }
        if (struct.authError != null) {
          oprot.writeFieldBegin(AUTH_ERROR_FIELD_DESC);
          struct.authError.write(oprot);
          oprot.writeFieldEnd();
        }
        if (struct.notFound != null) {
          oprot.writeFieldBegin(NOT_FOUND_FIELD_DESC);
          struct.notFound.write(oprot);
          oprot.writeFieldEnd();
        }
        if (struct.serverError != null) {
          oprot.writeFieldBegin(SERVER_ERROR_FIELD_DESC);
          struct.serverError.write(oprot);
          oprot.writeFieldEnd();
        }
        oprot.writeFieldStop();
        oprot.writeStructEnd();
      }

    }

    private static class getLecturePermissions_resultTupleSchemeFactory implements SchemeFactory {
      public getLecturePermissions_resultTupleScheme getScheme() {
        return new getLecturePermissions_resultTupleScheme();
      }
    }

    private static class getLecturePermissions_resultTupleScheme extends TupleScheme<getLecturePermissions_result> {

      @Override
      public void write(org.apache.thrift.protocol.TProtocol prot, getLecturePermissions_result struct) throws org.apache.thrift.TException {
        TTupleProtocol oprot = (TTupleProtocol) prot;
        BitSet optionals = new BitSet();
        if (struct.isSetSuccess()) {
          optionals.set(0);
        }
        if (struct.isSetAuthError()) {
          optionals.set(1);
        }
        if (struct.isSetNotFound()) {
          optionals.set(2);
        }
        if (struct.isSetServerError()) {
          optionals.set(3);
        }
        oprot.writeBitSet(optionals, 4);
        if (struct.isSetSuccess()) {
          {
            oprot.writeI32(struct.success.size());
            for (Map.Entry<String, LecturePermissions> _iter229 : struct.success.entrySet())
            {
              oprot.writeString(_iter229.getKey());
              _iter229.getValue().write(oprot);
            }
          }
        }
        if (struct.isSetAuthError()) {
          struct.authError.write(oprot);
        }
        if (struct.isSetNotFound()) {
          struct.notFound.write(oprot);
        }
        if (struct.isSetServerError()) {
          struct.serverError.write(oprot);
        }
      }

      @Override
      public void read(org.apache.thrift.protocol.TProtocol prot, getLecturePermissions_result struct) throws org.apache.thrift.TException {
        TTupleProtocol iprot = (TTupleProtocol) prot;
        BitSet incoming = iprot.readBitSet(4);
        if (incoming.get(0)) {
          {
            org.apache.thrift.protocol.TMap _map230 = new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRUCT, iprot.readI32());
            struct.success = new HashMap<String,LecturePermissions>(2*_map230.size);
            for (int _i231 = 0; _i231 < _map230.size; ++_i231)
            {
              String _key232;
              LecturePermissions _val233;
              _key232 = iprot.readString();
              _val233 = new LecturePermissions();
              _val233.read(iprot);
              struct.success.put(_key232, _val233);
            }
          }
          struct.setSuccessIsSet(true);
        }
        if (incoming.get(1)) {
          struct.authError = new TAuthorizationException();
          struct.authError.read(iprot);
          struct.setAuthErrorIsSet(true);
        }
        if (incoming.get(2)) {
          struct.notFound = new TNotFoundException();
          struct.notFound.read(iprot);
          struct.setNotFoundIsSet(true);
        }
        if (incoming.get(3)) {
          struct.serverError = new TInternalServerError();
          struct.serverError.read(iprot);
          struct.setServerErrorIsSet(true);
        }
      }
    }

  }

  public static class setLectureOwner_args implements org.apache.thrift.TBase<setLectureOwner_args, setLectureOwner_args._Fields>, java.io.Serializable, Cloneable, Comparable<setLectureOwner_args>   {
    private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("setLectureOwner_args");

    private static final org.apache.thrift.protocol.TField USER_TOKEN_FIELD_DESC = new org.apache.thrift.protocol.TField("userToken", org.apache.thrift.protocol.TType.STRING, (short)1);
    private static final org.apache.thrift.protocol.TField LECTURE_ID_FIELD_DESC = new org.apache.thrift.protocol.TField("lectureId", org.apache.thrift.protocol.TType.STRING, (short)2);
    private static final org.apache.thrift.protocol.TField NEW_OWNER_ID_FIELD_DESC = new org.apache.thrift.protocol.TField("newOwnerId", org.apache.thrift.protocol.TType.STRING, (short)3);

    private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
    static {
      schemes.put(StandardScheme.class, new setLectureOwner_argsStandardSchemeFactory());
      schemes.put(TupleScheme.class, new setLectureOwner_argsTupleSchemeFactory());
    }

    public String userToken; // required
    public String lectureId; // required
    public String newOwnerId; // required

    /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
    public enum _Fields implements org.apache.thrift.TFieldIdEnum {
      USER_TOKEN((short)1, "userToken"),
      LECTURE_ID((short)2, "lectureId"),
      NEW_OWNER_ID((short)3, "newOwnerId");

      private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();

      static {
        for (_Fields field : EnumSet.allOf(_Fields.class)) {
          byName.put(field.getFieldName(), field);
        }
      }

      /**
       * Find the _Fields constant that matches fieldId, or null if its not found.
       */
      public static _Fields findByThriftId(int fieldId) {
        switch(fieldId) {
          case 1: // USER_TOKEN
            return USER_TOKEN;
          case 2: // LECTURE_ID
            return LECTURE_ID;
          case 3: // NEW_OWNER_ID
            return NEW_OWNER_ID;
          default:
            return null;
        }
      }

      /**
       * Find the _Fields constant that matches fieldId, throwing an exception
       * if it is not found.
       */
      public static _Fields findByThriftIdOrThrow(int fieldId) {
        _Fields fields = findByThriftId(fieldId);
        if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
        return fields;
      }

      /**
       * Find the _Fields constant that matches name, or null if its not found.
       */
      public static _Fields findByName(String name) {
        return byName.get(name);
      }

      private final short _thriftId;
      private final String _fieldName;

      _Fields(short thriftId, String fieldName) {
        _thriftId = thriftId;
        _fieldName = fieldName;
      }

      public short getThriftFieldId() {
        return _thriftId;
      }

      public String getFieldName() {
        return _fieldName;
      }
    }

    // isset id assignments
    public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
    static {
      Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
      tmpMap.put(_Fields.USER_TOKEN, new org.apache.thrift.meta_data.FieldMetaData("userToken", org.apache.thrift.TFieldRequirementType.DEFAULT, 
          new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING          , "Token")));
      tmpMap.put(_Fields.LECTURE_ID, new org.apache.thrift.meta_data.FieldMetaData("lectureId", org.apache.thrift.TFieldRequirementType.DEFAULT, 
          new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING          , "UUID")));
      tmpMap.put(_Fields.NEW_OWNER_ID, new org.apache.thrift.meta_data.FieldMetaData("newOwnerId", org.apache.thrift.TFieldRequirementType.DEFAULT, 
          new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING          , "UUID")));
      metaDataMap = Collections.unmodifiableMap(tmpMap);
      org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(setLectureOwner_args.class, metaDataMap);
    }

    public setLectureOwner_args() {
    }

    public setLectureOwner_args(
      String userToken,
      String lectureId,
      String newOwnerId)
    {
      this();
      this.userToken = userToken;
      this.lectureId = lectureId;
      this.newOwnerId = newOwnerId;
    }

    /**
     * Performs a deep copy on <i>other</i>.
     */
    public setLectureOwner_args(setLectureOwner_args other) {
      if (other.isSetUserToken()) {
        this.userToken = other.userToken;
      }
      if (other.isSetLectureId()) {
        this.lectureId = other.lectureId;
      }
      if (other.isSetNewOwnerId()) {
        this.newOwnerId = other.newOwnerId;
      }
    }

    public setLectureOwner_args deepCopy() {
      return new setLectureOwner_args(this);
    }

    @Override
    public void clear() {
      this.userToken = null;
      this.lectureId = null;
      this.newOwnerId = null;
    }

    public String getUserToken() {
      return this.userToken;
    }

    public setLectureOwner_args setUserToken(String userToken) {
      this.userToken = userToken;
      return this;
    }

    public void unsetUserToken() {
      this.userToken = null;
    }

    /** Returns true if field userToken is set (has been assigned a value) and false otherwise */
    public boolean isSetUserToken() {
      return this.userToken != null;
    }

    public void setUserTokenIsSet(boolean value) {
      if (!value) {
        this.userToken = null;
      }
    }

    public String getLectureId() {
      return this.lectureId;
    }

    public setLectureOwner_args setLectureId(String lectureId) {
      this.lectureId = lectureId;
      return this;
    }

    public void unsetLectureId() {
      this.lectureId = null;
    }

    /** Returns true if field lectureId is set (has been assigned a value) and false otherwise */
    public boolean isSetLectureId() {
      return this.lectureId != null;
    }

    public void setLectureIdIsSet(boolean value) {
      if (!value) {
        this.lectureId = null;
      }
    }

    public String getNewOwnerId() {
      return this.newOwnerId;
    }

    public setLectureOwner_args setNewOwnerId(String newOwnerId) {
      this.newOwnerId = newOwnerId;
      return this;
    }

    public void unsetNewOwnerId() {
      this.newOwnerId = null;
    }

    /** Returns true if field newOwnerId is set (has been assigned a value) and false otherwise */
    public boolean isSetNewOwnerId() {
      return this.newOwnerId != null;
    }

    public void setNewOwnerIdIsSet(boolean value) {
      if (!value) {
        this.newOwnerId = null;
      }
    }

    public void setFieldValue(_Fields field, Object value) {
      switch (field) {
      case USER_TOKEN:
        if (value == null) {
          unsetUserToken();
        } else {
          setUserToken((String)value);
        }
        break;

      case LECTURE_ID:
        if (value == null) {
          unsetLectureId();
        } else {
          setLectureId((String)value);
        }
        break;

      case NEW_OWNER_ID:
        if (value == null) {
          unsetNewOwnerId();
        } else {
          setNewOwnerId((String)value);
        }
        break;

      }
    }

    public Object getFieldValue(_Fields field) {
      switch (field) {
      case USER_TOKEN:
        return getUserToken();

      case LECTURE_ID:
        return getLectureId();

      case NEW_OWNER_ID:
        return getNewOwnerId();

      }
      throw new IllegalStateException();
    }

    /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
    public boolean isSet(_Fields field) {
      if (field == null) {
        throw new IllegalArgumentException();
      }

      switch (field) {
      case USER_TOKEN:
        return isSetUserToken();
      case LECTURE_ID:
        return isSetLectureId();
      case NEW_OWNER_ID:
        return isSetNewOwnerId();
      }
      throw new IllegalStateException();
    }

    @Override
    public boolean equals(Object that) {
      if (that == null)
        return false;
      if (that instanceof setLectureOwner_args)
        return this.equals((setLectureOwner_args)that);
      return false;
    }

    public boolean equals(setLectureOwner_args that) {
      if (that == null)
        return false;

      boolean this_present_userToken = true && this.isSetUserToken();
      boolean that_present_userToken = true && that.isSetUserToken();
      if (this_present_userToken || that_present_userToken) {
        if (!(this_present_userToken && that_present_userToken))
          return false;
        if (!this.userToken.equals(that.userToken))
          return false;
      }

      boolean this_present_lectureId = true && this.isSetLectureId();
      boolean that_present_lectureId = true && that.isSetLectureId();
      if (this_present_lectureId || that_present_lectureId) {
        if (!(this_present_lectureId && that_present_lectureId))
          return false;
        if (!this.lectureId.equals(that.lectureId))
          return false;
      }

      boolean this_present_newOwnerId = true && this.isSetNewOwnerId();
      boolean that_present_newOwnerId = true && that.isSetNewOwnerId();
      if (this_present_newOwnerId || that_present_newOwnerId) {
        if (!(this_present_newOwnerId && that_present_newOwnerId))
          return false;
        if (!this.newOwnerId.equals(that.newOwnerId))
          return false;
      }

      return true;
    }

    @Override
    public int hashCode() {
      return 0;
    }

    @Override
    public int compareTo(setLectureOwner_args other) {
      if (!getClass().equals(other.getClass())) {
        return getClass().getName().compareTo(other.getClass().getName());
      }

      int lastComparison = 0;

      lastComparison = Boolean.valueOf(isSetUserToken()).compareTo(other.isSetUserToken());
      if (lastComparison != 0) {
        return lastComparison;
      }
      if (isSetUserToken()) {
        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.userToken, other.userToken);
        if (lastComparison != 0) {
          return lastComparison;
        }
      }
      lastComparison = Boolean.valueOf(isSetLectureId()).compareTo(other.isSetLectureId());
      if (lastComparison != 0) {
        return lastComparison;
      }
      if (isSetLectureId()) {
        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.lectureId, other.lectureId);
        if (lastComparison != 0) {
          return lastComparison;
        }
      }
      lastComparison = Boolean.valueOf(isSetNewOwnerId()).compareTo(other.isSetNewOwnerId());
      if (lastComparison != 0) {
        return lastComparison;
      }
      if (isSetNewOwnerId()) {
        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.newOwnerId, other.newOwnerId);
        if (lastComparison != 0) {
          return lastComparison;
        }
      }
      return 0;
    }

    public _Fields fieldForId(int fieldId) {
      return _Fields.findByThriftId(fieldId);
    }

    public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
      schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
    }

    public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
      schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
    }

    @Override
    public String toString() {
      StringBuilder sb = new StringBuilder("setLectureOwner_args(");
      boolean first = true;

      sb.append("userToken:");
      if (this.userToken == null) {
        sb.append("null");
      } else {
        sb.append(this.userToken);
      }
      first = false;
      if (!first) sb.append(", ");
      sb.append("lectureId:");
      if (this.lectureId == null) {
        sb.append("null");
      } else {
        sb.append(this.lectureId);
      }
      first = false;
      if (!first) sb.append(", ");
      sb.append("newOwnerId:");
      if (this.newOwnerId == null) {
        sb.append("null");
      } else {
        sb.append(this.newOwnerId);
      }
      first = false;
      sb.append(")");
      return sb.toString();
    }

    public void validate() throws org.apache.thrift.TException {
      // check for required fields
      // check for sub-struct validity
    }

    private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
      try {
        write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
      } catch (org.apache.thrift.TException te) {
        throw new java.io.IOException(te);
      }
    }

    private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
      try {
        read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
      } catch (org.apache.thrift.TException te) {
        throw new java.io.IOException(te);
      }
    }

    private static class setLectureOwner_argsStandardSchemeFactory implements SchemeFactory {
      public setLectureOwner_argsStandardScheme getScheme() {
        return new setLectureOwner_argsStandardScheme();
      }
    }

    private static class setLectureOwner_argsStandardScheme extends StandardScheme<setLectureOwner_args> {

      public void read(org.apache.thrift.protocol.TProtocol iprot, setLectureOwner_args struct) throws org.apache.thrift.TException {
        org.apache.thrift.protocol.TField schemeField;
        iprot.readStructBegin();
        while (true)
        {
          schemeField = iprot.readFieldBegin();
          if (schemeField.type == org.apache.thrift.protocol.TType.STOP) { 
            break;
          }
          switch (schemeField.id) {
            case 1: // USER_TOKEN
              if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
                struct.userToken = iprot.readString();
                struct.setUserTokenIsSet(true);
              } else { 
                org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
              }
              break;
            case 2: // LECTURE_ID
              if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
                struct.lectureId = iprot.readString();
                struct.setLectureIdIsSet(true);
              } else { 
                org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
              }
              break;
            case 3: // NEW_OWNER_ID
              if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
                struct.newOwnerId = iprot.readString();
                struct.setNewOwnerIdIsSet(true);
              } else { 
                org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
              }
              break;
            default:
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
          }
          iprot.readFieldEnd();
        }
        iprot.readStructEnd();

        // check for required fields of primitive type, which can't be checked in the validate method
        struct.validate();
      }

      public void write(org.apache.thrift.protocol.TProtocol oprot, setLectureOwner_args struct) throws org.apache.thrift.TException {
        struct.validate();

        oprot.writeStructBegin(STRUCT_DESC);
        if (struct.userToken != null) {
          oprot.writeFieldBegin(USER_TOKEN_FIELD_DESC);
          oprot.writeString(struct.userToken);
          oprot.writeFieldEnd();
        }
        if (struct.lectureId != null) {
          oprot.writeFieldBegin(LECTURE_ID_FIELD_DESC);
          oprot.writeString(struct.lectureId);
          oprot.writeFieldEnd();
        }
        if (struct.newOwnerId != null) {
          oprot.writeFieldBegin(NEW_OWNER_ID_FIELD_DESC);
          oprot.writeString(struct.newOwnerId);
          oprot.writeFieldEnd();
        }
        oprot.writeFieldStop();
        oprot.writeStructEnd();
      }

    }

    private static class setLectureOwner_argsTupleSchemeFactory implements SchemeFactory {
      public setLectureOwner_argsTupleScheme getScheme() {
        return new setLectureOwner_argsTupleScheme();
      }
    }

    private static class setLectureOwner_argsTupleScheme extends TupleScheme<setLectureOwner_args> {

      @Override
      public void write(org.apache.thrift.protocol.TProtocol prot, setLectureOwner_args struct) throws org.apache.thrift.TException {
        TTupleProtocol oprot = (TTupleProtocol) prot;
        BitSet optionals = new BitSet();
        if (struct.isSetUserToken()) {
          optionals.set(0);
        }
        if (struct.isSetLectureId()) {
          optionals.set(1);
        }
        if (struct.isSetNewOwnerId()) {
          optionals.set(2);
        }
        oprot.writeBitSet(optionals, 3);
        if (struct.isSetUserToken()) {
          oprot.writeString(struct.userToken);
        }
        if (struct.isSetLectureId()) {
          oprot.writeString(struct.lectureId);
        }
        if (struct.isSetNewOwnerId()) {
          oprot.writeString(struct.newOwnerId);
        }
      }

      @Override
      public void read(org.apache.thrift.protocol.TProtocol prot, setLectureOwner_args struct) throws org.apache.thrift.TException {
        TTupleProtocol iprot = (TTupleProtocol) prot;
        BitSet incoming = iprot.readBitSet(3);
        if (incoming.get(0)) {
          struct.userToken = iprot.readString();
          struct.setUserTokenIsSet(true);
        }
        if (incoming.get(1)) {
          struct.lectureId = iprot.readString();
          struct.setLectureIdIsSet(true);
        }
        if (incoming.get(2)) {
          struct.newOwnerId = iprot.readString();
          struct.setNewOwnerIdIsSet(true);
        }
      }
    }

  }

  public static class setLectureOwner_result implements org.apache.thrift.TBase<setLectureOwner_result, setLectureOwner_result._Fields>, java.io.Serializable, Cloneable, Comparable<setLectureOwner_result>   {
    private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("setLectureOwner_result");

    private static final org.apache.thrift.protocol.TField AUTH_ERROR_FIELD_DESC = new org.apache.thrift.protocol.TField("authError", org.apache.thrift.protocol.TType.STRUCT, (short)1);
    private static final org.apache.thrift.protocol.TField NOT_FOUND_FIELD_DESC = new org.apache.thrift.protocol.TField("notFound", org.apache.thrift.protocol.TType.STRUCT, (short)2);
    private static final org.apache.thrift.protocol.TField SERVER_ERROR_FIELD_DESC = new org.apache.thrift.protocol.TField("serverError", org.apache.thrift.protocol.TType.STRUCT, (short)3);

    private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
    static {
      schemes.put(StandardScheme.class, new setLectureOwner_resultStandardSchemeFactory());
      schemes.put(TupleScheme.class, new setLectureOwner_resultTupleSchemeFactory());
    }

    public TAuthorizationException authError; // required
    public TNotFoundException notFound; // required
    public TInternalServerError serverError; // required

    /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
    public enum _Fields implements org.apache.thrift.TFieldIdEnum {
      AUTH_ERROR((short)1, "authError"),
      NOT_FOUND((short)2, "notFound"),
      SERVER_ERROR((short)3, "serverError");

      private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();

      static {
        for (_Fields field : EnumSet.allOf(_Fields.class)) {
          byName.put(field.getFieldName(), field);
        }
      }

      /**
       * Find the _Fields constant that matches fieldId, or null if its not found.
       */
      public static _Fields findByThriftId(int fieldId) {
        switch(fieldId) {
          case 1: // AUTH_ERROR
            return AUTH_ERROR;
          case 2: // NOT_FOUND
            return NOT_FOUND;
          case 3: // SERVER_ERROR
            return SERVER_ERROR;
          default:
            return null;
        }
      }

      /**
       * Find the _Fields constant that matches fieldId, throwing an exception
       * if it is not found.
       */
      public static _Fields findByThriftIdOrThrow(int fieldId) {
        _Fields fields = findByThriftId(fieldId);
        if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
        return fields;
      }

      /**
       * Find the _Fields constant that matches name, or null if its not found.
       */
      public static _Fields findByName(String name) {
        return byName.get(name);
      }

      private final short _thriftId;
      private final String _fieldName;

      _Fields(short thriftId, String fieldName) {
        _thriftId = thriftId;
        _fieldName = fieldName;
      }

      public short getThriftFieldId() {
        return _thriftId;
      }

      public String getFieldName() {
        return _fieldName;
      }
    }

    // isset id assignments
    public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
    static {
      Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
      tmpMap.put(_Fields.AUTH_ERROR, new org.apache.thrift.meta_data.FieldMetaData("authError", org.apache.thrift.TFieldRequirementType.DEFAULT, 
          new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT)));
      tmpMap.put(_Fields.NOT_FOUND, new org.apache.thrift.meta_data.FieldMetaData("notFound", org.apache.thrift.TFieldRequirementType.DEFAULT, 
          new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT)));
      tmpMap.put(_Fields.SERVER_ERROR, new org.apache.thrift.meta_data.FieldMetaData("serverError", org.apache.thrift.TFieldRequirementType.DEFAULT, 
          new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT)));
      metaDataMap = Collections.unmodifiableMap(tmpMap);
      org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(setLectureOwner_result.class, metaDataMap);
    }

    public setLectureOwner_result() {
    }

    public setLectureOwner_result(
      TAuthorizationException authError,
      TNotFoundException notFound,
      TInternalServerError serverError)
    {
      this();
      this.authError = authError;
      this.notFound = notFound;
      this.serverError = serverError;
    }

    /**
     * Performs a deep copy on <i>other</i>.
     */
    public setLectureOwner_result(setLectureOwner_result other) {
      if (other.isSetAuthError()) {
        this.authError = new TAuthorizationException(other.authError);
      }
      if (other.isSetNotFound()) {
        this.notFound = new TNotFoundException(other.notFound);
      }
      if (other.isSetServerError()) {
        this.serverError = new TInternalServerError(other.serverError);
      }
    }

    public setLectureOwner_result deepCopy() {
      return new setLectureOwner_result(this);
    }

    @Override
    public void clear() {
      this.authError = null;
      this.notFound = null;
      this.serverError = null;
    }

    public TAuthorizationException getAuthError() {
      return this.authError;
    }

    public setLectureOwner_result setAuthError(TAuthorizationException authError) {
      this.authError = authError;
      return this;
    }

    public void unsetAuthError() {
      this.authError = null;
    }

    /** Returns true if field authError is set (has been assigned a value) and false otherwise */
    public boolean isSetAuthError() {
      return this.authError != null;
    }

    public void setAuthErrorIsSet(boolean value) {
      if (!value) {
        this.authError = null;
      }
    }

    public TNotFoundException getNotFound() {
      return this.notFound;
    }

    public setLectureOwner_result setNotFound(TNotFoundException notFound) {
      this.notFound = notFound;
      return this;
    }

    public void unsetNotFound() {
      this.notFound = null;
    }

    /** Returns true if field notFound is set (has been assigned a value) and false otherwise */
    public boolean isSetNotFound() {
      return this.notFound != null;
    }

    public void setNotFoundIsSet(boolean value) {
      if (!value) {
        this.notFound = null;
      }
    }

    public TInternalServerError getServerError() {
      return this.serverError;
    }

    public setLectureOwner_result setServerError(TInternalServerError serverError) {
      this.serverError = serverError;
      return this;
    }

    public void unsetServerError() {
      this.serverError = null;
    }

    /** Returns true if field serverError is set (has been assigned a value) and false otherwise */
    public boolean isSetServerError() {
      return this.serverError != null;
    }

    public void setServerErrorIsSet(boolean value) {
      if (!value) {
        this.serverError = null;
      }
    }

    public void setFieldValue(_Fields field, Object value) {
      switch (field) {
      case AUTH_ERROR:
        if (value == null) {
          unsetAuthError();
        } else {
          setAuthError((TAuthorizationException)value);
        }
        break;

      case NOT_FOUND:
        if (value == null) {
          unsetNotFound();
        } else {
          setNotFound((TNotFoundException)value);
        }
        break;

      case SERVER_ERROR:
        if (value == null) {
          unsetServerError();
        } else {
          setServerError((TInternalServerError)value);
        }
        break;

      }
    }

    public Object getFieldValue(_Fields field) {
      switch (field) {
      case AUTH_ERROR:
        return getAuthError();

      case NOT_FOUND:
        return getNotFound();

      case SERVER_ERROR:
        return getServerError();

      }
      throw new IllegalStateException();
    }

    /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
    public boolean isSet(_Fields field) {
      if (field == null) {
        throw new IllegalArgumentException();
      }

      switch (field) {
      case AUTH_ERROR:
        return isSetAuthError();
      case NOT_FOUND:
        return isSetNotFound();
      case SERVER_ERROR:
        return isSetServerError();
      }
      throw new IllegalStateException();
    }

    @Override
    public boolean equals(Object that) {
      if (that == null)
        return false;
      if (that instanceof setLectureOwner_result)
        return this.equals((setLectureOwner_result)that);
      return false;
    }

    public boolean equals(setLectureOwner_result that) {
      if (that == null)
        return false;

      boolean this_present_authError = true && this.isSetAuthError();
      boolean that_present_authError = true && that.isSetAuthError();
      if (this_present_authError || that_present_authError) {
        if (!(this_present_authError && that_present_authError))
          return false;
        if (!this.authError.equals(that.authError))
          return false;
      }

      boolean this_present_notFound = true && this.isSetNotFound();
      boolean that_present_notFound = true && that.isSetNotFound();
      if (this_present_notFound || that_present_notFound) {
        if (!(this_present_notFound && that_present_notFound))
          return false;
        if (!this.notFound.equals(that.notFound))
          return false;
      }

      boolean this_present_serverError = true && this.isSetServerError();
      boolean that_present_serverError = true && that.isSetServerError();
      if (this_present_serverError || that_present_serverError) {
        if (!(this_present_serverError && that_present_serverError))
          return false;
        if (!this.serverError.equals(that.serverError))
          return false;
      }

      return true;
    }

    @Override
    public int hashCode() {
      return 0;
    }

    @Override
    public int compareTo(setLectureOwner_result other) {
      if (!getClass().equals(other.getClass())) {
        return getClass().getName().compareTo(other.getClass().getName());
      }

      int lastComparison = 0;

      lastComparison = Boolean.valueOf(isSetAuthError()).compareTo(other.isSetAuthError());
      if (lastComparison != 0) {
        return lastComparison;
      }
      if (isSetAuthError()) {
        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.authError, other.authError);
        if (lastComparison != 0) {
          return lastComparison;
        }
      }
      lastComparison = Boolean.valueOf(isSetNotFound()).compareTo(other.isSetNotFound());
      if (lastComparison != 0) {
        return lastComparison;
      }
      if (isSetNotFound()) {
        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.notFound, other.notFound);
        if (lastComparison != 0) {
          return lastComparison;
        }
      }
      lastComparison = Boolean.valueOf(isSetServerError()).compareTo(other.isSetServerError());
      if (lastComparison != 0) {
        return lastComparison;
      }
      if (isSetServerError()) {
        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.serverError, other.serverError);
        if (lastComparison != 0) {
          return lastComparison;
        }
      }
      return 0;
    }

    public _Fields fieldForId(int fieldId) {
      return _Fields.findByThriftId(fieldId);
    }

    public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
      schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
    }

    public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
      schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
      }

    @Override
    public String toString() {
      StringBuilder sb = new StringBuilder("setLectureOwner_result(");
      boolean first = true;

      sb.append("authError:");
      if (this.authError == null) {
        sb.append("null");
      } else {
        sb.append(this.authError);
      }
      first = false;
      if (!first) sb.append(", ");
      sb.append("notFound:");
      if (this.notFound == null) {
        sb.append("null");
      } else {
        sb.append(this.notFound);
      }
      first = false;
      if (!first) sb.append(", ");
      sb.append("serverError:");
      if (this.serverError == null) {
        sb.append("null");
      } else {
        sb.append(this.serverError);
      }
      first = false;
      sb.append(")");
      return sb.toString();
    }

    public void validate() throws org.apache.thrift.TException {
      // check for required fields
      // check for sub-struct validity
    }

    private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
      try {
        write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
      } catch (org.apache.thrift.TException te) {
        throw new java.io.IOException(te);
      }
    }

    private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
      try {
        read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
      } catch (org.apache.thrift.TException te) {
        throw new java.io.IOException(te);
      }
    }

    private static class setLectureOwner_resultStandardSchemeFactory implements SchemeFactory {
      public setLectureOwner_resultStandardScheme getScheme() {
        return new setLectureOwner_resultStandardScheme();
      }
    }

    private static class setLectureOwner_resultStandardScheme extends StandardScheme<setLectureOwner_result> {

      public void read(org.apache.thrift.protocol.TProtocol iprot, setLectureOwner_result struct) throws org.apache.thrift.TException {
        org.apache.thrift.protocol.TField schemeField;
        iprot.readStructBegin();
        while (true)
        {
          schemeField = iprot.readFieldBegin();
          if (schemeField.type == org.apache.thrift.protocol.TType.STOP) { 
            break;
          }
          switch (schemeField.id) {
            case 1: // AUTH_ERROR
              if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
                struct.authError = new TAuthorizationException();
                struct.authError.read(iprot);
                struct.setAuthErrorIsSet(true);
              } else { 
                org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
              }
              break;
            case 2: // NOT_FOUND
              if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
                struct.notFound = new TNotFoundException();
                struct.notFound.read(iprot);
                struct.setNotFoundIsSet(true);
              } else { 
                org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
              }
              break;
            case 3: // SERVER_ERROR
              if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
                struct.serverError = new TInternalServerError();
                struct.serverError.read(iprot);
                struct.setServerErrorIsSet(true);
              } else { 
                org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
              }
              break;
            default:
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
          }
          iprot.readFieldEnd();
        }
        iprot.readStructEnd();

        // check for required fields of primitive type, which can't be checked in the validate method
        struct.validate();
      }

      public void write(org.apache.thrift.protocol.TProtocol oprot, setLectureOwner_result struct) throws org.apache.thrift.TException {
        struct.validate();

        oprot.writeStructBegin(STRUCT_DESC);
        if (struct.authError != null) {
          oprot.writeFieldBegin(AUTH_ERROR_FIELD_DESC);
          struct.authError.write(oprot);
          oprot.writeFieldEnd();
        }
        if (struct.notFound != null) {
          oprot.writeFieldBegin(NOT_FOUND_FIELD_DESC);
          struct.notFound.write(oprot);
          oprot.writeFieldEnd();
        }
        if (struct.serverError != null) {
          oprot.writeFieldBegin(SERVER_ERROR_FIELD_DESC);
          struct.serverError.write(oprot);
          oprot.writeFieldEnd();
        }
        oprot.writeFieldStop();
        oprot.writeStructEnd();
      }

    }

    private static class setLectureOwner_resultTupleSchemeFactory implements SchemeFactory {
      public setLectureOwner_resultTupleScheme getScheme() {
        return new setLectureOwner_resultTupleScheme();
      }
    }

    private static class setLectureOwner_resultTupleScheme extends TupleScheme<setLectureOwner_result> {

      @Override
      public void write(org.apache.thrift.protocol.TProtocol prot, setLectureOwner_result struct) throws org.apache.thrift.TException {
        TTupleProtocol oprot = (TTupleProtocol) prot;
        BitSet optionals = new BitSet();
        if (struct.isSetAuthError()) {
          optionals.set(0);
        }
        if (struct.isSetNotFound()) {
          optionals.set(1);
        }
        if (struct.isSetServerError()) {
          optionals.set(2);
        }
        oprot.writeBitSet(optionals, 3);
        if (struct.isSetAuthError()) {
          struct.authError.write(oprot);
        }
        if (struct.isSetNotFound()) {
          struct.notFound.write(oprot);
        }
        if (struct.isSetServerError()) {
          struct.serverError.write(oprot);
        }
      }

      @Override
      public void read(org.apache.thrift.protocol.TProtocol prot, setLectureOwner_result struct) throws org.apache.thrift.TException {
        TTupleProtocol iprot = (TTupleProtocol) prot;
        BitSet incoming = iprot.readBitSet(3);
        if (incoming.get(0)) {
          struct.authError = new TAuthorizationException();
          struct.authError.read(iprot);
          struct.setAuthErrorIsSet(true);
        }
        if (incoming.get(1)) {
          struct.notFound = new TNotFoundException();
          struct.notFound.read(iprot);
          struct.setNotFoundIsSet(true);
        }
        if (incoming.get(2)) {
          struct.serverError = new TInternalServerError();
          struct.serverError.read(iprot);
          struct.setServerErrorIsSet(true);
        }
      }
    }

  }

}