SHARE
TWEET

Untitled

a guest Jul 29th, 2018 53 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. #[allow(bad_style)]
  2. #[allow(unused_variables)]
  3. impl ProcessJsonToPointers for FedexShipInput {
  4.     fn collect(&self, json: Value) -> Result<Option<ns1__ValidateShipmentRequest>, Vec<String>> {
  5.         let schema_val = from_str(JSON_SCHEMA_FOR_FedexShipInput).expect("40");
  6.         let mut scope = json_schema::Scope::new();
  7.         let r_schema = scope
  8.             .compile_and_return(schema_val, false)
  9.             .expect("The json schema is invalid. Please connact support");
  10.         let validation_state = r_schema.validate(&json);
  11.         if validation_state.errors.len() > 0 {
  12.             let str_errors = validation_state
  13.                 .errors
  14.                 .into_iter()
  15.                 .map(|n_err| {
  16.                     let err = n_err;
  17.                     format!("{}: {}", err.get_path(), err.get_detail().unwrap_or(""))
  18.                 })
  19.                 .collect::<Vec<_>>();
  20.             return Err(str_errors);
  21.         }
  22.         let mut root = {
  23.             let mut ClientDetail = {
  24.                 let mut AccountNumber =
  25.                     get_mut_prt_string(json["ClientDetail"]["AccountNumber"].clone(), true);
  26.                 let mut IntegratorId =
  27.                     get_mut_prt_string(json["ClientDetail"]["IntegratorId"].clone(), false);
  28.                 let mut Localization = {
  29.                     let mut LanguageCode = get_mut_prt_string(
  30.                         json["ClientDetail"]["Localization"]["LanguageCode"].clone(),
  31.                         true,
  32.                     );
  33.                     let mut LocaleCode =
  34.                         get_mut_prt_string(json["ClientDetail"]["Localization"]["LocaleCode"].clone(), false);
  35.                     let mut ret = if !real {
  36.                         None
  37.                     } else {
  38.                         Some(ns1__Localization {
  39.                             LanguageCode: LanguageCode,
  40.                             LocaleCode: LocaleCode,
  41.                         })
  42.                     };
  43.                     ret
  44.                 };
  45.                 let mut MeterNumber = get_mut_prt_string(json["ClientDetail"]["MeterNumber"].clone(), true);
  46.                 let mut ClientDetail_Localization_ov = if Localization.is_some() {
  47.                     &mut Localization.expect("26") as *mut ns1__Localization
  48.                 } else {
  49.                     std::ptr::null_mut() as *mut ns1__Localization
  50.                 };
  51.                 if json["ClientDetail"].is_null() {
  52.                     return Err(vec![format!("Required obj '{}' not set", "ClientDetail")]);
  53.                 }
  54.                 let mut ret = if !real {
  55.                     None
  56.                 } else {
  57.                     Some(ns1__ClientDetail {
  58.                         AccountNumber: AccountNumber,
  59.                         IntegratorId: IntegratorId,
  60.                         Localization: ClientDetail_Localization_ov,
  61.                         MeterNumber: MeterNumber,
  62.                     })
  63.                 };
  64.                 ret
  65.             };
  66.             let mut RequestedShipment = {
  67.                 let mut BlockInsightVisibility =
  68.                     get_number(json["RequestedShipment"]["BlockInsightVisibility"].clone(), false);
  69.                 let mut ConfigurationData = {
  70.                     let mut DangerousGoodsPackageConfigurations_tmp = vec![];
  71.                     for (array_index, array_obj) in json["RequestedShipment"]["ConfigurationData"]
  72.                         ["DangerousGoodsPackageConfigurations"]
  73.                         .clone()
  74.                         .as_array()
  75.                         .expect("36")
  76.                         .iter()
  77.                         .enumerate()
  78.                     {
  79.                         let mut DangerousGoodsPackageConfigurations_arr_item = {
  80.                             let mut Accessibility = get_number(array_obj["Accessibility"].clone(), false);
  81.                             let mut AdditionalHandling =
  82.                                 get_mut_prt_string(array_obj["AdditionalHandling"].clone(), false);
  83.                             let mut CargoAircraftOnly =
  84.                                 get_number(array_obj["CargoAircraftOnly"].clone(), false);
  85.                             let mut Containers_tmp = vec![];
  86.                             for (array_index, array_obj) in array_obj["Containers"]
  87.                                 .clone()
  88.                                 .as_array()
  89.                                 .expect("36")
  90.                                 .iter()
  91.                                 .enumerate()
  92.                             {
  93.                                 let mut Containers_arr_item = {
  94.                                     let mut ContainerType =
  95.                                         get_mut_prt_string(array_obj["ContainerType"].clone(), false);
  96.                                     let mut HazardousCommodities_tmp = vec![];
  97.                                     for (array_index, array_obj) in array_obj["HazardousCommodities"]
  98.                                         .clone()
  99.                                         .as_array()
  100.                                         .expect("36")
  101.                                         .iter()
  102.                                         .enumerate()
  103.                                     {
  104.                                         let mut HazardousCommodities_arr_item = {
  105.                                             let mut Description = {
  106.                                                 let mut Authorization = get_mut_prt_string(
  107.                                                     array_obj["Description"]["Authorization"].clone(),
  108.                                                     false,
  109.                                                 );
  110.                                                 let mut HazardClass = get_mut_prt_string(
  111.                                                     array_obj["Description"]["HazardClass"].clone(),
  112.                                                     false,
  113.                                                 );
  114.                                                 let mut Id = get_mut_prt_string(
  115.                                                     array_obj["Description"]["Id"].clone(),
  116.                                                     false,
  117.                                                 );
  118.                                                 let mut LabelText = get_mut_prt_string(
  119.                                                     array_obj["Description"]["LabelText"].clone(),
  120.                                                     false,
  121.                                                 );
  122.                                                 let mut PackingDetails = {
  123.                                                     let mut CargoAircraftOnly = get_number(
  124.                                                         array_obj["Description"]["PackingDetails"]
  125.                                                             ["CargoAircraftOnly"]
  126.                                                             .clone(),
  127.                                                         false,
  128.                                                     );
  129.                                                     let mut PackingInstructions = get_mut_prt_string(
  130.                                                         array_obj["Description"]["PackingDetails"]
  131.                                                             ["PackingInstructions"]
  132.                                                             .clone(),
  133.                                                         false,
  134.                                                     );
  135.                                                     let mut ret = if !real {
  136.                                                         None
  137.                                                     } else {
  138.                                                         Some(ns1__HazardousCommodityPackingDetail {
  139.                                                             CargoAircraftOnly: CargoAircraftOnly,
  140.                                                             PackingInstructions: PackingInstructions,
  141.                                                         })
  142.                                                     };
  143.                                                     ret
  144.                                                 };
  145.                                                 let mut PackingGroup = get_number(
  146.                                                     array_obj["Description"]["PackingGroup"].clone(),
  147.                                                     false,
  148.                                                 );
  149.                                                 let mut Percentage = get_mut_prt_string(
  150.                                                     array_obj["Description"]["Percentage"].clone(),
  151.                                                     false,
  152.                                                 );
  153.                                                 let mut ProcessingOptions_tmp = vec![];
  154.                                                 for (array_index, array_obj) in array_obj["Description"]
  155.                                                     ["ProcessingOptions"]
  156.                                                     .clone()
  157.                                                     .as_array()
  158.                                                     .expect("36")
  159.                                                     .iter()
  160.                                                     .enumerate()
  161.                                                 {
  162.                                                     let mut ProcessingOptions_arr_item =
  163.                                                         get_number(array_obj.clone(), false);
  164.                                                     ProcessingOptions_tmp.push(ProcessingOptions_arr_item);
  165.                                                 }
  166.                                                 let ProcessingOptions = unsafe {
  167.                                                     libc::malloc(
  168.                                                         std::mem::size_of::<u32>()
  169.                                                             * ProcessingOptions_tmp.len(),
  170.                                                     )
  171.                                                         as *mut u32
  172.                                                 };
  173.                                                 for i in 0..ProcessingOptions_tmp.len() {
  174.                                                     unsafe {
  175.                                                         ProcessingOptions
  176.                                                             .offset(i as isize)
  177.                                                             .write(ProcessingOptions_tmp[i])
  178.                                                     };
  179.                                                 }
  180.                                                 let mut ProperShippingName = get_mut_prt_string(
  181.                                                     array_obj["Description"]["ProperShippingName"].clone(),
  182.                                                     false,
  183.                                                 );
  184.                                                 let mut ReportableQuantity = get_number(
  185.                                                     array_obj["Description"]["ReportableQuantity"].clone(),
  186.                                                     false,
  187.                                                 );
  188.                                                 let mut SequenceNumber = get_mut_prt_string(
  189.                                                     array_obj["Description"]["SequenceNumber"].clone(),
  190.                                                     false,
  191.                                                 );
  192.                                                 let mut SubsidiaryClasses_tmp = vec![];
  193.                                                 for (array_index, array_obj) in array_obj["Description"]
  194.                                                     ["SubsidiaryClasses"]
  195.                                                     .clone()
  196.                                                     .as_array()
  197.                                                     .expect("36")
  198.                                                     .iter()
  199.                                                     .enumerate()
  200.                                                 {
  201.                                                     let mut SubsidiaryClasses_arr_item =
  202.                                                         get_mut_prt_string(array_obj.clone(), false);
  203.                                                     SubsidiaryClasses_tmp.push(SubsidiaryClasses_arr_item);
  204.                                                 }
  205.                                                 let SubsidiaryClasses = SubsidiaryClasses_tmp.as_mut_ptr();
  206.                                                 let mut TechnicalName = get_mut_prt_string(
  207.                                                     array_obj["Description"]["TechnicalName"].clone(),
  208.                                                     false,
  209.                                                 );
  210.                                                 let mut Description_PackingDetails_ov =
  211.                                                     if PackingDetails.is_some() {
  212.                                                         &mut PackingDetails.expect("26")
  213.                                                             as *mut ns1__HazardousCommodityPackingDetail
  214.                                                     } else {
  215.                                                         std::ptr::null_mut()
  216.                                                             as *mut ns1__HazardousCommodityPackingDetail
  217.                                                     };
  218.                                                 let mut ret = if !real {
  219.                                                     None
  220.                                                 } else {
  221.                                                     Some(ns1__HazardousCommodityDescription {
  222.                                                         Authorization: Authorization,
  223.                                                         HazardClass: HazardClass,
  224.                                                         Id: Id,
  225.                                                         LabelText: LabelText,
  226.                                                         PackingDetails: Description_PackingDetails_ov,
  227.                                                         PackingGroup: PackingGroup,
  228.                                                         Percentage: Percentage,
  229.                                                         __sizeProcessingOptions: ProcessingOptions_tmp.len()
  230.                                                             as i32,
  231.                                                         ProcessingOptions: ProcessingOptions,
  232.                                                         ProperShippingName: ProperShippingName,
  233.                                                         ReportableQuantity: ReportableQuantity,
  234.                                                         SequenceNumber: SequenceNumber,
  235.                                                         __sizeSubsidiaryClasses: SubsidiaryClasses_tmp.len()
  236.                                                             as i32,
  237.                                                         SubsidiaryClasses: SubsidiaryClasses,
  238.                                                         TechnicalName: TechnicalName,
  239.                                                     })
  240.                                                 };
  241.                                                 std::mem::forget(ProcessingOptions_tmp);
  242.                                                 std::mem::forget(SubsidiaryClasses_tmp);
  243.                                                 ret
  244.                                             };
  245.                                             let mut InnerReceptacles_tmp = vec![];
  246.                                             for (array_index, array_obj) in array_obj["InnerReceptacles"]
  247.                                                 .clone()
  248.                                                 .as_array()
  249.                                                 .expect("36")
  250.                                                 .iter()
  251.                                                 .enumerate()
  252.                                             {
  253.                                                 let mut InnerReceptacles_arr_item = {
  254.                                                     let mut Quantity = {
  255.                                                         let mut Amount = get_mut_prt_string(
  256.                                                             array_obj["Quantity"]["Amount"].clone(),
  257.                                                             false,
  258.                                                         );
  259.                                                         let mut QuantityType = get_number(
  260.                                                             array_obj["Quantity"]["QuantityType"].clone(),
  261.                                                             false,
  262.                                                         );
  263.                                                         let mut Units = get_mut_prt_string(
  264.                                                             array_obj["Quantity"]["Units"].clone(),
  265.                                                             false,
  266.                                                         );
  267.                                                         let mut ret = if !real {
  268.                                                             None
  269.                                                         } else {
  270.                                                             Some(ns1__HazardousCommodityQuantityDetail {
  271.                                                                 Amount: Amount,
  272.                                                                 QuantityType: QuantityType,
  273.                                                                 Units: Units,
  274.                                                             })
  275.                                                         };
  276.                                                         ret
  277.                                                     };
  278.                                                     let mut InnerReceptacles_arr_item_Quantity_ov =
  279.                                                         if Quantity.is_some() {
  280.                                                             &mut Quantity.expect("26")
  281.                                                                 as *mut ns1__HazardousCommodityQuantityDetail
  282.                                                         } else {
  283.                                                             std::ptr::null_mut()
  284.                                                                 as *mut ns1__HazardousCommodityQuantityDetail
  285.                                                         };
  286.                                                     let mut ret = if !real {
  287.                                                         None
  288.                                                     } else {
  289.                                                         Some(ns1__HazardousCommodityInnerReceptacleDetail {
  290.                                                             Quantity: InnerReceptacles_arr_item_Quantity_ov,
  291.                                                         })
  292.                                                     };
  293.                                                     ret
  294.                                                 };
  295.                                                 if InnerReceptacles_arr_item.is_some() {
  296.                                                     InnerReceptacles_tmp
  297.                                                         .push(InnerReceptacles_arr_item.expect("35"));
  298.                                                 }
  299.                                             }
  300.                                             let InnerReceptacles = unsafe {
  301.                                                 libc::malloc(
  302.                                                     std::mem::size_of::<
  303.                                                         ns1__HazardousCommodityInnerReceptacleDetail,
  304.                                                     >()
  305.                                                         * InnerReceptacles_tmp.len(),
  306.                                                 )
  307.                                                     as *mut ns1__HazardousCommodityInnerReceptacleDetail
  308.                                             };
  309.                                             for i in 0..InnerReceptacles_tmp.len() {
  310.                                                 unsafe {
  311.                                                     InnerReceptacles
  312.                                                         .offset(i as isize)
  313.                                                         .write(InnerReceptacles_tmp[i])
  314.                                                 };
RAW Paste Data
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy. OK, I Understand
 
Top