C# BitMaskStream.Read方法代码示例

 public Paging Decode(BitArrayInputStream input)
 {
     int num2;
     Paging paging = new Paging();
     paging.InitDefaults();
     BitMaskStream stream = new BitMaskStream(input, 4);
     if (stream.Read())
     {
         paging.pagingRecordList = new List<PagingRecord>();
         num2 = 4;
         int num3 = input.ReadBits(num2) + 1;
         for (int i = 0; i < num3; i++)
         {
             PagingRecord item = PagingRecord.PerDecoder.Instance.Decode(input);
             paging.pagingRecordList.Add(item);
         }
     }
     if (stream.Read())
     {
         num2 = 1;
         paging.systemInfoModification = (systemInfoModification_Enum)input.ReadBits(num2);
     }
     if (stream.Read())
     {
         num2 = 1;
         paging.etws_Indication = (etws_Indication_Enum)input.ReadBits(num2);
     }
     if (stream.Read())
     {
         paging.nonCriticalExtension = Paging_v890_IEs.PerDecoder.Instance.Decode(input);
     }
     return paging;
 }

 public QuantityConfig Decode(BitArrayInputStream input)
 {
     QuantityConfig config = new QuantityConfig();
     config.InitDefaults();
     bool flag = input.ReadBit() != 0;
     BitMaskStream stream = new BitMaskStream(input, 4);
     if (stream.Read())
     {
         config.quantityConfigEUTRA = QuantityConfigEUTRA.PerDecoder.Instance.Decode(input);
     }
     if (stream.Read())
     {
         config.quantityConfigUTRA = QuantityConfigUTRA.PerDecoder.Instance.Decode(input);
     }
     if (stream.Read())
     {
         config.quantityConfigGERAN = QuantityConfigGERAN.PerDecoder.Instance.Decode(input);
     }
     if (stream.Read())
     {
         config.quantityConfigCDMA2000 = QuantityConfigCDMA2000.PerDecoder.Instance.Decode(input);
     }
     if (flag)
     {
         BitMaskStream stream2 = new BitMaskStream(input, 1);
         if (stream2.Read())
         {
             config.quantityConfigUTRA_v1020 = QuantityConfigUTRA_v1020.PerDecoder.Instance.Decode(input);
         }
     }
     return config;
 }

 public SystemInformationBlockType1_v9e0_IEs Decode(BitArrayInputStream input)
 {
     var es = new SystemInformationBlockType1_v9e0_IEs();
     es.InitDefaults();
     var stream = new BitMaskStream(input, 3);
     if (stream.Read())
     {
         es.freqBandIndicator_v9e0 = input.ReadBits(8) + 0x41;
     }
     if (stream.Read())
     {
         es.multiBandInfoList_v9e0 = new List<MultiBandInfo_v9e0>();
         const int nBits = 3;
         var num3 = input.ReadBits(nBits) + 1;
         for (var i = 0; i < num3; i++)
         {
             var item = MultiBandInfo_v9e0.PerDecoder.Instance.Decode(input);
             es.multiBandInfoList_v9e0.Add(item);
         }
     }
     if (stream.Read())
     {
         es.nonCriticalExtension = nonCriticalExtension_Type.PerDecoder.Instance.Decode(input);
     }
     return es;
 }

 public PhyLayerParameters_v1020 Decode(BitArrayInputStream input)
 {
     int num2;
     PhyLayerParameters_v1020 _v = new PhyLayerParameters_v1020();
     _v.InitDefaults();
     BitMaskStream stream = new BitMaskStream(input, 7);
     if (stream.Read())
     {
         num2 = 1;
         _v.twoAntennaPortsForPUCCH_r10 = (twoAntennaPortsForPUCCH_r10_Enum)input.ReadBits(num2);
     }
     if (stream.Read())
     {
         num2 = 1;
         _v.tm9_With_8Tx_FDD_r10 = (tm9_With_8Tx_FDD_r10_Enum)input.ReadBits(num2);
     }
     if (stream.Read())
     {
         num2 = 1;
         _v.pmi_Disabling_r10 = (pmi_Disabling_r10_Enum)input.ReadBits(num2);
     }
     if (stream.Read())
     {
         num2 = 1;
         _v.crossCarrierScheduling_r10 = (crossCarrierScheduling_r10_Enum)input.ReadBits(num2);
     }
     if (stream.Read())
     {
         num2 = 1;
         _v.simultaneousPUCCH_PUSCH_r10 = (simultaneousPUCCH_PUSCH_r10_Enum)input.ReadBits(num2);
     }
     if (stream.Read())
     {
         num2 = 1;
         _v.multiClusterPUSCH_WithinCC_r10 = (multiClusterPUSCH_WithinCC_r10_Enum)input.ReadBits(num2);
     }
     if (stream.Read())
     {
         _v.nonContiguousUL_RA_WithinCC_List_r10 = new List<NonContiguousUL_RA_WithinCC_r10>();
         num2 = 6;
         int num3 = input.ReadBits(num2) + 1;
         for (int i = 0; i < num3; i++)
         {
             NonContiguousUL_RA_WithinCC_r10 item = NonContiguousUL_RA_WithinCC_r10.PerDecoder.Instance.Decode(input);
             _v.nonContiguousUL_RA_WithinCC_List_r10.Add(item);
         }
     }
     return _v;
 }

 public SystemInformationBlockType2_v9e0_IEs Decode(BitArrayInputStream input)
 {
     var es = new SystemInformationBlockType2_v9e0_IEs();
     es.InitDefaults();
     var stream = new BitMaskStream(input, 2);
     if (stream.Read())
     {
         es.ul_CarrierFreq_v9e0 = input.ReadBits(0x12) + 0x10000;
     }
     if (stream.Read())
     {
         es.nonCriticalExtension = nonCriticalExtension_Type.PerDecoder.Instance.Decode(input);
     }
     return es;
 }

 public RRM_Config Decode(BitArrayInputStream input)
 {
     int num2;
     RRM_Config config = new RRM_Config();
     config.InitDefaults();
     bool flag = input.ReadBit() != 0;
     BitMaskStream stream = new BitMaskStream(input, 1);
     if (stream.Read())
     {
         num2 = 6;
         config.ue_InactiveTime = (ue_InactiveTime_Enum)input.ReadBits(num2);
     }
     if (flag)
     {
         BitMaskStream stream2 = new BitMaskStream(input, 1);
         if (!stream2.Read())
         {
             return config;
         }
         config.candidateCellInfoList_r10 = new List<CandidateCellInfo_r10>();
         num2 = 3;
         int num3 = input.ReadBits(num2) + 1;
         for (int i = 0; i < num3; i++)
         {
             CandidateCellInfo_r10 item = CandidateCellInfo_r10.PerDecoder.Instance.Decode(input);
             config.candidateCellInfoList_r10.Add(item);
         }
     }
     return config;
 }

 public SystemInformation_v8a0_IEs Decode(BitArrayInputStream input)
 {
     var es = new SystemInformation_v8a0_IEs();
     es.InitDefaults();
     var stream = new BitMaskStream(input, 2);
     if (stream.Read())
     {
         var nBits = input.ReadBits(8);
         es.lateNonCriticalExtension = input.readOctetString(nBits);
     }
     if (stream.Read())
     {
         es.nonCriticalExtension = nonCriticalExtension_Type.PerDecoder.Instance.Decode(input);
     }
     return es;
 }

 public ac_BarringInfo_Type Decode(BitArrayInputStream input)
 {
     var type = new ac_BarringInfo_Type();
     type.InitDefaults();
     var stream = new BitMaskStream(input, 2);
     type.ac_BarringForEmergency = input.ReadBit() == 1;
     if (stream.Read())
     {
         type.ac_BarringForMO_Signalling = AC_BarringConfig.PerDecoder.Instance.Decode(input);
     }
     if (stream.Read())
     {
         type.ac_BarringForMO_Data = AC_BarringConfig.PerDecoder.Instance.Decode(input);
     }
     return type;
 }

 public PLMN_Identity Decode(BitArrayInputStream input)
 {
     int num2;
     PLMN_Identity identity = new PLMN_Identity();
     identity.InitDefaults();
     BitMaskStream stream = new BitMaskStream(input, 1);
     if (stream.Read())
     {
         identity.mcc = new List<long>();
         num2 = 0;
         int num3 = input.ReadBits(num2) + 3;
         for (int j = 0; j < num3; j++)
         {
             long item = input.ReadBits(4);
             identity.mcc.Add(item);
         }
     }
     identity.mnc = new List<long>();
     num2 = 1;
     int num6 = input.ReadBits(num2) + 2;
     for (int i = 0; i < num6; i++)
     {
         long num8 = input.ReadBits(4);
         identity.mnc.Add(num8);
     }
     return identity;
 }

 public MobilityControlInfo Decode(BitArrayInputStream input)
 {
     BitMaskStream stream2;
     MobilityControlInfo info = new MobilityControlInfo();
     info.InitDefaults();
     bool flag = input.ReadBit() != 0;
     BitMaskStream stream = new BitMaskStream(input, 4);
     info.targetPhysCellId = input.ReadBits(9);
     if (stream.Read())
     {
         info.carrierFreq = CarrierFreqEUTRA.PerDecoder.Instance.Decode(input);
     }
     if (stream.Read())
     {
         info.carrierBandwidth = CarrierBandwidthEUTRA.PerDecoder.Instance.Decode(input);
     }
     if (stream.Read())
     {
         info.additionalSpectrumEmission = input.ReadBits(5) + 1;
     }
     int nBits = 3;
     info.t304 = (t304_Enum)input.ReadBits(nBits);
     info.newUE_Identity = input.ReadBitString(0x10);
     info.radioResourceConfigCommon = RadioResourceConfigCommon.PerDecoder.Instance.Decode(input);
     if (stream.Read())
     {
         info.rach_ConfigDedicated = RACH_ConfigDedicated.PerDecoder.Instance.Decode(input);
     }
     if (flag)
     {
         stream2 = new BitMaskStream(input, 1);
         if (stream2.Read())
         {
             info.carrierFreq_v9e0 = CarrierFreqEUTRA_v9e0.PerDecoder.Instance.Decode(input);
         }
     }
     if (flag)
     {
         stream2 = new BitMaskStream(input, 1);
         if (stream2.Read())
         {
             nBits = 1;
             info.drb_ContinueROHC_r11 = (drb_ContinueROHC_r11_Enum)input.ReadBits(nBits);
         }
     }
     return info;
 }

 public CQI_ReportConfig Decode(BitArrayInputStream input)
 {
     CQI_ReportConfig config = new CQI_ReportConfig();
     config.InitDefaults();
     BitMaskStream stream = new BitMaskStream(input, 2);
     if (stream.Read())
     {
         int nBits = 3;
         config.cqi_ReportModeAperiodic = (CQI_ReportModeAperiodic)input.ReadBits(nBits);
     }
     config.nomPDSCH_RS_EPRE_Offset = input.ReadBits(3) + -1;
     if (stream.Read())
     {
         config.cqi_ReportPeriodic = CQI_ReportPeriodic.PerDecoder.Instance.Decode(input);
     }
     return config;
 }

 public MeasObjectCDMA2000 Decode(BitArrayInputStream input)
 {
     MeasObjectCDMA2000 tcdma = new MeasObjectCDMA2000();
     tcdma.InitDefaults();
     input.ReadBit();
     BitMaskStream stream = new BitMaskStream(input, 1);
     BitMaskStream stream2 = new BitMaskStream(input, 4);
     int nBits = 1;
     tcdma.cdma2000_Type = (CDMA2000_Type)input.ReadBits(nBits);
     tcdma.carrierFreq = CarrierFreqCDMA2000.PerDecoder.Instance.Decode(input);
     if (stream2.Read())
     {
         tcdma.searchWindowSize = input.ReadBits(4);
     }
     if (stream.Read())
     {
         tcdma.offsetFreq = input.ReadBits(5) + -15;
     }
     if (stream2.Read())
     {
         tcdma.cellsToRemoveList = new List<long>();
         nBits = 5;
         int num3 = input.ReadBits(nBits) + 1;
         for (int i = 0; i < num3; i++)
         {
             long item = input.ReadBits(5) + 1;
             tcdma.cellsToRemoveList.Add(item);
         }
     }
     if (stream2.Read())
     {
         tcdma.cellsToAddModList = new List<CellsToAddModCDMA2000>();
         nBits = 5;
         int num6 = input.ReadBits(nBits) + 1;
         for (int j = 0; j < num6; j++)
         {
             CellsToAddModCDMA2000 dcdma = CellsToAddModCDMA2000.PerDecoder.Instance.Decode(input);
             tcdma.cellsToAddModList.Add(dcdma);
         }
     }
     if (stream2.Read())
     {
         tcdma.cellForWhichToReportCGI = input.ReadBits(9);
     }
     return tcdma;
 }

 public interRAT_Parameters_Type Decode(BitArrayInputStream input)
 {
     interRAT_Parameters_Type type = new interRAT_Parameters_Type();
     type.InitDefaults();
     BitMaskStream stream = new BitMaskStream(input, 7);
     if (stream.Read())
     {
         type.utraFDD = IRAT_ParametersUTRA_FDD.PerDecoder.Instance.Decode(input);
     }
     if (stream.Read())
     {
         type.utraTDD128 = IRAT_ParametersUTRA_TDD128.PerDecoder.Instance.Decode(input);
     }
     if (stream.Read())
     {
         type.utraTDD384 = IRAT_ParametersUTRA_TDD384.PerDecoder.Instance.Decode(input);
     }
     if (stream.Read())
     {
         type.utraTDD768 = IRAT_ParametersUTRA_TDD768.PerDecoder.Instance.Decode(input);
     }
     if (stream.Read())
     {
         type.geran = IRAT_ParametersGERAN.PerDecoder.Instance.Decode(input);
     }
     if (stream.Read())
     {
         type.cdma2000_HRPD = IRAT_ParametersCDMA2000_HRPD.PerDecoder.Instance.Decode(input);
     }
     if (stream.Read())
     {
         type.cdma2000_1xRTT = IRAT_ParametersCDMA2000_1XRTT.PerDecoder.Instance.Decode(input);
     }
     return type;
 }

 public SPS_Config Decode(BitArrayInputStream input)
 {
     SPS_Config config = new SPS_Config();
     config.InitDefaults();
     BitMaskStream stream = new BitMaskStream(input, 3);
     if (stream.Read())
     {
         config.semiPersistSchedC_RNTI = input.ReadBitString(0x10);
     }
     if (stream.Read())
     {
         config.sps_ConfigDL = SPS_ConfigDL.PerDecoder.Instance.Decode(input);
     }
     if (stream.Read())
     {
         config.sps_ConfigUL = SPS_ConfigUL.PerDecoder.Instance.Decode(input);
     }
     return config;
 }

 public Handover Decode(BitArrayInputStream input)
 {
     Handover handover = new Handover();
     handover.InitDefaults();
     BitMaskStream stream = new BitMaskStream(input, 2);
     int num2 = (input.ReadBit() == 0) ? 3 : 3;
     handover.targetRAT_Type = (targetRAT_Type_Enum)input.ReadBits(num2);
     int nBits = input.ReadBits(8);
     handover.targetRAT_MessageContainer = input.readOctetString(nBits);
     if (stream.Read())
     {
         handover.nas_SecurityParamFromEUTRA = input.readOctetString(1);
     }
     if (stream.Read())
     {
         handover.systemInformation = SI_OrPSI_GERAN.PerDecoder.Instance.Decode(input);
     }
     return handover;
 }