subor_rs/
overlay_manager_s_d_k_services.rs

1// Autogenerated by Thrift Compiler (0.12.0)
2// DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
3
4#![allow(unused_imports)]
5#![allow(unused_extern_crates)]
6#![cfg_attr(feature = "cargo-clippy", allow(too_many_arguments, type_complexity))]
7#![cfg_attr(rustfmt, rustfmt_skip)]
8
9extern crate ordered_float;
10extern crate thrift;
11extern crate try_from;
12
13use ordered_float::OrderedFloat;
14use std::cell::RefCell;
15use std::collections::{BTreeMap, BTreeSet};
16use std::convert::From;
17use std::default::Default;
18use std::error::Error;
19use std::fmt;
20use std::fmt::{Display, Formatter};
21use std::rc::Rc;
22use try_from::TryFrom;
23
24use thrift::{ApplicationError, ApplicationErrorKind, ProtocolError, ProtocolErrorKind, TThriftClient};
25use thrift::protocol::{TFieldIdentifier, TListIdentifier, TMapIdentifier, TMessageIdentifier, TMessageType, TInputProtocol, TOutputProtocol, TSetIdentifier, TStructIdentifier, TType};
26use thrift::protocol::field_id;
27use thrift::protocol::verify_expected_message_type;
28use thrift::protocol::verify_expected_sequence_number;
29use thrift::protocol::verify_expected_service_call;
30use thrift::protocol::verify_required_field_exists;
31use thrift::server::TProcessor;
32
33use overlay_manager_s_d_k_data_types;
34
35//
36// OverlayExternalService service client
37//
38
39pub trait TOverlayExternalServiceSyncClient {
40  fn show_in_game_overlay(&mut self, arguments: overlay_manager_s_d_k_data_types::OverlayState) -> thrift::Result<()>;
41  fn take_screen_shot(&mut self) -> thrift::Result<bool>;
42  fn video_capture(&mut self, arguments: overlay_manager_s_d_k_data_types::VideoCaptureState) -> thrift::Result<()>;
43}
44
45pub trait TOverlayExternalServiceSyncClientMarker {}
46
47pub struct OverlayExternalServiceSyncClient<IP, OP> where IP: TInputProtocol, OP: TOutputProtocol {
48  _i_prot: IP,
49  _o_prot: OP,
50  _sequence_number: i32,
51}
52
53impl <IP, OP> OverlayExternalServiceSyncClient<IP, OP> where IP: TInputProtocol, OP: TOutputProtocol {
54  pub fn new(input_protocol: IP, output_protocol: OP) -> OverlayExternalServiceSyncClient<IP, OP> {
55    OverlayExternalServiceSyncClient { _i_prot: input_protocol, _o_prot: output_protocol, _sequence_number: 0 }
56  }
57}
58
59impl <IP, OP> TThriftClient for OverlayExternalServiceSyncClient<IP, OP> where IP: TInputProtocol, OP: TOutputProtocol {
60  fn i_prot_mut(&mut self) -> &mut TInputProtocol { &mut self._i_prot }
61  fn o_prot_mut(&mut self) -> &mut TOutputProtocol { &mut self._o_prot }
62  fn sequence_number(&self) -> i32 { self._sequence_number }
63  fn increment_sequence_number(&mut self) -> i32 { self._sequence_number += 1; self._sequence_number }
64}
65
66impl <IP, OP> TOverlayExternalServiceSyncClientMarker for OverlayExternalServiceSyncClient<IP, OP> where IP: TInputProtocol, OP: TOutputProtocol {}
67
68impl <C: TThriftClient + TOverlayExternalServiceSyncClientMarker> TOverlayExternalServiceSyncClient for C {
69  fn show_in_game_overlay(&mut self, arguments: overlay_manager_s_d_k_data_types::OverlayState) -> thrift::Result<()> {
70    (
71      {
72        self.increment_sequence_number();
73        let message_ident = TMessageIdentifier::new("ShowInGameOverlay", TMessageType::Call, self.sequence_number());
74        let call_args = OverlayExternalServiceShowInGameOverlayArgs { arguments: arguments };
75        self.o_prot_mut().write_message_begin(&message_ident)?;
76        call_args.write_to_out_protocol(self.o_prot_mut())?;
77        self.o_prot_mut().write_message_end()?;
78        self.o_prot_mut().flush()
79      }
80    )?;
81    {
82      let message_ident = self.i_prot_mut().read_message_begin()?;
83      verify_expected_sequence_number(self.sequence_number(), message_ident.sequence_number)?;
84      verify_expected_service_call("ShowInGameOverlay", &message_ident.name)?;
85      if message_ident.message_type == TMessageType::Exception {
86        let remote_error = thrift::Error::read_application_error_from_in_protocol(self.i_prot_mut())?;
87        self.i_prot_mut().read_message_end()?;
88        return Err(thrift::Error::Application(remote_error))
89      }
90      verify_expected_message_type(TMessageType::Reply, message_ident.message_type)?;
91      let result = OverlayExternalServiceShowInGameOverlayResult::read_from_in_protocol(self.i_prot_mut())?;
92      self.i_prot_mut().read_message_end()?;
93      result.ok_or()
94    }
95  }
96  fn take_screen_shot(&mut self) -> thrift::Result<bool> {
97    (
98      {
99        self.increment_sequence_number();
100        let message_ident = TMessageIdentifier::new("TakeScreenShot", TMessageType::Call, self.sequence_number());
101        let call_args = OverlayExternalServiceTakeScreenShotArgs {  };
102        self.o_prot_mut().write_message_begin(&message_ident)?;
103        call_args.write_to_out_protocol(self.o_prot_mut())?;
104        self.o_prot_mut().write_message_end()?;
105        self.o_prot_mut().flush()
106      }
107    )?;
108    {
109      let message_ident = self.i_prot_mut().read_message_begin()?;
110      verify_expected_sequence_number(self.sequence_number(), message_ident.sequence_number)?;
111      verify_expected_service_call("TakeScreenShot", &message_ident.name)?;
112      if message_ident.message_type == TMessageType::Exception {
113        let remote_error = thrift::Error::read_application_error_from_in_protocol(self.i_prot_mut())?;
114        self.i_prot_mut().read_message_end()?;
115        return Err(thrift::Error::Application(remote_error))
116      }
117      verify_expected_message_type(TMessageType::Reply, message_ident.message_type)?;
118      let result = OverlayExternalServiceTakeScreenShotResult::read_from_in_protocol(self.i_prot_mut())?;
119      self.i_prot_mut().read_message_end()?;
120      result.ok_or()
121    }
122  }
123  fn video_capture(&mut self, arguments: overlay_manager_s_d_k_data_types::VideoCaptureState) -> thrift::Result<()> {
124    (
125      {
126        self.increment_sequence_number();
127        let message_ident = TMessageIdentifier::new("VideoCapture", TMessageType::Call, self.sequence_number());
128        let call_args = OverlayExternalServiceVideoCaptureArgs { arguments: arguments };
129        self.o_prot_mut().write_message_begin(&message_ident)?;
130        call_args.write_to_out_protocol(self.o_prot_mut())?;
131        self.o_prot_mut().write_message_end()?;
132        self.o_prot_mut().flush()
133      }
134    )?;
135    {
136      let message_ident = self.i_prot_mut().read_message_begin()?;
137      verify_expected_sequence_number(self.sequence_number(), message_ident.sequence_number)?;
138      verify_expected_service_call("VideoCapture", &message_ident.name)?;
139      if message_ident.message_type == TMessageType::Exception {
140        let remote_error = thrift::Error::read_application_error_from_in_protocol(self.i_prot_mut())?;
141        self.i_prot_mut().read_message_end()?;
142        return Err(thrift::Error::Application(remote_error))
143      }
144      verify_expected_message_type(TMessageType::Reply, message_ident.message_type)?;
145      let result = OverlayExternalServiceVideoCaptureResult::read_from_in_protocol(self.i_prot_mut())?;
146      self.i_prot_mut().read_message_end()?;
147      result.ok_or()
148    }
149  }
150}
151
152//
153// OverlayExternalService service processor
154//
155
156pub trait OverlayExternalServiceSyncHandler {
157  fn handle_show_in_game_overlay(&self, arguments: overlay_manager_s_d_k_data_types::OverlayState) -> thrift::Result<()>;
158  fn handle_take_screen_shot(&self) -> thrift::Result<bool>;
159  fn handle_video_capture(&self, arguments: overlay_manager_s_d_k_data_types::VideoCaptureState) -> thrift::Result<()>;
160}
161
162pub struct OverlayExternalServiceSyncProcessor<H: OverlayExternalServiceSyncHandler> {
163  handler: H,
164}
165
166impl <H: OverlayExternalServiceSyncHandler> OverlayExternalServiceSyncProcessor<H> {
167  pub fn new(handler: H) -> OverlayExternalServiceSyncProcessor<H> {
168    OverlayExternalServiceSyncProcessor {
169      handler,
170    }
171  }
172  fn process_show_in_game_overlay(&self, incoming_sequence_number: i32, i_prot: &mut TInputProtocol, o_prot: &mut TOutputProtocol) -> thrift::Result<()> {
173    TOverlayExternalServiceProcessFunctions::process_show_in_game_overlay(&self.handler, incoming_sequence_number, i_prot, o_prot)
174  }
175  fn process_take_screen_shot(&self, incoming_sequence_number: i32, i_prot: &mut TInputProtocol, o_prot: &mut TOutputProtocol) -> thrift::Result<()> {
176    TOverlayExternalServiceProcessFunctions::process_take_screen_shot(&self.handler, incoming_sequence_number, i_prot, o_prot)
177  }
178  fn process_video_capture(&self, incoming_sequence_number: i32, i_prot: &mut TInputProtocol, o_prot: &mut TOutputProtocol) -> thrift::Result<()> {
179    TOverlayExternalServiceProcessFunctions::process_video_capture(&self.handler, incoming_sequence_number, i_prot, o_prot)
180  }
181}
182
183pub struct TOverlayExternalServiceProcessFunctions;
184
185impl TOverlayExternalServiceProcessFunctions {
186  pub fn process_show_in_game_overlay<H: OverlayExternalServiceSyncHandler>(handler: &H, incoming_sequence_number: i32, i_prot: &mut TInputProtocol, o_prot: &mut TOutputProtocol) -> thrift::Result<()> {
187    let args = OverlayExternalServiceShowInGameOverlayArgs::read_from_in_protocol(i_prot)?;
188    match handler.handle_show_in_game_overlay(args.arguments) {
189      Ok(_) => {
190        let message_ident = TMessageIdentifier::new("ShowInGameOverlay", TMessageType::Reply, incoming_sequence_number);
191        o_prot.write_message_begin(&message_ident)?;
192        let ret = OverlayExternalServiceShowInGameOverlayResult {  };
193        ret.write_to_out_protocol(o_prot)?;
194        o_prot.write_message_end()?;
195        o_prot.flush()
196      },
197      Err(e) => {
198        match e {
199          thrift::Error::Application(app_err) => {
200            let message_ident = TMessageIdentifier::new("ShowInGameOverlay", TMessageType::Exception, incoming_sequence_number);
201            o_prot.write_message_begin(&message_ident)?;
202            thrift::Error::write_application_error_to_out_protocol(&app_err, o_prot)?;
203            o_prot.write_message_end()?;
204            o_prot.flush()
205          },
206          _ => {
207            let ret_err = {
208              ApplicationError::new(
209                ApplicationErrorKind::Unknown,
210                e.description()
211              )
212            };
213            let message_ident = TMessageIdentifier::new("ShowInGameOverlay", TMessageType::Exception, incoming_sequence_number);
214            o_prot.write_message_begin(&message_ident)?;
215            thrift::Error::write_application_error_to_out_protocol(&ret_err, o_prot)?;
216            o_prot.write_message_end()?;
217            o_prot.flush()
218          },
219        }
220      },
221    }
222  }
223  pub fn process_take_screen_shot<H: OverlayExternalServiceSyncHandler>(handler: &H, incoming_sequence_number: i32, i_prot: &mut TInputProtocol, o_prot: &mut TOutputProtocol) -> thrift::Result<()> {
224    let _ = OverlayExternalServiceTakeScreenShotArgs::read_from_in_protocol(i_prot)?;
225    match handler.handle_take_screen_shot() {
226      Ok(handler_return) => {
227        let message_ident = TMessageIdentifier::new("TakeScreenShot", TMessageType::Reply, incoming_sequence_number);
228        o_prot.write_message_begin(&message_ident)?;
229        let ret = OverlayExternalServiceTakeScreenShotResult { result_value: Some(handler_return) };
230        ret.write_to_out_protocol(o_prot)?;
231        o_prot.write_message_end()?;
232        o_prot.flush()
233      },
234      Err(e) => {
235        match e {
236          thrift::Error::Application(app_err) => {
237            let message_ident = TMessageIdentifier::new("TakeScreenShot", TMessageType::Exception, incoming_sequence_number);
238            o_prot.write_message_begin(&message_ident)?;
239            thrift::Error::write_application_error_to_out_protocol(&app_err, o_prot)?;
240            o_prot.write_message_end()?;
241            o_prot.flush()
242          },
243          _ => {
244            let ret_err = {
245              ApplicationError::new(
246                ApplicationErrorKind::Unknown,
247                e.description()
248              )
249            };
250            let message_ident = TMessageIdentifier::new("TakeScreenShot", TMessageType::Exception, incoming_sequence_number);
251            o_prot.write_message_begin(&message_ident)?;
252            thrift::Error::write_application_error_to_out_protocol(&ret_err, o_prot)?;
253            o_prot.write_message_end()?;
254            o_prot.flush()
255          },
256        }
257      },
258    }
259  }
260  pub fn process_video_capture<H: OverlayExternalServiceSyncHandler>(handler: &H, incoming_sequence_number: i32, i_prot: &mut TInputProtocol, o_prot: &mut TOutputProtocol) -> thrift::Result<()> {
261    let args = OverlayExternalServiceVideoCaptureArgs::read_from_in_protocol(i_prot)?;
262    match handler.handle_video_capture(args.arguments) {
263      Ok(_) => {
264        let message_ident = TMessageIdentifier::new("VideoCapture", TMessageType::Reply, incoming_sequence_number);
265        o_prot.write_message_begin(&message_ident)?;
266        let ret = OverlayExternalServiceVideoCaptureResult {  };
267        ret.write_to_out_protocol(o_prot)?;
268        o_prot.write_message_end()?;
269        o_prot.flush()
270      },
271      Err(e) => {
272        match e {
273          thrift::Error::Application(app_err) => {
274            let message_ident = TMessageIdentifier::new("VideoCapture", TMessageType::Exception, incoming_sequence_number);
275            o_prot.write_message_begin(&message_ident)?;
276            thrift::Error::write_application_error_to_out_protocol(&app_err, o_prot)?;
277            o_prot.write_message_end()?;
278            o_prot.flush()
279          },
280          _ => {
281            let ret_err = {
282              ApplicationError::new(
283                ApplicationErrorKind::Unknown,
284                e.description()
285              )
286            };
287            let message_ident = TMessageIdentifier::new("VideoCapture", TMessageType::Exception, incoming_sequence_number);
288            o_prot.write_message_begin(&message_ident)?;
289            thrift::Error::write_application_error_to_out_protocol(&ret_err, o_prot)?;
290            o_prot.write_message_end()?;
291            o_prot.flush()
292          },
293        }
294      },
295    }
296  }
297}
298
299impl <H: OverlayExternalServiceSyncHandler> TProcessor for OverlayExternalServiceSyncProcessor<H> {
300  fn process(&self, i_prot: &mut TInputProtocol, o_prot: &mut TOutputProtocol) -> thrift::Result<()> {
301    let message_ident = i_prot.read_message_begin()?;
302    let res = match &*message_ident.name {
303      "ShowInGameOverlay" => {
304        self.process_show_in_game_overlay(message_ident.sequence_number, i_prot, o_prot)
305      },
306      "TakeScreenShot" => {
307        self.process_take_screen_shot(message_ident.sequence_number, i_prot, o_prot)
308      },
309      "VideoCapture" => {
310        self.process_video_capture(message_ident.sequence_number, i_prot, o_prot)
311      },
312      method => {
313        Err(
314          thrift::Error::Application(
315            ApplicationError::new(
316              ApplicationErrorKind::UnknownMethod,
317              format!("unknown method {}", method)
318            )
319          )
320        )
321      },
322    };
323    thrift::server::handle_process_result(&message_ident, res, o_prot)
324  }
325}
326
327//
328// OverlayExternalServiceShowInGameOverlayArgs
329//
330
331#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
332struct OverlayExternalServiceShowInGameOverlayArgs {
333  arguments: overlay_manager_s_d_k_data_types::OverlayState,
334}
335
336impl OverlayExternalServiceShowInGameOverlayArgs {
337  fn read_from_in_protocol(i_prot: &mut TInputProtocol) -> thrift::Result<OverlayExternalServiceShowInGameOverlayArgs> {
338    i_prot.read_struct_begin()?;
339    let mut f_1: Option<overlay_manager_s_d_k_data_types::OverlayState> = None;
340    loop {
341      let field_ident = i_prot.read_field_begin()?;
342      if field_ident.field_type == TType::Stop {
343        break;
344      }
345      let field_id = field_id(&field_ident)?;
346      match field_id {
347        1 => {
348          let val = overlay_manager_s_d_k_data_types::OverlayState::read_from_in_protocol(i_prot)?;
349          f_1 = Some(val);
350        },
351        _ => {
352          i_prot.skip(field_ident.field_type)?;
353        },
354      };
355      i_prot.read_field_end()?;
356    }
357    i_prot.read_struct_end()?;
358    verify_required_field_exists("OverlayExternalServiceShowInGameOverlayArgs.arguments", &f_1)?;
359    let ret = OverlayExternalServiceShowInGameOverlayArgs {
360      arguments: f_1.expect("auto-generated code should have checked for presence of required fields"),
361    };
362    Ok(ret)
363  }
364  fn write_to_out_protocol(&self, o_prot: &mut TOutputProtocol) -> thrift::Result<()> {
365    let struct_ident = TStructIdentifier::new("ShowInGameOverlay_args");
366    o_prot.write_struct_begin(&struct_ident)?;
367    o_prot.write_field_begin(&TFieldIdentifier::new("arguments", TType::Struct, 1))?;
368    self.arguments.write_to_out_protocol(o_prot)?;
369    o_prot.write_field_end()?;
370    o_prot.write_field_stop()?;
371    o_prot.write_struct_end()
372  }
373}
374
375//
376// OverlayExternalServiceShowInGameOverlayResult
377//
378
379#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
380struct OverlayExternalServiceShowInGameOverlayResult {
381}
382
383impl OverlayExternalServiceShowInGameOverlayResult {
384  fn read_from_in_protocol(i_prot: &mut TInputProtocol) -> thrift::Result<OverlayExternalServiceShowInGameOverlayResult> {
385    i_prot.read_struct_begin()?;
386    loop {
387      let field_ident = i_prot.read_field_begin()?;
388      if field_ident.field_type == TType::Stop {
389        break;
390      }
391      let field_id = field_id(&field_ident)?;
392      match field_id {
393        _ => {
394          i_prot.skip(field_ident.field_type)?;
395        },
396      };
397      i_prot.read_field_end()?;
398    }
399    i_prot.read_struct_end()?;
400    let ret = OverlayExternalServiceShowInGameOverlayResult {};
401    Ok(ret)
402  }
403  fn write_to_out_protocol(&self, o_prot: &mut TOutputProtocol) -> thrift::Result<()> {
404    let struct_ident = TStructIdentifier::new("OverlayExternalServiceShowInGameOverlayResult");
405    o_prot.write_struct_begin(&struct_ident)?;
406    o_prot.write_field_stop()?;
407    o_prot.write_struct_end()
408  }
409  fn ok_or(self) -> thrift::Result<()> {
410    Ok(())
411  }
412}
413
414//
415// OverlayExternalServiceTakeScreenShotArgs
416//
417
418#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
419struct OverlayExternalServiceTakeScreenShotArgs {
420}
421
422impl OverlayExternalServiceTakeScreenShotArgs {
423  fn read_from_in_protocol(i_prot: &mut TInputProtocol) -> thrift::Result<OverlayExternalServiceTakeScreenShotArgs> {
424    i_prot.read_struct_begin()?;
425    loop {
426      let field_ident = i_prot.read_field_begin()?;
427      if field_ident.field_type == TType::Stop {
428        break;
429      }
430      let field_id = field_id(&field_ident)?;
431      match field_id {
432        _ => {
433          i_prot.skip(field_ident.field_type)?;
434        },
435      };
436      i_prot.read_field_end()?;
437    }
438    i_prot.read_struct_end()?;
439    let ret = OverlayExternalServiceTakeScreenShotArgs {};
440    Ok(ret)
441  }
442  fn write_to_out_protocol(&self, o_prot: &mut TOutputProtocol) -> thrift::Result<()> {
443    let struct_ident = TStructIdentifier::new("TakeScreenShot_args");
444    o_prot.write_struct_begin(&struct_ident)?;
445    o_prot.write_field_stop()?;
446    o_prot.write_struct_end()
447  }
448}
449
450//
451// OverlayExternalServiceTakeScreenShotResult
452//
453
454#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
455struct OverlayExternalServiceTakeScreenShotResult {
456  result_value: Option<bool>,
457}
458
459impl OverlayExternalServiceTakeScreenShotResult {
460  fn read_from_in_protocol(i_prot: &mut TInputProtocol) -> thrift::Result<OverlayExternalServiceTakeScreenShotResult> {
461    i_prot.read_struct_begin()?;
462    let mut f_0: Option<bool> = None;
463    loop {
464      let field_ident = i_prot.read_field_begin()?;
465      if field_ident.field_type == TType::Stop {
466        break;
467      }
468      let field_id = field_id(&field_ident)?;
469      match field_id {
470        0 => {
471          let val = i_prot.read_bool()?;
472          f_0 = Some(val);
473        },
474        _ => {
475          i_prot.skip(field_ident.field_type)?;
476        },
477      };
478      i_prot.read_field_end()?;
479    }
480    i_prot.read_struct_end()?;
481    let ret = OverlayExternalServiceTakeScreenShotResult {
482      result_value: f_0,
483    };
484    Ok(ret)
485  }
486  fn write_to_out_protocol(&self, o_prot: &mut TOutputProtocol) -> thrift::Result<()> {
487    let struct_ident = TStructIdentifier::new("OverlayExternalServiceTakeScreenShotResult");
488    o_prot.write_struct_begin(&struct_ident)?;
489    if let Some(fld_var) = self.result_value {
490      o_prot.write_field_begin(&TFieldIdentifier::new("result_value", TType::Bool, 0))?;
491      o_prot.write_bool(fld_var)?;
492      o_prot.write_field_end()?;
493      ()
494    } else {
495      ()
496    }
497    o_prot.write_field_stop()?;
498    o_prot.write_struct_end()
499  }
500  fn ok_or(self) -> thrift::Result<bool> {
501    if self.result_value.is_some() {
502      Ok(self.result_value.unwrap())
503    } else {
504      Err(
505        thrift::Error::Application(
506          ApplicationError::new(
507            ApplicationErrorKind::MissingResult,
508            "no result received for OverlayExternalServiceTakeScreenShot"
509          )
510        )
511      )
512    }
513  }
514}
515
516//
517// OverlayExternalServiceVideoCaptureArgs
518//
519
520#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
521struct OverlayExternalServiceVideoCaptureArgs {
522  arguments: overlay_manager_s_d_k_data_types::VideoCaptureState,
523}
524
525impl OverlayExternalServiceVideoCaptureArgs {
526  fn read_from_in_protocol(i_prot: &mut TInputProtocol) -> thrift::Result<OverlayExternalServiceVideoCaptureArgs> {
527    i_prot.read_struct_begin()?;
528    let mut f_1: Option<overlay_manager_s_d_k_data_types::VideoCaptureState> = None;
529    loop {
530      let field_ident = i_prot.read_field_begin()?;
531      if field_ident.field_type == TType::Stop {
532        break;
533      }
534      let field_id = field_id(&field_ident)?;
535      match field_id {
536        1 => {
537          let val = overlay_manager_s_d_k_data_types::VideoCaptureState::read_from_in_protocol(i_prot)?;
538          f_1 = Some(val);
539        },
540        _ => {
541          i_prot.skip(field_ident.field_type)?;
542        },
543      };
544      i_prot.read_field_end()?;
545    }
546    i_prot.read_struct_end()?;
547    verify_required_field_exists("OverlayExternalServiceVideoCaptureArgs.arguments", &f_1)?;
548    let ret = OverlayExternalServiceVideoCaptureArgs {
549      arguments: f_1.expect("auto-generated code should have checked for presence of required fields"),
550    };
551    Ok(ret)
552  }
553  fn write_to_out_protocol(&self, o_prot: &mut TOutputProtocol) -> thrift::Result<()> {
554    let struct_ident = TStructIdentifier::new("VideoCapture_args");
555    o_prot.write_struct_begin(&struct_ident)?;
556    o_prot.write_field_begin(&TFieldIdentifier::new("arguments", TType::Struct, 1))?;
557    self.arguments.write_to_out_protocol(o_prot)?;
558    o_prot.write_field_end()?;
559    o_prot.write_field_stop()?;
560    o_prot.write_struct_end()
561  }
562}
563
564//
565// OverlayExternalServiceVideoCaptureResult
566//
567
568#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
569struct OverlayExternalServiceVideoCaptureResult {
570}
571
572impl OverlayExternalServiceVideoCaptureResult {
573  fn read_from_in_protocol(i_prot: &mut TInputProtocol) -> thrift::Result<OverlayExternalServiceVideoCaptureResult> {
574    i_prot.read_struct_begin()?;
575    loop {
576      let field_ident = i_prot.read_field_begin()?;
577      if field_ident.field_type == TType::Stop {
578        break;
579      }
580      let field_id = field_id(&field_ident)?;
581      match field_id {
582        _ => {
583          i_prot.skip(field_ident.field_type)?;
584        },
585      };
586      i_prot.read_field_end()?;
587    }
588    i_prot.read_struct_end()?;
589    let ret = OverlayExternalServiceVideoCaptureResult {};
590    Ok(ret)
591  }
592  fn write_to_out_protocol(&self, o_prot: &mut TOutputProtocol) -> thrift::Result<()> {
593    let struct_ident = TStructIdentifier::new("OverlayExternalServiceVideoCaptureResult");
594    o_prot.write_struct_begin(&struct_ident)?;
595    o_prot.write_field_stop()?;
596    o_prot.write_struct_end()
597  }
598  fn ok_or(self) -> thrift::Result<()> {
599    Ok(())
600  }
601}
602
subor_rs/overlay_manager_s_d_k_services.rs

subor_rs/
overlay_manager_s_d_k_services.rs
