LEFT | RIGHT |
1 /* -*- Mode: C++; c-file-style: "gnu"; indent-tabs-mode:nil; -*- */ | 1 /* -*- Mode: C++; c-file-style: "gnu"; indent-tabs-mode:nil; -*- */ |
2 /* | 2 /* |
3 * Copyright (c) 2012 Centre Tecnologic de Telecomunicacions de Catalunya (CTTC) | 3 * Copyright (c) 2012 Centre Tecnologic de Telecomunicacions de Catalunya (CTTC) |
4 * | 4 * |
5 * This program is free software; you can redistribute it and/or modify | 5 * This program is free software; you can redistribute it and/or modify |
6 * it under the terms of the GNU General Public License version 2 as | 6 * it under the terms of the GNU General Public License version 2 as |
7 * published by the Free Software Foundation; | 7 * published by the Free Software Foundation; |
8 * | 8 * |
9 * This program is distributed in the hope that it will be useful, | 9 * This program is distributed in the hope that it will be useful, |
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of | 10 * but WITHOUT ANY WARRANTY; without even the implied warranty of |
(...skipping 27 matching lines...) Expand all Loading... |
38 #define MAX_MEAS_ID 32 | 38 #define MAX_MEAS_ID 32 |
39 #define MAX_CELL_MEAS 32 | 39 #define MAX_CELL_MEAS 32 |
40 #define MAX_CELL_REPORT 8 | 40 #define MAX_CELL_REPORT 8 |
41 | 41 |
42 #define MAX_SCELL_REPORT 5 | 42 #define MAX_SCELL_REPORT 5 |
43 #define MAX_SCELL_CONF 5 | 43 #define MAX_SCELL_CONF 5 |
44 namespace ns3 { | 44 namespace ns3 { |
45 | 45 |
46 NS_LOG_COMPONENT_DEFINE ("RrcHeader"); | 46 NS_LOG_COMPONENT_DEFINE ("RrcHeader"); |
47 | 47 |
| 48 |
48 //////////////////// RrcAsn1Header class /////////////////////////////// | 49 //////////////////// RrcAsn1Header class /////////////////////////////// |
49 RrcAsn1Header::RrcAsn1Header () | 50 RrcAsn1Header::RrcAsn1Header () |
50 { | 51 { |
51 } | 52 } |
52 | 53 |
53 TypeId | 54 TypeId |
54 RrcAsn1Header::GetTypeId (void) | 55 RrcAsn1Header::GetTypeId (void) |
55 { | 56 { |
56 static TypeId tid = TypeId ("ns3::RrcAsn1Header") | 57 static TypeId tid = TypeId ("ns3::RrcAsn1Header") |
57 .SetParent<Header> () | 58 .SetParent<Header> () |
58 .SetGroupName("Lte") | 59 .SetGroupName("Lte") |
59 ; | 60 ; |
60 return tid; | 61 return tid; |
61 } | 62 } |
62 | 63 |
63 TypeId | 64 TypeId |
64 RrcAsn1Header::GetInstanceTypeId (void) const | 65 RrcAsn1Header::GetInstanceTypeId (void) const |
65 { | 66 { |
66 return GetTypeId (); | 67 return GetTypeId (); |
67 } | 68 } |
68 | 69 |
69 int | 70 int |
70 RrcAsn1Header::GetMessageType () | 71 RrcAsn1Header::GetMessageType () |
71 { | 72 { |
72 return m_messageType; | 73 return m_messageType; |
| 74 } |
| 75 |
| 76 int |
| 77 RrcAsn1Header::BandwidthToEnum (uint8_t bandwidth) const |
| 78 { |
| 79 int n; |
| 80 switch (bandwidth) |
| 81 { |
| 82 case 6: n = 0; break; |
| 83 case 15: n = 1; break; |
| 84 case 25: n = 2; break; |
| 85 case 50: n = 3; break; |
| 86 case 75: n = 4; break; |
| 87 case 100: n = 5; break; |
| 88 default: |
| 89 NS_FATAL_ERROR ("Wrong bandwidth: " << (uint16_t) bandwidth); |
| 90 } |
| 91 return n; |
| 92 } |
| 93 |
| 94 uint8_t |
| 95 RrcAsn1Header::EnumToBandwidth (int n) const |
| 96 { |
| 97 uint8_t bw; |
| 98 switch (n) |
| 99 { |
| 100 case 0: bw = 6; break; |
| 101 case 1: bw = 15; break; |
| 102 case 2: bw = 25; break; |
| 103 case 3: bw = 50; break; |
| 104 case 4: bw = 75; break; |
| 105 case 5: bw = 100; break; |
| 106 default: |
| 107 NS_FATAL_ERROR ("Wrong enum value for bandwidth: " << n); |
| 108 } |
| 109 return bw; |
73 } | 110 } |
74 | 111 |
75 void | 112 void |
76 RrcAsn1Header::SerializeDrbToAddModList (std::list<LteRrcSap::DrbToAddMod> drbTo
AddModList) const | 113 RrcAsn1Header::SerializeDrbToAddModList (std::list<LteRrcSap::DrbToAddMod> drbTo
AddModList) const |
77 { | 114 { |
78 // Serialize DRB-ToAddModList sequence-of | 115 // Serialize DRB-ToAddModList sequence-of |
79 SerializeSequenceOf (drbToAddModList.size (),MAX_DRB,1); | 116 SerializeSequenceOf (drbToAddModList.size (),MAX_DRB,1); |
80 | 117 |
81 // Serialize the elements in the sequence-of list | 118 // Serialize the elements in the sequence-of list |
82 std::list<LteRrcSap::DrbToAddMod>::iterator it = drbToAddModList.begin (); | 119 std::list<LteRrcSap::DrbToAddMod>::iterator it = drbToAddModList.begin (); |
(...skipping 475 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
558 SerializeInteger (0,0,98); // nRB-CQI | 595 SerializeInteger (0,0,98); // nRB-CQI |
559 SerializeInteger (0,0,7); // nCS-AN | 596 SerializeInteger (0,0,7); // nCS-AN |
560 SerializeInteger (0,0,2047); // n1PUCCH-AN | 597 SerializeInteger (0,0,2047); // n1PUCCH-AN |
561 // soundingRS-UL-ConfigCommon· | 598 // soundingRS-UL-ConfigCommon· |
562 SerializeChoice (2,0,false); | 599 SerializeChoice (2,0,false); |
563 SerializeNull (); // release | 600 SerializeNull (); // release |
564 // uplinkPowerControlCommon· | 601 // uplinkPowerControlCommon· |
565 SerializeSequence (std::bitset<0> (0),false); | 602 SerializeSequence (std::bitset<0> (0),false); |
566 SerializeInteger (0,-126,24); // p0-NominalPUSCH | 603 SerializeInteger (0,-126,24); // p0-NominalPUSCH |
567 SerializeEnum (8,0); // alpha | 604 SerializeEnum (8,0); // alpha |
568 SerializeInteger (-50,-127,-96); // p0-NominalPUCCH | 605 SerializeInteger (-110,-127,-96); // p0-NominalPUCCH |
569 SerializeSequence (std::bitset<0> (0),false); // deltaFList-PUCCH | 606 SerializeSequence (std::bitset<0> (0),false); // deltaFList-PUCCH |
570 SerializeEnum (3,0); // deltaF-PUCCH-Format1 | 607 SerializeEnum (3,0); // deltaF-PUCCH-Format1 |
571 SerializeEnum (3,0); // deltaF-PUCCH-Format1b | 608 SerializeEnum (3,0); // deltaF-PUCCH-Format1b |
572 SerializeEnum (4,0); // deltaF-PUCCH-Format2 | 609 SerializeEnum (4,0); // deltaF-PUCCH-Format2 |
573 SerializeEnum (3,0); // deltaF-PUCCH-Format2a | 610 SerializeEnum (3,0); // deltaF-PUCCH-Format2a |
574 SerializeEnum (3,0); // deltaF-PUCCH-Format2b | 611 SerializeEnum (3,0); // deltaF-PUCCH-Format2b |
575 SerializeInteger (0,-1,6); | 612 SerializeInteger (0,-1,6); |
576 // ul-CyclicPrefixLength· | 613 // ul-CyclicPrefixLength· |
577 SerializeEnum (2,0); | 614 SerializeEnum (2,0); |
578 } | 615 } |
(...skipping 11 matching lines...) Expand all Loading... |
590 SerializeEnum (8,0); // t300 | 627 SerializeEnum (8,0); // t300 |
591 SerializeEnum (8,0); // t301 | 628 SerializeEnum (8,0); // t301 |
592 SerializeEnum (7,0); // t310 | 629 SerializeEnum (7,0); // t310 |
593 SerializeEnum (8,0); // n310 | 630 SerializeEnum (8,0); // n310 |
594 SerializeEnum (7,0); // t311 | 631 SerializeEnum (7,0); // t311 |
595 SerializeEnum (8,0); // n311 | 632 SerializeEnum (8,0); // n311 |
596 | 633 |
597 // freqInfo | 634 // freqInfo |
598 SerializeSequence (std::bitset<2> (3),false); | 635 SerializeSequence (std::bitset<2> (3),false); |
599 SerializeInteger ((int) systemInformationBlockType2.freqInfo.ulCarrierFreq, 0,
MAX_EARFCN); | 636 SerializeInteger ((int) systemInformationBlockType2.freqInfo.ulCarrierFreq, 0,
MAX_EARFCN); |
600 switch (systemInformationBlockType2.freqInfo.ulBandwidth) | 637 SerializeEnum (6, BandwidthToEnum (systemInformationBlockType2.freqInfo.ulBand
width)); |
601 { | |
602 case 6: | |
603 SerializeEnum (6,0); | |
604 break; | |
605 case 15: | |
606 SerializeEnum (6,1); | |
607 break; | |
608 case 25: | |
609 SerializeEnum (6,2); | |
610 break; | |
611 case 50: | |
612 SerializeEnum (6,3); | |
613 break; | |
614 case 75: | |
615 SerializeEnum (6,4); | |
616 break; | |
617 case 100: | |
618 SerializeEnum (6,5); | |
619 break; | |
620 default: | |
621 SerializeEnum (6,0); | |
622 } | |
623 | 638 |
624 SerializeInteger (29,1,32); // additionalSpectrumEmission | 639 SerializeInteger (29,1,32); // additionalSpectrumEmission |
625 // timeAlignmentTimerCommon | 640 // timeAlignmentTimerCommon |
626 SerializeEnum (8,0); | 641 SerializeEnum (8,0); |
627 } | 642 } |
628 | 643 |
629 void | 644 void |
630 RrcAsn1Header::SerializeMeasResults (LteRrcSap::MeasResults measResults) const | 645 RrcAsn1Header::SerializeMeasResults (LteRrcSap::MeasResults measResults) const |
631 { | 646 { |
632 // Watchdog: if list has 0 elements, set boolean to false | 647 // Watchdog: if list has 0 elements, set boolean to false |
(...skipping 121 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
754 { | 769 { |
755 // plmn-Identity sequence, mcc is optional, no extension marker | 770 // plmn-Identity sequence, mcc is optional, no extension marker |
756 SerializeSequence (std::bitset<1> (0), false); | 771 SerializeSequence (std::bitset<1> (0), false); |
757 | 772 |
758 // Serialize mnc | 773 // Serialize mnc |
759 int nDig = (plmnId > 99) ? 3 : 2; | 774 int nDig = (plmnId > 99) ? 3 : 2; |
760 | 775 |
761 SerializeSequenceOf (nDig,3,2); | 776 SerializeSequenceOf (nDig,3,2); |
762 for (int i = nDig - 1; i >= 0; i--) | 777 for (int i = nDig - 1; i >= 0; i--) |
763 { | 778 { |
764 int n = static_cast<int>(floor (plmnId / pow (10,i))); | 779 int n = static_cast<int> (floor (plmnId / pow (10,i))); |
765 SerializeInteger (n,0,9); | 780 SerializeInteger (n,0,9); |
766 plmnId -= static_cast<uint32_t>(n * pow (10,i)); | 781 plmnId -= static_cast<uint32_t> (n * pow (10,i)); |
767 } | 782 } |
768 | 783 |
769 // cellReservedForOperatorUse· | 784 // cellReservedForOperatorUse· |
770 SerializeEnum (2,0); | 785 SerializeEnum (2,0); |
771 } | 786 } |
772 | 787 |
773 void· | 788 void· |
774 RrcAsn1Header::SerializeRachConfigCommon (LteRrcSap::RachConfigCommon rachConfig
Common) const | 789 RrcAsn1Header::SerializeRachConfigCommon (LteRrcSap::RachConfigCommon rachConfig
Common) const |
775 { | 790 { |
776 // rach-ConfigCommon | 791 // rach-ConfigCommon |
(...skipping 47 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
824 case 56: | 839 case 56: |
825 SerializeEnum (16,13); | 840 SerializeEnum (16,13); |
826 break; | 841 break; |
827 case 60: | 842 case 60: |
828 SerializeEnum (16,14); | 843 SerializeEnum (16,14); |
829 break; | 844 break; |
830 case 64: | 845 case 64: |
831 SerializeEnum (16,15); | 846 SerializeEnum (16,15); |
832 break; | 847 break; |
833 default: | 848 default: |
834 SerializeEnum (16,0); | 849 NS_FATAL_ERROR ("Wrong numberOfRA-Preambles value"); |
835 } | 850 } |
836 | 851 |
837 SerializeSequence (std::bitset<0> (0),false); // powerRampingParameters | 852 SerializeSequence (std::bitset<0> (0),false); // powerRampingParameters |
838 SerializeEnum (4,0); // powerRampingStep | 853 SerializeEnum (4,0); // powerRampingStep |
839 SerializeEnum (16,0); // preambleInitialReceivedTargetPower | 854 SerializeEnum (16,0); // preambleInitialReceivedTargetPower |
840 SerializeSequence (std::bitset<0> (0),false); // ra-SupervisionInfo | 855 SerializeSequence (std::bitset<0> (0),false); // ra-SupervisionInfo |
841 | 856 |
842 // preambleTransMax | 857 // preambleTransMax |
843 switch (rachConfigCommon.raSupervisionInfo.preambleTransMax) | 858 switch (rachConfigCommon.raSupervisionInfo.preambleTransMax) |
844 { | 859 { |
(...skipping 231 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1076 measObjOpts.set (3,!it->measObjectEutra.cellsToAddModList.empty () ); | 1091 measObjOpts.set (3,!it->measObjectEutra.cellsToAddModList.empty () ); |
1077 measObjOpts.set (2,!it->measObjectEutra.blackCellsToRemoveList.empty (
) ); | 1092 measObjOpts.set (2,!it->measObjectEutra.blackCellsToRemoveList.empty (
) ); |
1078 measObjOpts.set (1,!it->measObjectEutra.blackCellsToAddModList.empty (
) ); | 1093 measObjOpts.set (1,!it->measObjectEutra.blackCellsToAddModList.empty (
) ); |
1079 measObjOpts.set (0,it->measObjectEutra.haveCellForWhichToReportCGI); | 1094 measObjOpts.set (0,it->measObjectEutra.haveCellForWhichToReportCGI); |
1080 SerializeSequence (measObjOpts, true); | 1095 SerializeSequence (measObjOpts, true); |
1081 | 1096 |
1082 // Serialize carrierFreq | 1097 // Serialize carrierFreq |
1083 SerializeInteger (it->measObjectEutra.carrierFreq, 0, MAX_EARFCN); | 1098 SerializeInteger (it->measObjectEutra.carrierFreq, 0, MAX_EARFCN); |
1084 | 1099 |
1085 // Serialize allowedMeasBandwidth | 1100 // Serialize allowedMeasBandwidth |
1086 switch (it->measObjectEutra.allowedMeasBandwidth) | 1101 SerializeEnum (6, BandwidthToEnum (it->measObjectEutra.allowedMeasBand
width)); |
1087 { | |
1088 case 6: | |
1089 SerializeEnum (6,0); | |
1090 break; | |
1091 case 15: | |
1092 SerializeEnum (6,1); | |
1093 break; | |
1094 case 25: | |
1095 SerializeEnum (6,2); | |
1096 break; | |
1097 case 50: | |
1098 SerializeEnum (6,3); | |
1099 break; | |
1100 case 75: | |
1101 SerializeEnum (6,4); | |
1102 break; | |
1103 case 100: | |
1104 SerializeEnum (6,5); | |
1105 break; | |
1106 default: | |
1107 SerializeEnum (6,0); | |
1108 } | |
1109 | 1102 |
1110 SerializeBoolean (it->measObjectEutra.presenceAntennaPort1); | 1103 SerializeBoolean (it->measObjectEutra.presenceAntennaPort1); |
1111 SerializeBitstring (std::bitset<2> (it->measObjectEutra.neighCellConfi
g)); | 1104 SerializeBitstring (std::bitset<2> (it->measObjectEutra.neighCellConfi
g)); |
1112 SerializeQoffsetRange (it->measObjectEutra.offsetFreq); | 1105 SerializeQoffsetRange (it->measObjectEutra.offsetFreq); |
1113 | 1106 |
1114 if (!it->measObjectEutra.cellsToRemoveList.empty ()) | 1107 if (!it->measObjectEutra.cellsToRemoveList.empty ()) |
1115 { | 1108 { |
1116 SerializeSequenceOf (it->measObjectEutra.cellsToRemoveList.size ()
,MAX_CELL_MEAS,1); | 1109 SerializeSequenceOf (it->measObjectEutra.cellsToRemoveList.size ()
,MAX_CELL_MEAS,1); |
1117 for (std::list<uint8_t>::iterator it2 = it->measObjectEutra.cellsT
oRemoveList.begin (); it2 != it->measObjectEutra.cellsToRemoveList.end (); it2++
) | 1110 for (std::list<uint8_t>::iterator it2 = it->measObjectEutra.cellsT
oRemoveList.begin (); it2 != it->measObjectEutra.cellsToRemoveList.end (); it2++
) |
1118 { | 1111 { |
(...skipping 873 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1992 RrcAsn1Header::DeserializeThresholdEutra (LteRrcSap::ThresholdEutra * thresholdE
utra, Buffer::Iterator bIterator) | 1985 RrcAsn1Header::DeserializeThresholdEutra (LteRrcSap::ThresholdEutra * thresholdE
utra, Buffer::Iterator bIterator) |
1993 { | 1986 { |
1994 int thresholdEutraChoice, range; | 1987 int thresholdEutraChoice, range; |
1995 bIterator = DeserializeChoice (2, false, &thresholdEutraChoice, bIterator); | 1988 bIterator = DeserializeChoice (2, false, &thresholdEutraChoice, bIterator); |
1996 | 1989 |
1997 switch (thresholdEutraChoice) | 1990 switch (thresholdEutraChoice) |
1998 { | 1991 { |
1999 case 0: | 1992 case 0: |
2000 thresholdEutra->choice = LteRrcSap::ThresholdEutra::THRESHOLD_RSRP; | 1993 thresholdEutra->choice = LteRrcSap::ThresholdEutra::THRESHOLD_RSRP; |
2001 bIterator = DeserializeInteger (&range, 0, 97, bIterator); | 1994 bIterator = DeserializeInteger (&range, 0, 97, bIterator); |
2002 thresholdEutra->range = static_cast<uint8_t>(range); | 1995 thresholdEutra->range = static_cast<uint8_t> (range); |
2003 break; | 1996 break; |
2004 case 1: | 1997 case 1: |
2005 default: | 1998 default: |
2006 thresholdEutra->choice = LteRrcSap::ThresholdEutra::THRESHOLD_RSRQ; | 1999 thresholdEutra->choice = LteRrcSap::ThresholdEutra::THRESHOLD_RSRQ; |
2007 bIterator = DeserializeInteger (&range, 0, 34, bIterator); | 2000 bIterator = DeserializeInteger (&range, 0, 34, bIterator); |
2008 thresholdEutra->range = static_cast<uint8_t>(range); | 2001 thresholdEutra->range = static_cast<uint8_t> (range); |
2009 } | 2002 } |
2010 | 2003 |
2011 return bIterator; | 2004 return bIterator; |
2012 } | 2005 } |
2013 | 2006 |
2014 Buffer::Iterator | 2007 Buffer::Iterator |
2015 RrcAsn1Header::DeserializeQoffsetRange (int8_t * qOffsetRange, Buffer::Iterator
bIterator) | 2008 RrcAsn1Header::DeserializeQoffsetRange (int8_t * qOffsetRange, Buffer::Iterator
bIterator) |
2016 { | 2009 { |
2017 int n; | 2010 int n; |
2018 bIterator = DeserializeEnum (31, &n, bIterator); | 2011 bIterator = DeserializeEnum (31, &n, bIterator); |
(...skipping 117 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2136 | 2129 |
2137 if (optionalFieldsPresent[3]) | 2130 if (optionalFieldsPresent[3]) |
2138 { | 2131 { |
2139 // Deserialize drb-ToReleaseList | 2132 // Deserialize drb-ToReleaseList |
2140 int n; | 2133 int n; |
2141 int val; | 2134 int val; |
2142 bIterator = DeserializeSequenceOf (&n,MAX_DRB,1,bIterator); | 2135 bIterator = DeserializeSequenceOf (&n,MAX_DRB,1,bIterator); |
2143 for (int i = 0; i < n; i++) | 2136 for (int i = 0; i < n; i++) |
2144 { | 2137 { |
2145 bIterator = DeserializeInteger (&val,1,32,bIterator); | 2138 bIterator = DeserializeInteger (&val,1,32,bIterator); |
2146 radioResourceConfigDedicated->drbToReleaseList.push_back (static_cast<
uint8_t>(val)); | 2139 radioResourceConfigDedicated->drbToReleaseList.push_back (static_cast<
uint8_t> (val)); |
2147 } | 2140 } |
2148 } | 2141 } |
2149 | 2142 |
2150 if (optionalFieldsPresent[2]) | 2143 if (optionalFieldsPresent[2]) |
2151 { | 2144 { |
2152 // Deserialize mac-MainConfig | 2145 // Deserialize mac-MainConfig |
2153 // ... | 2146 // ... |
2154 } | 2147 } |
2155 | 2148 |
2156 if (optionalFieldsPresent[1]) | 2149 if (optionalFieldsPresent[1]) |
(...skipping 25 matching lines...) Expand all Loading... |
2182 { | 2175 { |
2183 LteRrcSap::SrbToAddMod srbToAddMod; | 2176 LteRrcSap::SrbToAddMod srbToAddMod; |
2184 // Deserialize SRB-ToAddMod sequence | 2177 // Deserialize SRB-ToAddMod sequence |
2185 // 2 optional fields, extension marker present | 2178 // 2 optional fields, extension marker present |
2186 std::bitset<2> optionalFields; | 2179 std::bitset<2> optionalFields; |
2187 bIterator = DeserializeSequence (&optionalFields,true,bIterator); | 2180 bIterator = DeserializeSequence (&optionalFields,true,bIterator); |
2188 | 2181 |
2189 // Deserialize srbIdentity | 2182 // Deserialize srbIdentity |
2190 int n; | 2183 int n; |
2191 bIterator = DeserializeInteger (&n,1,2,bIterator); | 2184 bIterator = DeserializeInteger (&n,1,2,bIterator); |
2192 srbToAddMod.srbIdentity = static_cast<uint8_t>(n); | 2185 srbToAddMod.srbIdentity = static_cast<uint8_t> (n); |
2193 | 2186 |
2194 if (optionalFields[1]) | 2187 if (optionalFields[1]) |
2195 { | 2188 { |
2196 // Deserialize rlcConfig choice | 2189 // Deserialize rlcConfig choice |
2197 // ... | 2190 // ... |
2198 } | 2191 } |
2199 | 2192 |
2200 if (optionalFields[0]) | 2193 if (optionalFields[0]) |
2201 { | 2194 { |
2202 // Deserialize logicalChannelConfig choice | 2195 // Deserialize logicalChannelConfig choice |
(...skipping 31 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2234 { | 2227 { |
2235 LteRrcSap::DrbToAddMod drbToAddMod; | 2228 LteRrcSap::DrbToAddMod drbToAddMod; |
2236 | 2229 |
2237 std::bitset<5> optionalFields; | 2230 std::bitset<5> optionalFields; |
2238 bIterator = DeserializeSequence (&optionalFields,true,bIterator); | 2231 bIterator = DeserializeSequence (&optionalFields,true,bIterator); |
2239 | 2232 |
2240 if (optionalFields[4]) | 2233 if (optionalFields[4]) |
2241 { | 2234 { |
2242 // Deserialize epsBearerIdentity | 2235 // Deserialize epsBearerIdentity |
2243 bIterator = DeserializeInteger (&val,0,15,bIterator); | 2236 bIterator = DeserializeInteger (&val,0,15,bIterator); |
2244 drbToAddMod.epsBearerIdentity = static_cast<uint8_t>(val); | 2237 drbToAddMod.epsBearerIdentity = static_cast<uint8_t> (val); |
2245 } | 2238 } |
2246 | 2239 |
2247 bIterator = DeserializeInteger (&val,1,32,bIterator); | 2240 bIterator = DeserializeInteger (&val,1,32,bIterator); |
2248 drbToAddMod.drbIdentity = static_cast<uint8_t>(val); | 2241 drbToAddMod.drbIdentity = static_cast<uint8_t> (val); |
2249 | 2242 |
2250 if (optionalFields[3]) | 2243 if (optionalFields[3]) |
2251 { | 2244 { |
2252 // Deserialize pdcp-Config | 2245 // Deserialize pdcp-Config |
2253 // ... | 2246 // ... |
2254 } | 2247 } |
2255 | 2248 |
2256 if (optionalFields[2]) | 2249 if (optionalFields[2]) |
2257 { | 2250 { |
2258 // Deserialize RLC-Config | 2251 // Deserialize RLC-Config |
(...skipping 49 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2308 bIterator = DeserializeEnum (2,&sel, bIterator); // sn-FieldLength | 2301 bIterator = DeserializeEnum (2,&sel, bIterator); // sn-FieldLength |
2309 bIterator = DeserializeEnum (32,&sel, bIterator); // t-Reordering | 2302 bIterator = DeserializeEnum (32,&sel, bIterator); // t-Reordering |
2310 break; | 2303 break; |
2311 } | 2304 } |
2312 | 2305 |
2313 } | 2306 } |
2314 | 2307 |
2315 if (optionalFields[1]) | 2308 if (optionalFields[1]) |
2316 { | 2309 { |
2317 bIterator = DeserializeInteger (&val,3,10,bIterator); | 2310 bIterator = DeserializeInteger (&val,3,10,bIterator); |
2318 drbToAddMod.logicalChannelIdentity = static_cast<uint8_t>(val); | 2311 drbToAddMod.logicalChannelIdentity = static_cast<uint8_t> (val); |
2319 } | 2312 } |
2320 | 2313 |
2321 if (optionalFields[0]) | 2314 if (optionalFields[0]) |
2322 { | 2315 { |
2323 bIterator = DeserializeLogicalChannelConfig (&drbToAddMod.logicalChann
elConfig,bIterator); | 2316 bIterator = DeserializeLogicalChannelConfig (&drbToAddMod.logicalChann
elConfig,bIterator); |
2324 } | 2317 } |
2325 | 2318 |
2326 drbToAddModList->insert (drbToAddModList->end (),drbToAddMod); | 2319 drbToAddModList->insert (drbToAddModList->end (),drbToAddMod); |
2327 } | 2320 } |
2328 return bIterator; | 2321 return bIterator; |
2329 } | 2322 } |
2330 | 2323 |
2331 Buffer::Iterator | 2324 Buffer::Iterator |
2332 RrcAsn1Header::DeserializeLogicalChannelConfig (LteRrcSap::LogicalChannelConfig
*logicalChannelConfig, Buffer::Iterator bIterator) | 2325 RrcAsn1Header::DeserializeLogicalChannelConfig (LteRrcSap::LogicalChannelConfig
*logicalChannelConfig, Buffer::Iterator bIterator) |
2333 { | 2326 { |
2334 int n; | 2327 int n; |
2335 | 2328 |
2336 // Deserialize LogicalChannelConfig sequence | 2329 // Deserialize LogicalChannelConfig sequence |
2337 // 1 optional field, extension marker is present. | 2330 // 1 optional field, extension marker is present. |
2338 std::bitset<1> bitset1; | 2331 std::bitset<1> bitset1; |
2339 bIterator = DeserializeSequence (&bitset1,true,bIterator); | 2332 bIterator = DeserializeSequence (&bitset1,true,bIterator); |
2340 | 2333 |
2341 if (bitset1[0]) | 2334 if (bitset1[0]) |
2342 { | 2335 { |
2343 // Deserialize ul-SpecificParameters sequence | 2336 // Deserialize ul-SpecificParameters sequence |
2344 bIterator = DeserializeSequence (&bitset1,false,bIterator); | 2337 bIterator = DeserializeSequence (&bitset1,false,bIterator); |
2345 | 2338 |
2346 // Deserialize priority | 2339 // Deserialize priority |
2347 bIterator = DeserializeInteger (&n,1,16,bIterator); | 2340 bIterator = DeserializeInteger (&n,1,16,bIterator); |
2348 logicalChannelConfig->priority = static_cast<uint8_t>(n); | 2341 logicalChannelConfig->priority = static_cast<uint8_t> (n); |
2349 | 2342 |
2350 // Deserialize prioritisedBitRate | 2343 // Deserialize prioritisedBitRate |
2351 bIterator = DeserializeEnum (16,&n,bIterator); | 2344 bIterator = DeserializeEnum (16,&n,bIterator); |
2352 uint16_t prioritizedBitRateKbps; | 2345 uint16_t prioritizedBitRateKbps; |
2353 | 2346 |
2354 switch (n) | 2347 switch (n) |
2355 { | 2348 { |
2356 case 0: | 2349 case 0: |
2357 prioritizedBitRateKbps = 0; | 2350 prioritizedBitRateKbps = 0; |
2358 break; | 2351 break; |
(...skipping 48 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2407 break; | 2400 break; |
2408 default: | 2401 default: |
2409 bucketSizeDurationMs = 1000; | 2402 bucketSizeDurationMs = 1000; |
2410 } | 2403 } |
2411 logicalChannelConfig->bucketSizeDurationMs = bucketSizeDurationMs; | 2404 logicalChannelConfig->bucketSizeDurationMs = bucketSizeDurationMs; |
2412 | 2405 |
2413 if (bitset1[0]) | 2406 if (bitset1[0]) |
2414 { | 2407 { |
2415 // Deserialize logicalChannelGroup | 2408 // Deserialize logicalChannelGroup |
2416 bIterator = DeserializeInteger (&n,0,3,bIterator); | 2409 bIterator = DeserializeInteger (&n,0,3,bIterator); |
2417 logicalChannelConfig->logicalChannelGroup = static_cast<uint8_t>(n); | 2410 logicalChannelConfig->logicalChannelGroup = static_cast<uint8_t> (n); |
2418 } | 2411 } |
2419 } | 2412 } |
2420 return bIterator; | 2413 return bIterator; |
2421 } | 2414 } |
2422 | 2415 |
2423 Buffer::Iterator | 2416 Buffer::Iterator |
2424 RrcAsn1Header::DeserializePhysicalConfigDedicated (LteRrcSap::PhysicalConfigDedi
cated *physicalConfigDedicated, Buffer::Iterator bIterator) | 2417 RrcAsn1Header::DeserializePhysicalConfigDedicated (LteRrcSap::PhysicalConfigDedi
cated *physicalConfigDedicated, Buffer::Iterator bIterator) |
2425 { | 2418 { |
2426 std::bitset<10> optionalFieldPresent; | 2419 std::bitset<10> optionalFieldPresent; |
2427 bIterator = DeserializeSequence (&optionalFieldPresent,true,bIterator); | 2420 bIterator = DeserializeSequence (&optionalFieldPresent,true,bIterator); |
2428 | 2421 |
2429 physicalConfigDedicated->havePdschConfigDedicated = optionalFieldPresent[9]; | 2422 physicalConfigDedicated->havePdschConfigDedicated = optionalFieldPresent[9]; |
2430 if (optionalFieldPresent[9]) | 2423 if (optionalFieldPresent[9]) |
2431 { | 2424 { |
2432 // Deserialize pdsch-ConfigDedicated | 2425 // Deserialize pdsch-ConfigDedicated |
2433 std::bitset<0> bitset0; | 2426 std::bitset<0> bitset0; |
2434 bIterator = DeserializeSequence (&bitset0,false,bIterator); | 2427 bIterator = DeserializeSequence (&bitset0,false,bIterator); |
2435 | 2428 |
2436 int slct; | 2429 int slct; |
2437 | 2430 |
2438 // Deserialize p-a | 2431 // Deserialize p-a |
2439 bIterator = DeserializeEnum (8,&slct,bIterator); | 2432 bIterator = DeserializeEnum (8,&slct,bIterator); |
2440 physicalConfigDedicated->pdschConfigDedicated.pa = static_cast<uint8_t>(sl
ct); | 2433 physicalConfigDedicated->pdschConfigDedicated.pa = static_cast<uint8_t> (s
lct); |
2441 | 2434 |
2442 bIterator = DeserializeNull (bIterator); | 2435 bIterator = DeserializeNull (bIterator); |
2443 | 2436 |
2444 } | 2437 } |
2445 if (optionalFieldPresent[8]) | 2438 if (optionalFieldPresent[8]) |
2446 { | 2439 { |
2447 // Deserialize pucch-ConfigDedicated | 2440 // Deserialize pucch-ConfigDedicated |
2448 // ... | 2441 // ... |
2449 } | 2442 } |
2450 if (optionalFieldPresent[7]) | 2443 if (optionalFieldPresent[7]) |
(...skipping 39 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2490 { | 2483 { |
2491 physicalConfigDedicated->soundingRsUlConfigDedicated.type = LteRrcSap:
:SoundingRsUlConfigDedicated::SETUP; | 2484 physicalConfigDedicated->soundingRsUlConfigDedicated.type = LteRrcSap:
:SoundingRsUlConfigDedicated::SETUP; |
2492 | 2485 |
2493 std::bitset<0> bitset0; | 2486 std::bitset<0> bitset0; |
2494 bIterator = DeserializeSequence (&bitset0,false,bIterator); | 2487 bIterator = DeserializeSequence (&bitset0,false,bIterator); |
2495 | 2488 |
2496 int slct; | 2489 int slct; |
2497 | 2490 |
2498 // Deserialize srs-Bandwidth | 2491 // Deserialize srs-Bandwidth |
2499 bIterator = DeserializeEnum (4,&slct,bIterator); | 2492 bIterator = DeserializeEnum (4,&slct,bIterator); |
2500 physicalConfigDedicated->soundingRsUlConfigDedicated.srsBandwidth = st
atic_cast<uint8_t>(slct); | 2493 physicalConfigDedicated->soundingRsUlConfigDedicated.srsBandwidth = st
atic_cast<uint8_t> (slct); |
2501 | 2494 |
2502 // Deserialize srs-HoppingBandwidth | 2495 // Deserialize srs-HoppingBandwidth |
2503 bIterator = DeserializeEnum (4,&slct,bIterator); | 2496 bIterator = DeserializeEnum (4,&slct,bIterator); |
2504 | 2497 |
2505 // Deserialize freqDomainPosition | 2498 // Deserialize freqDomainPosition |
2506 bIterator = DeserializeInteger (&slct,0,23,bIterator); | 2499 bIterator = DeserializeInteger (&slct,0,23,bIterator); |
2507 | 2500 |
2508 // Deserialize duration | 2501 // Deserialize duration |
2509 bool duration; | 2502 bool duration; |
2510 bIterator = DeserializeBoolean (&duration,bIterator); | 2503 bIterator = DeserializeBoolean (&duration,bIterator); |
2511 | 2504 |
2512 // Deserialize srs-ConfigIndex | 2505 // Deserialize srs-ConfigIndex |
2513 bIterator = DeserializeInteger (&slct,0,1023,bIterator); | 2506 bIterator = DeserializeInteger (&slct,0,1023,bIterator); |
2514 physicalConfigDedicated->soundingRsUlConfigDedicated.srsConfigIndex =
static_cast<uint16_t>(slct); | 2507 physicalConfigDedicated->soundingRsUlConfigDedicated.srsConfigIndex =
static_cast<uint16_t> (slct); |
2515 | 2508 |
2516 // Deserialize transmissionComb | 2509 // Deserialize transmissionComb |
2517 bIterator = DeserializeInteger (&slct,0,1,bIterator); | 2510 bIterator = DeserializeInteger (&slct,0,1,bIterator); |
2518 | 2511 |
2519 // Deserialize cyclicShift | 2512 // Deserialize cyclicShift |
2520 bIterator = DeserializeEnum (8,&slct,bIterator); | 2513 bIterator = DeserializeEnum (8,&slct,bIterator); |
2521 } | 2514 } |
2522 } | 2515 } |
2523 physicalConfigDedicated->haveAntennaInfoDedicated = optionalFieldPresent[1]; | 2516 physicalConfigDedicated->haveAntennaInfoDedicated = optionalFieldPresent[1]; |
2524 if (optionalFieldPresent[1]) | 2517 if (optionalFieldPresent[1]) |
2525 { | 2518 { |
2526 // Deserialize antennaInfo | 2519 // Deserialize antennaInfo |
2527 int sel; | 2520 int sel; |
2528 bIterator = DeserializeChoice (2,false,&sel,bIterator); | 2521 bIterator = DeserializeChoice (2,false,&sel,bIterator); |
2529 if (sel == 1) | 2522 if (sel == 1) |
2530 { | 2523 { |
2531 bIterator = DeserializeNull (bIterator); | 2524 bIterator = DeserializeNull (bIterator); |
2532 } | 2525 } |
2533 else if (sel == 0) | 2526 else if (sel == 0) |
2534 { | 2527 { |
2535 std::bitset<1> codebookSubsetRestrictionPresent; | 2528 std::bitset<1> codebookSubsetRestrictionPresent; |
2536 bIterator = DeserializeSequence (&codebookSubsetRestrictionPresent,fal
se,bIterator); | 2529 bIterator = DeserializeSequence (&codebookSubsetRestrictionPresent,fal
se,bIterator); |
2537 | 2530 |
2538 int txmode; | 2531 int txmode; |
2539 bIterator = DeserializeEnum (8,&txmode,bIterator); | 2532 bIterator = DeserializeEnum (8,&txmode,bIterator); |
2540 physicalConfigDedicated->antennaInfo.transmissionMode = static_cast<ui
nt8_t>(txmode); | 2533 physicalConfigDedicated->antennaInfo.transmissionMode = static_cast<ui
nt8_t> (txmode); |
2541 | 2534 |
2542 if (codebookSubsetRestrictionPresent[0]) | 2535 if (codebookSubsetRestrictionPresent[0]) |
2543 { | 2536 { |
2544 // Deserialize codebookSubsetRestriction | 2537 // Deserialize codebookSubsetRestriction |
2545 // ... | 2538 // ... |
2546 } | 2539 } |
2547 | 2540 |
2548 int txantennaselchosen; | 2541 int txantennaselchosen; |
2549 bIterator = DeserializeChoice (2,false,&txantennaselchosen,bIterator); | 2542 bIterator = DeserializeChoice (2,false,&txantennaselchosen,bIterator); |
2550 if (txantennaselchosen == 0) | 2543 if (txantennaselchosen == 0) |
(...skipping 106 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2657 std::bitset<2> radioResourceConfigCommonSCell_r10; | 2650 std::bitset<2> radioResourceConfigCommonSCell_r10; |
2658 bIterator = DeserializeSequence (&radioResourceConfigCommonSCell_r10,false,b
Iterator); | 2651 bIterator = DeserializeSequence (&radioResourceConfigCommonSCell_r10,false,b
Iterator); |
2659 rrccsc->haveNonUlConfiguration = radioResourceConfigCommonSCell_r10[1]; | 2652 rrccsc->haveNonUlConfiguration = radioResourceConfigCommonSCell_r10[1]; |
2660 rrccsc->haveUlConfiguration = radioResourceConfigCommonSCell_r10[0]; | 2653 rrccsc->haveUlConfiguration = radioResourceConfigCommonSCell_r10[0]; |
2661 if (rrccsc->haveNonUlConfiguration) | 2654 if (rrccsc->haveNonUlConfiguration) |
2662 { | 2655 { |
2663 std::bitset<5> nonUlConfiguration_r10; | 2656 std::bitset<5> nonUlConfiguration_r10; |
2664 bIterator = DeserializeSequence (&nonUlConfiguration_r10,false,bIterator
); | 2657 bIterator = DeserializeSequence (&nonUlConfiguration_r10,false,bIterator
); |
2665 int n; | 2658 int n; |
2666 bIterator = DeserializeInteger (&n,6,100,bIterator); | 2659 bIterator = DeserializeInteger (&n,6,100,bIterator); |
2667 rrccsc->nonUlConfiguration.dlBandwidth = static_cast<uint16_t>(n); | 2660 rrccsc->nonUlConfiguration.dlBandwidth = static_cast<uint16_t> (n); |
2668 | 2661 |
2669 std::bitset<1> antennaInfoCommon_r10; | 2662 std::bitset<1> antennaInfoCommon_r10; |
2670 bIterator = DeserializeSequence (&antennaInfoCommon_r10,false,bIterator)
; | 2663 bIterator = DeserializeSequence (&antennaInfoCommon_r10,false,bIterator)
; |
2671 bIterator = DeserializeInteger (&n,0,65536,bIterator); | 2664 bIterator = DeserializeInteger (&n,0,65536,bIterator); |
2672 rrccsc->nonUlConfiguration.antennaInfoCommon.antennaPortsCount = static_
cast<uint16_t>(n); | 2665 rrccsc->nonUlConfiguration.antennaInfoCommon.antennaPortsCount = static_
cast<uint16_t> (n); |
2673 | 2666 |
2674 std::bitset<2> pdschConfigCommon_r10; | 2667 std::bitset<2> pdschConfigCommon_r10; |
2675 bIterator = DeserializeSequence (&pdschConfigCommon_r10,false,bIterator)
; | 2668 bIterator = DeserializeSequence (&pdschConfigCommon_r10,false,bIterator)
; |
2676 bIterator = DeserializeInteger (&n,-60,50,bIterator); | 2669 bIterator = DeserializeInteger (&n,-60,50,bIterator); |
2677 rrccsc->nonUlConfiguration.pdschConfigCommon.referenceSignalPower = stat
ic_cast<int8_t>(n); | 2670 rrccsc->nonUlConfiguration.pdschConfigCommon.referenceSignalPower = stat
ic_cast<int8_t>(n); |
2678 bIterator = DeserializeInteger (&n,0,3,bIterator); | 2671 bIterator = DeserializeInteger (&n,0,3,bIterator); |
2679 rrccsc->nonUlConfiguration.pdschConfigCommon.pb = static_cast<int8_t>(n)
; | 2672 rrccsc->nonUlConfiguration.pdschConfigCommon.pb = static_cast<int8_t>(n)
; |
2680 } | 2673 } |
2681 if (rrccsc->haveUlConfiguration) | 2674 if (rrccsc->haveUlConfiguration) |
2682 { | 2675 { |
2683 std::bitset<7> UlConfiguration_r10; | 2676 std::bitset<7> UlConfiguration_r10; |
2684 bIterator = DeserializeSequence (&UlConfiguration_r10,true,bIterator); | 2677 bIterator = DeserializeSequence (&UlConfiguration_r10,true,bIterator); |
2685 ········ | 2678 ········ |
2686 std::bitset<3> FreqInfo_r10; | 2679 std::bitset<3> FreqInfo_r10; |
2687 bIterator = DeserializeSequence (&FreqInfo_r10,false,bIterator); | 2680 bIterator = DeserializeSequence (&FreqInfo_r10,false,bIterator); |
2688 int n; | 2681 int n; |
2689 bIterator = DeserializeInteger (&n,0,MAX_EARFCN,bIterator); | 2682 bIterator = DeserializeInteger (&n,0,MAX_EARFCN,bIterator); |
2690 rrccsc->ulConfiguration.ulFreqInfo.ulCarrierFreq = n; | 2683 rrccsc->ulConfiguration.ulFreqInfo.ulCarrierFreq = n; |
2691 bIterator = DeserializeInteger (&n,6,100,bIterator); | 2684 bIterator = DeserializeInteger (&n,6,100,bIterator); |
2692 rrccsc->ulConfiguration.ulFreqInfo.ulBandwidth = static_cast<int8_t>(n); | 2685 rrccsc->ulConfiguration.ulFreqInfo.ulBandwidth = static_cast<int8_t>(n); |
2693 | 2686 |
2694 std::bitset<2> UlPowerControlCommonSCell_r10; | 2687 std::bitset<2> UlPowerControlCommonSCell_r10; |
2695 bIterator = DeserializeSequence (&UlPowerControlCommonSCell_r10,false,bI
terator); | 2688 bIterator = DeserializeSequence (&UlPowerControlCommonSCell_r10,false,bI
terator); |
2696 bIterator = DeserializeInteger (&n,0,65536,bIterator); | 2689 bIterator = DeserializeInteger (&n,0,65536,bIterator); |
2697 rrccsc->ulConfiguration.ulPowerControlCommonSCell.alpha = static_cast<ui
nt16_t>(n); | 2690 rrccsc->ulConfiguration.ulPowerControlCommonSCell.alpha = static_cast<ui
nt16_t> (n); |
2698 ········· | 2691 ········· |
2699 std::bitset<1> prachConfigSCell_r10; | 2692 std::bitset<1> prachConfigSCell_r10; |
2700 bIterator = DeserializeSequence (&prachConfigSCell_r10,false,bIterator); | 2693 bIterator = DeserializeSequence (&prachConfigSCell_r10,false,bIterator); |
2701 bIterator = DeserializeInteger (&n,0,256,bIterator); | 2694 bIterator = DeserializeInteger (&n,0,256,bIterator); |
2702 rrccsc->ulConfiguration.prachConfigSCell.index = static_cast<uint16_t>(n
); | 2695 rrccsc->ulConfiguration.prachConfigSCell.index = static_cast<uint16_t> (
n); |
2703 }···· | 2696 }···· |
2704 ···· | 2697 ···· |
2705 return bIterator; | 2698 return bIterator; |
2706 } | 2699 } |
2707 | 2700 |
2708 Buffer::Iterator· | 2701 Buffer::Iterator· |
2709 RrcAsn1Header::DeserializeRadioResourceConfigDedicatedSCell (LteRrcSap::RadioR
esourceConfigDedicatedSCell *rrcdsc, Buffer::Iterator bIterator) | 2702 RrcAsn1Header::DeserializeRadioResourceConfigDedicatedSCell (LteRrcSap::RadioR
esourceConfigDedicatedSCell *rrcdsc, Buffer::Iterator bIterator) |
2710 { | 2703 { |
2711 NS_LOG_FUNCTION (this); | 2704 NS_LOG_FUNCTION (this); |
2712 std::bitset<1> RadioResourceConfigDedicatedSCell_r10; | 2705 std::bitset<1> RadioResourceConfigDedicatedSCell_r10; |
(...skipping 29 matching lines...) Expand all Loading... |
2742 { | 2735 { |
2743 bIterator = DeserializeNull (bIterator); | 2736 bIterator = DeserializeNull (bIterator); |
2744 } | 2737 } |
2745 else if (sel == 0) | 2738 else if (sel == 0) |
2746 { | 2739 { |
2747 std::bitset<1> codebookSubsetRestrictionPresent; | 2740 std::bitset<1> codebookSubsetRestrictionPresent; |
2748 bIterator = DeserializeSequence (&codebookSubsetRestrictionPres
ent,false,bIterator); | 2741 bIterator = DeserializeSequence (&codebookSubsetRestrictionPres
ent,false,bIterator); |
2749 | 2742 |
2750 int txmode; | 2743 int txmode; |
2751 bIterator = DeserializeEnum (8,&txmode,bIterator); | 2744 bIterator = DeserializeEnum (8,&txmode,bIterator); |
2752 pcdsc->antennaInfo.transmissionMode = static_cast<uint8_t>(txmo
de); | 2745 pcdsc->antennaInfo.transmissionMode = static_cast<uint8_t> (txm
ode); |
2753 | 2746 |
2754 if (codebookSubsetRestrictionPresent[0]) | 2747 if (codebookSubsetRestrictionPresent[0]) |
2755 { | 2748 { |
2756 // Deserialize codebookSubsetRestriction | 2749 // Deserialize codebookSubsetRestriction |
2757 NS_FATAL_ERROR ("Not implemented yet"); | 2750 NS_FATAL_ERROR ("Not implemented yet"); |
2758 // ... | 2751 // ... |
2759 } | 2752 } |
2760 | 2753 |
2761 int txantennaselchosen; | 2754 int txantennaselchosen; |
2762 bIterator = DeserializeChoice (2,false,&txantennaselchosen,bIte
rator); | 2755 bIterator = DeserializeChoice (2,false,&txantennaselchosen,bIte
rator); |
(...skipping 13 matching lines...) Expand all Loading... |
2776 if (pcdsc->havePdschConfigDedicated) | 2769 if (pcdsc->havePdschConfigDedicated) |
2777 { | 2770 { |
2778 // Deserialize pdsch-ConfigDedicated | 2771 // Deserialize pdsch-ConfigDedicated |
2779 std::bitset<0> bitset0; | 2772 std::bitset<0> bitset0; |
2780 bIterator = DeserializeSequence (&bitset0,false,bIterator); | 2773 bIterator = DeserializeSequence (&bitset0,false,bIterator); |
2781 | 2774 |
2782 int slct; | 2775 int slct; |
2783 | 2776 |
2784 // Deserialize p-a | 2777 // Deserialize p-a |
2785 bIterator = DeserializeEnum (8,&slct,bIterator); | 2778 bIterator = DeserializeEnum (8,&slct,bIterator); |
2786 pcdsc->pdschConfigDedicated.pa = static_cast<uint8_t>(slct); | 2779 pcdsc->pdschConfigDedicated.pa = static_cast<uint8_t> (slct); |
2787 | 2780 |
2788 bIterator = DeserializeNull (bIterator); | 2781 bIterator = DeserializeNull (bIterator); |
2789 } | 2782 } |
2790 ········ | 2783 ········ |
2791 } | 2784 } |
2792 if (pcdsc->haveUlConfiguration) | 2785 if (pcdsc->haveUlConfiguration) |
2793 { | 2786 { |
2794 std::bitset<7> ulOpt; | 2787 std::bitset<7> ulOpt; |
2795 bIterator = DeserializeSequence (&ulOpt,false,bIterator); | 2788 bIterator = DeserializeSequence (&ulOpt,false,bIterator); |
2796 pcdsc->haveAntennaInfoUlDedicated = ulOpt[6]; | 2789 pcdsc->haveAntennaInfoUlDedicated = ulOpt[6]; |
(...skipping 13 matching lines...) Expand all Loading... |
2810 { | 2803 { |
2811 bIterator = DeserializeNull (bIterator); | 2804 bIterator = DeserializeNull (bIterator); |
2812 } | 2805 } |
2813 else if (sel == 0) | 2806 else if (sel == 0) |
2814 { | 2807 { |
2815 std::bitset<1> codebookSubsetRestrictionPresent; | 2808 std::bitset<1> codebookSubsetRestrictionPresent; |
2816 bIterator = DeserializeSequence (&codebookSubsetRestrictionPres
ent,false,bIterator); | 2809 bIterator = DeserializeSequence (&codebookSubsetRestrictionPres
ent,false,bIterator); |
2817 | 2810 |
2818 int txmode; | 2811 int txmode; |
2819 bIterator = DeserializeEnum (8,&txmode,bIterator); | 2812 bIterator = DeserializeEnum (8,&txmode,bIterator); |
2820 pcdsc->antennaInfo.transmissionMode = static_cast<uint8_t>(txmo
de); | 2813 pcdsc->antennaInfo.transmissionMode = static_cast<uint8_t> (txm
ode); |
2821 | 2814 |
2822 if (codebookSubsetRestrictionPresent[0]) | 2815 if (codebookSubsetRestrictionPresent[0]) |
2823 { | 2816 { |
2824 // Deserialize codebookSubsetRestriction | 2817 // Deserialize codebookSubsetRestriction |
2825 NS_FATAL_ERROR ("Not implemented yet"); | 2818 NS_FATAL_ERROR ("Not implemented yet"); |
2826 // ... | 2819 // ... |
2827 } | 2820 } |
2828 | 2821 |
2829 int txantennaselchosen; | 2822 int txantennaselchosen; |
2830 bIterator = DeserializeChoice (2,false,&txantennaselchosen,bIte
rator); | 2823 bIterator = DeserializeChoice (2,false,&txantennaselchosen,bIte
rator); |
(...skipping 27 matching lines...) Expand all Loading... |
2858 { | 2851 { |
2859 pcdsc->soundingRsUlConfigDedicated.type = LteRrcSap::SoundingRs
UlConfigDedicated::SETUP; | 2852 pcdsc->soundingRsUlConfigDedicated.type = LteRrcSap::SoundingRs
UlConfigDedicated::SETUP; |
2860 | 2853 |
2861 std::bitset<0> bitset0; | 2854 std::bitset<0> bitset0; |
2862 bIterator = DeserializeSequence (&bitset0,false,bIterator); | 2855 bIterator = DeserializeSequence (&bitset0,false,bIterator); |
2863 | 2856 |
2864 int slct; | 2857 int slct; |
2865 | 2858 |
2866 // Deserialize srs-Bandwidth | 2859 // Deserialize srs-Bandwidth |
2867 bIterator = DeserializeEnum (4,&slct,bIterator); | 2860 bIterator = DeserializeEnum (4,&slct,bIterator); |
2868 pcdsc->soundingRsUlConfigDedicated.srsBandwidth = static_cast<u
int8_t>(slct); | 2861 pcdsc->soundingRsUlConfigDedicated.srsBandwidth = static_cast<u
int8_t> (slct); |
2869 | 2862 |
2870 // Deserialize srs-HoppingBandwidth | 2863 // Deserialize srs-HoppingBandwidth |
2871 bIterator = DeserializeEnum (4,&slct,bIterator); | 2864 bIterator = DeserializeEnum (4,&slct,bIterator); |
2872 | 2865 |
2873 // Deserialize freqDomainPosition | 2866 // Deserialize freqDomainPosition |
2874 bIterator = DeserializeInteger (&slct,0,23,bIterator); | 2867 bIterator = DeserializeInteger (&slct,0,23,bIterator); |
2875 | 2868 |
2876 // Deserialize duration | 2869 // Deserialize duration |
2877 bool duration; | 2870 bool duration; |
2878 bIterator = DeserializeBoolean (&duration,bIterator); | 2871 bIterator = DeserializeBoolean (&duration,bIterator); |
2879 | 2872 |
2880 // Deserialize srs-ConfigIndex | 2873 // Deserialize srs-ConfigIndex |
2881 bIterator = DeserializeInteger (&slct,0,1023,bIterator); | 2874 bIterator = DeserializeInteger (&slct,0,1023,bIterator); |
2882 pcdsc->soundingRsUlConfigDedicated.srsConfigIndex = static_cast
<uint16_t>(slct); | 2875 pcdsc->soundingRsUlConfigDedicated.srsConfigIndex = static_cast
<uint16_t> (slct); |
2883 | 2876 |
2884 // Deserialize transmissionComb | 2877 // Deserialize transmissionComb |
2885 bIterator = DeserializeInteger (&slct,0,1,bIterator); | 2878 bIterator = DeserializeInteger (&slct,0,1,bIterator); |
2886 | 2879 |
2887 // Deserialize cyclicShift | 2880 // Deserialize cyclicShift |
2888 bIterator = DeserializeEnum (8,&slct,bIterator); | 2881 bIterator = DeserializeEnum (8,&slct,bIterator); |
2889 } | 2882 } |
2890 } | 2883 } |
2891 | 2884 |
2892 | 2885 |
(...skipping 200 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
3093 if (freqInfoOpts[1]) | 3086 if (freqInfoOpts[1]) |
3094 { | 3087 { |
3095 // Deserialize ul-CarrierFreq | 3088 // Deserialize ul-CarrierFreq |
3096 bIterator = DeserializeInteger (&n, 0, MAX_EARFCN, bIterator); | 3089 bIterator = DeserializeInteger (&n, 0, MAX_EARFCN, bIterator); |
3097 systemInformationBlockType2->freqInfo.ulCarrierFreq = n; | 3090 systemInformationBlockType2->freqInfo.ulCarrierFreq = n; |
3098 } | 3091 } |
3099 if (freqInfoOpts[0]) | 3092 if (freqInfoOpts[0]) |
3100 { | 3093 { |
3101 // Deserialize ul-Bandwidth | 3094 // Deserialize ul-Bandwidth |
3102 bIterator = DeserializeEnum (6, &n, bIterator); | 3095 bIterator = DeserializeEnum (6, &n, bIterator); |
3103 switch (n) | 3096 systemInformationBlockType2->freqInfo.ulBandwidth = EnumToBandwidth (n); |
3104 { | |
3105 case 0: | |
3106 systemInformationBlockType2->freqInfo.ulBandwidth = 6; | |
3107 break; | |
3108 case 1: | |
3109 systemInformationBlockType2->freqInfo.ulBandwidth = 15; | |
3110 break; | |
3111 case 2: | |
3112 systemInformationBlockType2->freqInfo.ulBandwidth = 25; | |
3113 break; | |
3114 case 3: | |
3115 systemInformationBlockType2->freqInfo.ulBandwidth = 50; | |
3116 break; | |
3117 case 4: | |
3118 systemInformationBlockType2->freqInfo.ulBandwidth = 75; | |
3119 break; | |
3120 case 5: | |
3121 systemInformationBlockType2->freqInfo.ulBandwidth = 100; | |
3122 break; | |
3123 default: | |
3124 systemInformationBlockType2->freqInfo.ulBandwidth = 6; | |
3125 } | |
3126 } | 3097 } |
3127 | 3098 |
3128 // additionalSpectrumEmission | 3099 // additionalSpectrumEmission |
3129 bIterator = DeserializeInteger (&n,1,32,bIterator); | 3100 bIterator = DeserializeInteger (&n,1,32,bIterator); |
3130 | 3101 |
3131 if (sysInfoBlkT2Opts[0]) | 3102 if (sysInfoBlkT2Opts[0]) |
3132 { | 3103 { |
3133 // Deserialize mbsfn-SubframeConfigList | 3104 // Deserialize mbsfn-SubframeConfigList |
3134 // ... | 3105 // ... |
3135 } | 3106 } |
(...skipping 180 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
3316 case 13: | 3287 case 13: |
3317 rachConfigCommon->preambleInfo.numberOfRaPreambles = 56; | 3288 rachConfigCommon->preambleInfo.numberOfRaPreambles = 56; |
3318 break; | 3289 break; |
3319 case 14: | 3290 case 14: |
3320 rachConfigCommon->preambleInfo.numberOfRaPreambles = 60; | 3291 rachConfigCommon->preambleInfo.numberOfRaPreambles = 60; |
3321 break; | 3292 break; |
3322 case 15: | 3293 case 15: |
3323 rachConfigCommon->preambleInfo.numberOfRaPreambles = 64; | 3294 rachConfigCommon->preambleInfo.numberOfRaPreambles = 64; |
3324 break; | 3295 break; |
3325 default: | 3296 default: |
3326 rachConfigCommon->preambleInfo.numberOfRaPreambles = 0; | 3297 rachConfigCommon->preambleInfo.numberOfRaPreambles = 4; |
3327 } | 3298 } |
3328 | |
3329 rachConfigCommon->preambleInfo.numberOfRaPreambles = static_cast<uint8_t>(n); | |
3330 | 3299 |
3331 if (preamblesGroupAConfigPresent[0]) | 3300 if (preamblesGroupAConfigPresent[0]) |
3332 { | 3301 { |
3333 // Deserialize preamblesGroupAConfig | 3302 // Deserialize preamblesGroupAConfig |
3334 // ... | 3303 // ... |
3335 } | 3304 } |
3336 | 3305 |
3337 // powerRampingParameters | 3306 // powerRampingParameters |
3338 bIterator = DeserializeSequence (&bitset0,false,bIterator); | 3307 bIterator = DeserializeSequence (&bitset0,false,bIterator); |
3339 bIterator = DeserializeEnum (4,&n,bIterator); // powerRampingStep | 3308 bIterator = DeserializeEnum (4,&n,bIterator); // powerRampingStep |
(...skipping 191 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
3531 RrcAsn1Header::DeserializeMeasResults (LteRrcSap::MeasResults *measResults, Buff
er::Iterator bIterator) | 3500 RrcAsn1Header::DeserializeMeasResults (LteRrcSap::MeasResults *measResults, Buff
er::Iterator bIterator) |
3532 { | 3501 { |
3533 int n; | 3502 int n; |
3534 std::bitset<0> b0; | 3503 std::bitset<0> b0; |
3535 std::bitset<4> measResultOptionalPresent; | 3504 std::bitset<4> measResultOptionalPresent; |
3536 // bIterator = DeserializeSequence (&measResultNeighCellsPresent,true,bIter
ator); | 3505 // bIterator = DeserializeSequence (&measResultNeighCellsPresent,true,bIter
ator); |
3537 bIterator = DeserializeSequence (&measResultOptionalPresent,true,bIterator); | 3506 bIterator = DeserializeSequence (&measResultOptionalPresent,true,bIterator); |
3538 | 3507 |
3539 // Deserialize measId | 3508 // Deserialize measId |
3540 bIterator = DeserializeInteger (&n, 1, MAX_MEAS_ID, bIterator); | 3509 bIterator = DeserializeInteger (&n, 1, MAX_MEAS_ID, bIterator); |
3541 measResults->measId = static_cast<uint8_t>(n); | 3510 measResults->measId = static_cast<uint8_t> (n); |
3542 | 3511 |
3543 // Deserialize measResultServCell | 3512 // Deserialize measResultServCell |
3544 bIterator = DeserializeSequence (&b0,false,bIterator); | 3513 bIterator = DeserializeSequence (&b0,false,bIterator); |
3545 | 3514 |
3546 // Deserialize rsrpResult | 3515 // Deserialize rsrpResult |
3547 bIterator = DeserializeInteger (&n, 0, 97, bIterator); | 3516 bIterator = DeserializeInteger (&n, 0, 97, bIterator); |
3548 measResults->rsrpResult = static_cast<uint8_t>(n); | 3517 measResults->rsrpResult = static_cast<uint8_t> (n); |
3549 | 3518 |
3550 // Deserialize rsrqResult | 3519 // Deserialize rsrqResult |
3551 bIterator = DeserializeInteger (&n, 0, 34, bIterator); | 3520 bIterator = DeserializeInteger (&n, 0, 34, bIterator); |
3552 measResults->rsrqResult = static_cast<uint8_t>(n); | 3521 measResults->rsrqResult = static_cast<uint8_t> (n); |
3553 | 3522 |
3554 measResults->haveMeasResultNeighCells = measResultOptionalPresent[0]; | 3523 measResults->haveMeasResultNeighCells = measResultOptionalPresent[0]; |
3555 measResults->haveScellsMeas = measResultOptionalPresent[3]; | 3524 measResults->haveScellsMeas = measResultOptionalPresent[3]; |
3556 if ( measResults->haveMeasResultNeighCells) | 3525 if ( measResults->haveMeasResultNeighCells) |
3557 { | 3526 { |
3558 int measResultNeighCellsChoice; | 3527 int measResultNeighCellsChoice; |
3559 | 3528 |
3560 // Deserialize measResultNeighCells | 3529 // Deserialize measResultNeighCells |
3561 bIterator = DeserializeChoice (4,false,&measResultNeighCellsChoice,bIterat
or); | 3530 bIterator = DeserializeChoice (4,false,&measResultNeighCellsChoice,bIterat
or); |
3562 | 3531 |
3563 if (measResultNeighCellsChoice == 0) | 3532 if (measResultNeighCellsChoice == 0) |
3564 { | 3533 { |
3565 // Deserialize measResultListEUTRA | 3534 // Deserialize measResultListEUTRA |
3566 int numElems; | 3535 int numElems; |
3567 bIterator = DeserializeSequenceOf (&numElems,MAX_CELL_REPORT,1,bIterat
or); | 3536 bIterator = DeserializeSequenceOf (&numElems,MAX_CELL_REPORT,1,bIterat
or); |
3568 | 3537 |
3569 for (int i = 0; i < numElems; i++) | 3538 for (int i = 0; i < numElems; i++) |
3570 { | 3539 { |
3571 LteRrcSap::MeasResultEutra measResultEutra; | 3540 LteRrcSap::MeasResultEutra measResultEutra; |
3572 | 3541 |
3573 std::bitset<1> isCgiInfoPresent; | 3542 std::bitset<1> isCgiInfoPresent; |
3574 bIterator = DeserializeSequence (&isCgiInfoPresent,false,bIterator
); | 3543 bIterator = DeserializeSequence (&isCgiInfoPresent,false,bIterator
); |
3575 | 3544 |
3576 // PhysCellId | 3545 // PhysCellId |
3577 bIterator = DeserializeInteger (&n,0,503,bIterator); | 3546 bIterator = DeserializeInteger (&n,0,503,bIterator); |
3578 measResultEutra.physCellId = static_cast<uint16_t>(n); | 3547 measResultEutra.physCellId = static_cast<uint16_t> (n); |
3579 | 3548 |
3580 measResultEutra.haveCgiInfo = isCgiInfoPresent[0]; | 3549 measResultEutra.haveCgiInfo = isCgiInfoPresent[0]; |
3581 if (isCgiInfoPresent[0]) | 3550 if (isCgiInfoPresent[0]) |
3582 { | 3551 { |
3583 std::bitset<1> havePlmnIdentityList; | 3552 std::bitset<1> havePlmnIdentityList; |
3584 bIterator = DeserializeSequence (&havePlmnIdentityList,false,b
Iterator); | 3553 bIterator = DeserializeSequence (&havePlmnIdentityList,false,b
Iterator); |
3585 | 3554 |
3586 // Deserialize cellGlobalId | 3555 // Deserialize cellGlobalId |
3587 bIterator = DeserializeSequence (&b0,false,bIterator); | 3556 bIterator = DeserializeSequence (&b0,false,bIterator); |
3588 | 3557 |
3589 // Deserialize plmn-Identity | 3558 // Deserialize plmn-Identity |
3590 bIterator = DeserializePlmnIdentity (&measResultEutra.cgiInfo.
plmnIdentity,bIterator); | 3559 bIterator = DeserializePlmnIdentity (&measResultEutra.cgiInfo.
plmnIdentity,bIterator); |
3591 | 3560 |
3592 // Deserialize CellIdentity | 3561 // Deserialize CellIdentity |
3593 std::bitset<28> cellId; | 3562 std::bitset<28> cellId; |
3594 bIterator = DeserializeBitstring (&cellId,bIterator); | 3563 bIterator = DeserializeBitstring (&cellId,bIterator); |
3595 measResultEutra.cgiInfo.cellIdentity = cellId.to_ulong (); | 3564 measResultEutra.cgiInfo.cellIdentity = cellId.to_ulong (); |
3596 | 3565 |
3597 // Deserialize trackingAreaCode | 3566 // Deserialize trackingAreaCode |
3598 std::bitset<16> trArCo; | 3567 std::bitset<16> trArCo; |
3599 bIterator = DeserializeBitstring (&trArCo,bIterator); | 3568 bIterator = DeserializeBitstring (&trArCo,bIterator); |
3600 measResultEutra.cgiInfo.trackingAreaCode = static_cast<uint16_
t>(trArCo.to_ulong ()); | 3569 measResultEutra.cgiInfo.trackingAreaCode = static_cast<uint16_
t> (trArCo.to_ulong ()); |
3601 | 3570 |
3602 // Deserialize plmn-IdentityList | 3571 // Deserialize plmn-IdentityList |
3603 if (havePlmnIdentityList[0]) | 3572 if (havePlmnIdentityList[0]) |
3604 { | 3573 { |
3605 int numPlmnElems; | 3574 int numPlmnElems; |
3606 bIterator = DeserializeSequenceOf (&numPlmnElems, 5, 1, bI
terator); | 3575 bIterator = DeserializeSequenceOf (&numPlmnElems, 5, 1, bI
terator); |
3607 | 3576 |
3608 for ( int j = 0; j < numPlmnElems; j++) | 3577 for ( int j = 0; j < numPlmnElems; j++) |
3609 { | 3578 { |
3610 uint32_t plmnId; | 3579 uint32_t plmnId; |
3611 bIterator = DeserializePlmnIdentity (&plmnId,bIterator
); | 3580 bIterator = DeserializePlmnIdentity (&plmnId,bIterator
); |
3612 measResultEutra.cgiInfo.plmnIdentityList.push_back (pl
mnId); | 3581 measResultEutra.cgiInfo.plmnIdentityList.push_back (pl
mnId); |
3613 } | 3582 } |
3614 } | 3583 } |
3615 } | 3584 } |
3616 | 3585 |
3617 // Deserialize measResult | 3586 // Deserialize measResult |
3618 std::bitset<2> measResultOpts; | 3587 std::bitset<2> measResultOpts; |
3619 bIterator = DeserializeSequence (&measResultOpts, true, bIterator)
; | 3588 bIterator = DeserializeSequence (&measResultOpts, true, bIterator)
; |
3620 | 3589 |
3621 measResultEutra.haveRsrpResult = measResultOpts[1]; | 3590 measResultEutra.haveRsrpResult = measResultOpts[1]; |
3622 if (measResultOpts[1]) | 3591 if (measResultOpts[1]) |
3623 { | 3592 { |
3624 // Deserialize rsrpResult | 3593 // Deserialize rsrpResult |
3625 bIterator = DeserializeInteger (&n,0,97,bIterator); | 3594 bIterator = DeserializeInteger (&n,0,97,bIterator); |
3626 measResultEutra.rsrpResult = static_cast<uint8_t>(n); | 3595 measResultEutra.rsrpResult = static_cast<uint8_t> (n); |
3627 } | 3596 } |
3628 | 3597 |
3629 measResultEutra.haveRsrqResult = measResultOpts[0]; | 3598 measResultEutra.haveRsrqResult = measResultOpts[0]; |
3630 if (measResultOpts[0]) | 3599 if (measResultOpts[0]) |
3631 { | 3600 { |
3632 // Deserialize rsrqResult | 3601 // Deserialize rsrqResult |
3633 bIterator = DeserializeInteger (&n,0,34,bIterator); | 3602 bIterator = DeserializeInteger (&n,0,34,bIterator); |
3634 measResultEutra.rsrqResult = static_cast<uint8_t>(n); | 3603 measResultEutra.rsrqResult = static_cast<uint8_t> (n); |
3635 } | 3604 } |
3636 | 3605 |
3637 measResults->measResultListEutra.push_back (measResultEutra); | 3606 measResults->measResultListEutra.push_back (measResultEutra); |
3638 } | 3607 } |
3639 } | 3608 } |
3640 | 3609 |
3641 if (measResultNeighCellsChoice == 1) | 3610 if (measResultNeighCellsChoice == 1) |
3642 { | 3611 { |
3643 // Deserialize measResultListUTRA | 3612 // Deserialize measResultListUTRA |
3644 // ... | 3613 // ... |
(...skipping 14 matching lines...) Expand all Loading... |
3659 { | 3628 { |
3660 | 3629 |
3661 int numElems; | 3630 int numElems; |
3662 bIterator = DeserializeSequenceOf (&numElems,MAX_SCELL_REPORT,1,bIterato
r); | 3631 bIterator = DeserializeSequenceOf (&numElems,MAX_SCELL_REPORT,1,bIterato
r); |
3663 for (int i = 0; i < numElems; i++) | 3632 for (int i = 0; i < numElems; i++) |
3664 { | 3633 { |
3665 LteRrcSap::MeasResultScell measResultScell; | 3634 LteRrcSap::MeasResultScell measResultScell; |
3666 int measScellId; | 3635 int measScellId; |
3667 // Deserialize measId | 3636 // Deserialize measId |
3668 bIterator = DeserializeInteger (&measScellId, 1,MAX_SCELL_REPORT,bIt
erator); | 3637 bIterator = DeserializeInteger (&measScellId, 1,MAX_SCELL_REPORT,bIt
erator); |
3669 measResultScell.servFreqId = static_cast<uint16_t>(measScellId); | 3638 measResultScell.servFreqId = static_cast<uint16_t> (measScellId); |
3670 std::bitset<2> measResultScellPresent; | 3639 std::bitset<2> measResultScellPresent; |
3671 bIterator = DeserializeSequence (&measResultScellPresent,true,bItera
tor); | 3640 bIterator = DeserializeSequence (&measResultScellPresent,true,bItera
tor); |
3672 measResults->measScellResultList.haveMeasurementResultsServingSCells
= measResultScellPresent[0]; | 3641 measResults->measScellResultList.haveMeasurementResultsServingSCells
= measResultScellPresent[0]; |
3673 measResults->measScellResultList.haveMeasurementResultsNeighCell = me
asResultScellPresent[1]; | 3642 measResults->measScellResultList.haveMeasurementResultsNeighCell = me
asResultScellPresent[1]; |
3674 if (measResults->measScellResultList.haveMeasurementResultsServingSCe
lls) | 3643 if (measResults->measScellResultList.haveMeasurementResultsServingSCe
lls) |
3675 { | 3644 { |
3676 // Deserialize measResult | 3645 // Deserialize measResult |
3677 std::bitset<2> measResultOpts; | 3646 std::bitset<2> measResultOpts; |
3678 bIterator = DeserializeSequence (&measResultOpts, true, bIterator
); | 3647 bIterator = DeserializeSequence (&measResultOpts, true, bIterator
); |
3679 | 3648 |
3680 measResultScell.haveRsrpResult = measResultOpts[1]; | 3649 measResultScell.haveRsrpResult = measResultOpts[1]; |
3681 if (measResultOpts[1]) | 3650 if (measResultOpts[1]) |
3682 { | 3651 { |
3683 // Deserialize rsrpResult | 3652 // Deserialize rsrpResult |
3684 bIterator = DeserializeInteger (&n,0,97,bIterator); | 3653 bIterator = DeserializeInteger (&n,0,97,bIterator); |
3685 measResultScell.rsrpResult = static_cast<uint8_t>(n); | 3654 measResultScell.rsrpResult = static_cast<uint8_t> (n); |
3686 } | 3655 } |
3687 | 3656 |
3688 measResultScell.haveRsrqResult = measResultOpts[0]; | 3657 measResultScell.haveRsrqResult = measResultOpts[0]; |
3689 if (measResultOpts[0]) | 3658 if (measResultOpts[0]) |
3690 { | 3659 { |
3691 // Deserialize rsrqResult | 3660 // Deserialize rsrqResult |
3692 bIterator = DeserializeInteger (&n,0,34,bIterator); | 3661 bIterator = DeserializeInteger (&n,0,34,bIterator); |
3693 measResultScell.rsrqResult = static_cast<uint8_t>(n); | 3662 measResultScell.rsrqResult = static_cast<uint8_t> (n); |
3694 } | 3663 } |
3695 } | 3664 } |
3696 if (measResults->measScellResultList.haveMeasurementResultsNeighCell) | 3665 if (measResults->measScellResultList.haveMeasurementResultsNeighCell) |
3697 { | 3666 { |
3698 // Deserialize measResultBestNeighCell | 3667 // Deserialize measResultBestNeighCell |
3699 } | 3668 } |
3700 measResults->measScellResultList.measResultScell.push_back (measResul
tScell); | 3669 measResults->measScellResultList.measResultScell.push_back (measResul
tScell); |
3701 } | 3670 } |
3702 ········ | 3671 ········ |
3703 } | 3672 } |
(...skipping 14 matching lines...) Expand all Loading... |
3718 } | 3687 } |
3719 | 3688 |
3720 // Deserialize mnc | 3689 // Deserialize mnc |
3721 int mncDigits; | 3690 int mncDigits; |
3722 int mnc = 0; | 3691 int mnc = 0; |
3723 bIterator = DeserializeSequenceOf (&mncDigits,3,2,bIterator); | 3692 bIterator = DeserializeSequenceOf (&mncDigits,3,2,bIterator); |
3724 | 3693 |
3725 for (int j = mncDigits - 1; j >= 0; j--) | 3694 for (int j = mncDigits - 1; j >= 0; j--) |
3726 { | 3695 { |
3727 bIterator = DeserializeInteger (&n,0,9,bIterator); | 3696 bIterator = DeserializeInteger (&n,0,9,bIterator); |
3728 mnc += static_cast<int>(n * pow (10,j)); | 3697 mnc += static_cast<int> (n * pow (10,j)); |
3729 } | 3698 } |
3730 | 3699 |
3731 *plmnId = mnc; | 3700 *plmnId = mnc; |
3732 | 3701 |
3733 // cellReservedForOperatorUse | 3702 // cellReservedForOperatorUse |
3734 bIterator = DeserializeEnum (2,&n,bIterator); | 3703 bIterator = DeserializeEnum (2,&n,bIterator); |
3735 return bIterator; | 3704 return bIterator; |
3736 } | 3705 } |
3737 | 3706 |
3738 Buffer::Iterator | 3707 Buffer::Iterator |
3739 RrcAsn1Header::DeserializeMeasConfig (LteRrcSap::MeasConfig * measConfig, Buffer
::Iterator bIterator) | 3708 RrcAsn1Header::DeserializeMeasConfig (LteRrcSap::MeasConfig * measConfig, Buffer
::Iterator bIterator) |
3740 { | 3709 { |
3741 std::bitset<0> bitset0; | 3710 std::bitset<0> bitset0; |
3742 std::bitset<2> bitset2; | 3711 std::bitset<2> bitset2; |
3743 std::bitset<11> bitset11; | 3712 std::bitset<11> bitset11; |
3744 int n; | 3713 int n; |
3745 | 3714 |
3746 // measConfig | 3715 // measConfig |
3747 bIterator = DeserializeSequence (&bitset11,true,bIterator); | 3716 bIterator = DeserializeSequence (&bitset11,true,bIterator); |
3748 | 3717 |
3749 if (bitset11[10]) | 3718 if (bitset11[10]) |
3750 { | 3719 { |
3751 // measObjectToRemoveList | 3720 // measObjectToRemoveList |
3752 int measObjectToRemoveListElems; | 3721 int measObjectToRemoveListElems; |
3753 bIterator = DeserializeSequenceOf (&measObjectToRemoveListElems, MAX_OBJEC
T_ID, 1, bIterator); | 3722 bIterator = DeserializeSequenceOf (&measObjectToRemoveListElems, MAX_OBJEC
T_ID, 1, bIterator); |
3754 | 3723 |
3755 for (int i = 0; i < measObjectToRemoveListElems; i++) | 3724 for (int i = 0; i < measObjectToRemoveListElems; i++) |
3756 { | 3725 { |
3757 bIterator = DeserializeInteger (&n, 1, MAX_OBJECT_ID, bIterator); | 3726 bIterator = DeserializeInteger (&n, 1, MAX_OBJECT_ID, bIterator); |
3758 measConfig->measObjectToRemoveList.push_back (static_cast<uint8_t>(n))
; | 3727 measConfig->measObjectToRemoveList.push_back (static_cast<uint8_t> (n)
); |
3759 } | 3728 } |
3760 } | 3729 } |
3761 | 3730 |
3762 if (bitset11[9]) | 3731 if (bitset11[9]) |
3763 { | 3732 { |
3764 // measObjectToAddModList | 3733 // measObjectToAddModList |
3765 int measObjectToAddModListElems; | 3734 int measObjectToAddModListElems; |
3766 bIterator = DeserializeSequenceOf (&measObjectToAddModListElems, MAX_OBJEC
T_ID, 1, bIterator); | 3735 bIterator = DeserializeSequenceOf (&measObjectToAddModListElems, MAX_OBJEC
T_ID, 1, bIterator); |
3767 | 3736 |
3768 for (int i = 0; i < measObjectToAddModListElems; i++) | 3737 for (int i = 0; i < measObjectToAddModListElems; i++) |
3769 { | 3738 { |
3770 LteRrcSap::MeasObjectToAddMod elem; | 3739 LteRrcSap::MeasObjectToAddMod elem; |
3771 | 3740 |
3772 bIterator = DeserializeSequence (&bitset0, false, bIterator); | 3741 bIterator = DeserializeSequence (&bitset0, false, bIterator); |
3773 | 3742 |
3774 bIterator = DeserializeInteger (&n, 1, MAX_OBJECT_ID, bIterator); | 3743 bIterator = DeserializeInteger (&n, 1, MAX_OBJECT_ID, bIterator); |
3775 elem.measObjectId = static_cast<uint8_t>(n); | 3744 elem.measObjectId = static_cast<uint8_t> (n); |
3776 | 3745 |
3777 int measObjectChoice; | 3746 int measObjectChoice; |
3778 bIterator = DeserializeChoice (4, true, &measObjectChoice, bIterator); | 3747 bIterator = DeserializeChoice (4, true, &measObjectChoice, bIterator); |
3779 | 3748 |
3780 switch (measObjectChoice) | 3749 switch (measObjectChoice) |
3781 { | 3750 { |
3782 case 1: | 3751 case 1: |
3783 // Deserialize measObjectUTRA | 3752 // Deserialize measObjectUTRA |
3784 // ... | 3753 // ... |
3785 break; | 3754 break; |
(...skipping 13 matching lines...) Expand all Loading... |
3799 // Deserialize measObjectEUTRA | 3768 // Deserialize measObjectEUTRA |
3800 std::bitset<5> measObjectEutraOpts; | 3769 std::bitset<5> measObjectEutraOpts; |
3801 bIterator = DeserializeSequence (&measObjectEutraOpts, true, bIter
ator); | 3770 bIterator = DeserializeSequence (&measObjectEutraOpts, true, bIter
ator); |
3802 | 3771 |
3803 // carrierFreq | 3772 // carrierFreq |
3804 bIterator = DeserializeInteger (&n, 0, MAX_EARFCN, bIterator); | 3773 bIterator = DeserializeInteger (&n, 0, MAX_EARFCN, bIterator); |
3805 elem.measObjectEutra.carrierFreq = n; | 3774 elem.measObjectEutra.carrierFreq = n; |
3806 | 3775 |
3807 // allowedMeasBandwidth | 3776 // allowedMeasBandwidth |
3808 bIterator = DeserializeEnum (6, &n, bIterator); | 3777 bIterator = DeserializeEnum (6, &n, bIterator); |
3809 switch (n) | 3778 elem.measObjectEutra.allowedMeasBandwidth = EnumToBandwidth (n); |
3810 { | |
3811 case 0: | |
3812 elem.measObjectEutra.allowedMeasBandwidth = 6; | |
3813 break; | |
3814 case 1: | |
3815 elem.measObjectEutra.allowedMeasBandwidth = 15; | |
3816 break; | |
3817 case 2: | |
3818 elem.measObjectEutra.allowedMeasBandwidth = 25; | |
3819 break; | |
3820 case 3: | |
3821 elem.measObjectEutra.allowedMeasBandwidth = 50; | |
3822 break; | |
3823 case 4: | |
3824 elem.measObjectEutra.allowedMeasBandwidth = 75; | |
3825 break; | |
3826 case 5: | |
3827 default: | |
3828 elem.measObjectEutra.allowedMeasBandwidth = 100; | |
3829 break; | |
3830 } | |
3831 | 3779 |
3832 // presenceAntennaPort1 | 3780 // presenceAntennaPort1 |
3833 bIterator = DeserializeBoolean (&elem.measObjectEutra.presenceAnte
nnaPort1, bIterator); | 3781 bIterator = DeserializeBoolean (&elem.measObjectEutra.presenceAnte
nnaPort1, bIterator); |
3834 | 3782 |
3835 // neighCellConfig | 3783 // neighCellConfig |
3836 bIterator = DeserializeBitstring (&bitset2, bIterator); | 3784 bIterator = DeserializeBitstring (&bitset2, bIterator); |
3837 elem.measObjectEutra.neighCellConfig = static_cast<uint8_t>(bitset
2.to_ulong ()); | 3785 elem.measObjectEutra.neighCellConfig = static_cast<uint8_t> (bitse
t2.to_ulong ()); |
3838 | 3786 |
3839 // offsetFreq | 3787 // offsetFreq |
3840 bIterator = DeserializeQoffsetRange (&elem.measObjectEutra.offsetF
req, bIterator); | 3788 bIterator = DeserializeQoffsetRange (&elem.measObjectEutra.offsetF
req, bIterator); |
3841 | 3789 |
3842 if (measObjectEutraOpts[4]) | 3790 if (measObjectEutraOpts[4]) |
3843 { | 3791 { |
3844 // cellsToRemoveList | 3792 // cellsToRemoveList |
3845 int numElems; | 3793 int numElems; |
3846 bIterator = DeserializeSequenceOf (&numElems, MAX_CELL_MEAS, 1
, bIterator); | 3794 bIterator = DeserializeSequenceOf (&numElems, MAX_CELL_MEAS, 1
, bIterator); |
3847 | 3795 |
3848 for (int j = 0; j < numElems; j++) | 3796 for (int j = 0; j < numElems; j++) |
3849 { | 3797 { |
3850 bIterator = DeserializeInteger (&n, 1, MAX_CELL_MEAS, bIte
rator); | 3798 bIterator = DeserializeInteger (&n, 1, MAX_CELL_MEAS, bIte
rator); |
3851 elem.measObjectEutra.cellsToRemoveList.push_back (static_c
ast<uint8_t>(n)); | 3799 elem.measObjectEutra.cellsToRemoveList.push_back (static_c
ast<uint8_t> (n)); |
3852 } | 3800 } |
3853 } | 3801 } |
3854 | 3802 |
3855 if (measObjectEutraOpts[3]) | 3803 if (measObjectEutraOpts[3]) |
3856 { | 3804 { |
3857 // cellsToAddModList | 3805 // cellsToAddModList |
3858 int numElems; | 3806 int numElems; |
3859 bIterator = DeserializeSequenceOf (&numElems, MAX_CELL_MEAS, 1
, bIterator); | 3807 bIterator = DeserializeSequenceOf (&numElems, MAX_CELL_MEAS, 1
, bIterator); |
3860 | 3808 |
3861 for (int j = 0; j < numElems; j++) | 3809 for (int j = 0; j < numElems; j++) |
3862 { | 3810 { |
3863 LteRrcSap::CellsToAddMod cellsToAddMod; | 3811 LteRrcSap::CellsToAddMod cellsToAddMod; |
3864 | 3812 |
3865 bIterator = DeserializeSequence (&bitset0, false, bIterato
r); | 3813 bIterator = DeserializeSequence (&bitset0, false, bIterato
r); |
3866 | 3814 |
3867 // cellIndex | 3815 // cellIndex |
3868 bIterator = DeserializeInteger (&n, 1, MAX_CELL_MEAS, bIte
rator); | 3816 bIterator = DeserializeInteger (&n, 1, MAX_CELL_MEAS, bIte
rator); |
3869 cellsToAddMod.cellIndex = static_cast<uint8_t>(n); | 3817 cellsToAddMod.cellIndex = static_cast<uint8_t> (n); |
3870 | 3818 |
3871 // PhysCellId | 3819 // PhysCellId |
3872 bIterator = DeserializeInteger (&n, 0, 503, bIterator); | 3820 bIterator = DeserializeInteger (&n, 0, 503, bIterator); |
3873 cellsToAddMod.physCellId = static_cast<uint16_t>(n); | 3821 cellsToAddMod.physCellId = static_cast<uint16_t> (n); |
3874 | 3822 |
3875 // cellIndividualOffset | 3823 // cellIndividualOffset |
3876 bIterator = DeserializeQoffsetRange ( &cellsToAddMod.cellI
ndividualOffset, bIterator); | 3824 bIterator = DeserializeQoffsetRange ( &cellsToAddMod.cellI
ndividualOffset, bIterator); |
3877 | 3825 |
3878 elem.measObjectEutra.cellsToAddModList.push_back (cellsToA
ddMod); | 3826 elem.measObjectEutra.cellsToAddModList.push_back (cellsToA
ddMod); |
3879 } | 3827 } |
3880 } | 3828 } |
3881 | 3829 |
3882 if (measObjectEutraOpts[2]) | 3830 if (measObjectEutraOpts[2]) |
3883 { | 3831 { |
3884 // blackCellsToRemoveList | 3832 // blackCellsToRemoveList |
3885 int numElems; | 3833 int numElems; |
3886 bIterator = DeserializeSequenceOf (&numElems, MAX_CELL_MEAS, 1
, bIterator); | 3834 bIterator = DeserializeSequenceOf (&numElems, MAX_CELL_MEAS, 1
, bIterator); |
3887 | 3835 |
3888 for (int j = 0; j < numElems; j++) | 3836 for (int j = 0; j < numElems; j++) |
3889 { | 3837 { |
3890 bIterator = DeserializeInteger (&n, 1, MAX_CELL_MEAS, bIte
rator); | 3838 bIterator = DeserializeInteger (&n, 1, MAX_CELL_MEAS, bIte
rator); |
3891 elem.measObjectEutra.blackCellsToRemoveList.push_back (sta
tic_cast<uint8_t>(n)); | 3839 elem.measObjectEutra.blackCellsToRemoveList.push_back (sta
tic_cast<uint8_t> (n)); |
3892 } | 3840 } |
3893 } | 3841 } |
3894 | 3842 |
3895 | 3843 |
3896 if (measObjectEutraOpts[1]) | 3844 if (measObjectEutraOpts[1]) |
3897 { | 3845 { |
3898 // blackCellsToAddModList | 3846 // blackCellsToAddModList |
3899 int numElems; | 3847 int numElems; |
3900 bIterator = DeserializeSequenceOf (&numElems, MAX_CELL_MEAS, 1
, bIterator); | 3848 bIterator = DeserializeSequenceOf (&numElems, MAX_CELL_MEAS, 1
, bIterator); |
3901 | 3849 |
3902 for (int j = 0; j < numElems; j++) | 3850 for (int j = 0; j < numElems; j++) |
3903 { | 3851 { |
3904 LteRrcSap::BlackCellsToAddMod blackCellsToAddMod; | 3852 LteRrcSap::BlackCellsToAddMod blackCellsToAddMod; |
3905 bIterator = DeserializeSequence (&bitset0, false, bIterato
r); | 3853 bIterator = DeserializeSequence (&bitset0, false, bIterato
r); |
3906 | 3854 |
3907 bIterator = DeserializeInteger (&n, 1, MAX_CELL_MEAS, bIte
rator); | 3855 bIterator = DeserializeInteger (&n, 1, MAX_CELL_MEAS, bIte
rator); |
3908 blackCellsToAddMod.cellIndex = static_cast<uint8_t>(n); | 3856 blackCellsToAddMod.cellIndex = static_cast<uint8_t> (n); |
3909 | 3857 |
3910 // PhysCellIdRange | 3858 // PhysCellIdRange |
3911 std::bitset<1> isRangePresent; | 3859 std::bitset<1> isRangePresent; |
3912 bIterator = DeserializeSequence (&isRangePresent, false, b
Iterator); | 3860 bIterator = DeserializeSequence (&isRangePresent, false, b
Iterator); |
3913 | 3861 |
3914 // start | 3862 // start |
3915 bIterator = DeserializeInteger (&n, 0, 503, bIterator); | 3863 bIterator = DeserializeInteger (&n, 0, 503, bIterator); |
3916 blackCellsToAddMod.physCellIdRange.start = static_cast<uin
t16_t>(n); | 3864 blackCellsToAddMod.physCellIdRange.start = static_cast<uin
t16_t> (n); |
3917 | 3865 |
3918 blackCellsToAddMod.physCellIdRange.haveRange = isRangePres
ent[0]; | 3866 blackCellsToAddMod.physCellIdRange.haveRange = isRangePres
ent[0]; |
3919 // initialize range to silence compiler warning | 3867 // initialize range to silence compiler warning |
3920 blackCellsToAddMod.physCellIdRange.range = 0; | 3868 blackCellsToAddMod.physCellIdRange.range = 0; |
3921 if (blackCellsToAddMod.physCellIdRange.haveRange) | 3869 if (blackCellsToAddMod.physCellIdRange.haveRange) |
3922 { | 3870 { |
3923 // range | 3871 // range |
3924 bIterator = DeserializeEnum (16, &n, bIterator); | 3872 bIterator = DeserializeEnum (16, &n, bIterator); |
3925 switch (n) | 3873 switch (n) |
3926 { | 3874 { |
(...skipping 46 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
3973 | 3921 |
3974 elem.measObjectEutra.blackCellsToAddModList.push_back (bla
ckCellsToAddMod); | 3922 elem.measObjectEutra.blackCellsToAddModList.push_back (bla
ckCellsToAddMod); |
3975 } | 3923 } |
3976 } | 3924 } |
3977 | 3925 |
3978 elem.measObjectEutra.haveCellForWhichToReportCGI = measObjectEutra
Opts[0]; | 3926 elem.measObjectEutra.haveCellForWhichToReportCGI = measObjectEutra
Opts[0]; |
3979 if (measObjectEutraOpts[0]) | 3927 if (measObjectEutraOpts[0]) |
3980 { | 3928 { |
3981 // cellForWhichToReportCGI | 3929 // cellForWhichToReportCGI |
3982 bIterator = DeserializeInteger (&n, 0, 503, bIterator); | 3930 bIterator = DeserializeInteger (&n, 0, 503, bIterator); |
3983 elem.measObjectEutra.cellForWhichToReportCGI = static_cast<uin
t8_t>(n); | 3931 elem.measObjectEutra.cellForWhichToReportCGI = static_cast<uin
t16_t> (n); |
3984 } | 3932 } |
3985 } | 3933 } |
3986 measConfig->measObjectToAddModList.push_back (elem); | 3934 measConfig->measObjectToAddModList.push_back (elem); |
3987 } | 3935 } |
3988 } | 3936 } |
3989 | 3937 |
3990 if (bitset11[8]) | 3938 if (bitset11[8]) |
3991 { | 3939 { |
3992 // reportConfigToRemoveList | 3940 // reportConfigToRemoveList |
3993 int reportConfigToRemoveListElems; | 3941 int reportConfigToRemoveListElems; |
3994 bIterator = DeserializeSequenceOf (&reportConfigToRemoveListElems, MAX_REP
ORT_CONFIG_ID, 1, bIterator); | 3942 bIterator = DeserializeSequenceOf (&reportConfigToRemoveListElems, MAX_REP
ORT_CONFIG_ID, 1, bIterator); |
3995 | 3943 |
3996 for (int i = 0; i < reportConfigToRemoveListElems; i++) | 3944 for (int i = 0; i < reportConfigToRemoveListElems; i++) |
3997 { | 3945 { |
3998 bIterator = DeserializeInteger (&n, 1, MAX_REPORT_CONFIG_ID, bIterator
); | 3946 bIterator = DeserializeInteger (&n, 1, MAX_REPORT_CONFIG_ID, bIterator
); |
3999 measConfig->reportConfigToRemoveList.push_back (static_cast<uint8_t>(n
)); | 3947 measConfig->reportConfigToRemoveList.push_back (static_cast<uint8_t> (
n)); |
4000 } | 3948 } |
4001 } | 3949 } |
4002 | 3950 |
4003 if (bitset11[7]) | 3951 if (bitset11[7]) |
4004 { | 3952 { |
4005 // reportConfigToAddModList | 3953 // reportConfigToAddModList |
4006 int reportConfigToAddModListElems; | 3954 int reportConfigToAddModListElems; |
4007 bIterator = DeserializeSequenceOf (&reportConfigToAddModListElems, MAX_REP
ORT_CONFIG_ID, 1, bIterator); | 3955 bIterator = DeserializeSequenceOf (&reportConfigToAddModListElems, MAX_REP
ORT_CONFIG_ID, 1, bIterator); |
4008 | 3956 |
4009 for (int i = 0; i < reportConfigToAddModListElems; i++) | 3957 for (int i = 0; i < reportConfigToAddModListElems; i++) |
4010 { | 3958 { |
4011 LteRrcSap::ReportConfigToAddMod elem; | 3959 LteRrcSap::ReportConfigToAddMod elem; |
4012 | 3960 |
4013 bIterator = DeserializeSequence (&bitset0, false, bIterator); | 3961 bIterator = DeserializeSequence (&bitset0, false, bIterator); |
4014 bIterator = DeserializeInteger (&n, 1, MAX_REPORT_CONFIG_ID, bIterator
); | 3962 bIterator = DeserializeInteger (&n, 1, MAX_REPORT_CONFIG_ID, bIterator
); |
4015 elem.reportConfigId = static_cast<uint8_t>(n); | 3963 elem.reportConfigId = static_cast<uint8_t> (n); |
4016 | 3964 |
4017 // Deserialize reportConfig | 3965 // Deserialize reportConfig |
4018 int reportConfigChoice; | 3966 int reportConfigChoice; |
4019 bIterator = DeserializeChoice (2, false, &reportConfigChoice, bIterato
r); | 3967 bIterator = DeserializeChoice (2, false, &reportConfigChoice, bIterato
r); |
4020 | 3968 |
4021 if (reportConfigChoice == 0) | 3969 if (reportConfigChoice == 0) |
4022 { | 3970 { |
4023 // reportConfigEUTRA | 3971 // reportConfigEUTRA |
4024 bIterator = DeserializeSequence (&bitset0, true, bIterator); | 3972 bIterator = DeserializeSequence (&bitset0, true, bIterator); |
4025 | 3973 |
(...skipping 41 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
4067 | 4015 |
4068 case 4: | 4016 case 4: |
4069 default: | 4017 default: |
4070 elem.reportConfigEutra.eventId = LteRrcSap::ReportConfigEu
tra::EVENT_A5; | 4018 elem.reportConfigEutra.eventId = LteRrcSap::ReportConfigEu
tra::EVENT_A5; |
4071 bIterator = DeserializeSequence (&bitset0, false, bIterato
r); | 4019 bIterator = DeserializeSequence (&bitset0, false, bIterato
r); |
4072 bIterator = DeserializeThresholdEutra (&elem.reportConfigE
utra.threshold1, bIterator); | 4020 bIterator = DeserializeThresholdEutra (&elem.reportConfigE
utra.threshold1, bIterator); |
4073 bIterator = DeserializeThresholdEutra (&elem.reportConfigE
utra.threshold2, bIterator); | 4021 bIterator = DeserializeThresholdEutra (&elem.reportConfigE
utra.threshold2, bIterator); |
4074 } | 4022 } |
4075 | 4023 |
4076 bIterator = DeserializeInteger (&n, 0, 30, bIterator); | 4024 bIterator = DeserializeInteger (&n, 0, 30, bIterator); |
4077 elem.reportConfigEutra.hysteresis = static_cast<uint8_t>(n); | 4025 elem.reportConfigEutra.hysteresis = static_cast<uint8_t> (n); |
4078 | 4026 |
4079 bIterator = DeserializeEnum (16, &n, bIterator); | 4027 bIterator = DeserializeEnum (16, &n, bIterator); |
4080 switch (n) | 4028 switch (n) |
4081 { | 4029 { |
4082 case 0: | 4030 case 0: |
4083 elem.reportConfigEutra.timeToTrigger = 0; | 4031 elem.reportConfigEutra.timeToTrigger = 0; |
4084 break; | 4032 break; |
4085 case 1: | 4033 case 1: |
4086 elem.reportConfigEutra.timeToTrigger = 40; | 4034 elem.reportConfigEutra.timeToTrigger = 40; |
4087 break; | 4035 break; |
(...skipping 182 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
4270 | 4218 |
4271 if (bitset11[6]) | 4219 if (bitset11[6]) |
4272 { | 4220 { |
4273 // measIdToRemoveList | 4221 // measIdToRemoveList |
4274 int measIdToRemoveListElems; | 4222 int measIdToRemoveListElems; |
4275 bIterator = DeserializeSequenceOf (&measIdToRemoveListElems, MAX_MEAS_ID,
1, bIterator); | 4223 bIterator = DeserializeSequenceOf (&measIdToRemoveListElems, MAX_MEAS_ID,
1, bIterator); |
4276 | 4224 |
4277 for (int i = 0; i < measIdToRemoveListElems; i++) | 4225 for (int i = 0; i < measIdToRemoveListElems; i++) |
4278 { | 4226 { |
4279 bIterator = DeserializeInteger (&n, 1, MAX_MEAS_ID, bIterator); | 4227 bIterator = DeserializeInteger (&n, 1, MAX_MEAS_ID, bIterator); |
4280 measConfig->measIdToRemoveList.push_back (static_cast<uint8_t>(n)); | 4228 measConfig->measIdToRemoveList.push_back (static_cast<uint8_t> (n)); |
4281 } | 4229 } |
4282 } | 4230 } |
4283 | 4231 |
4284 if (bitset11[5]) | 4232 if (bitset11[5]) |
4285 { | 4233 { |
4286 // measIdToAddModList | 4234 // measIdToAddModList |
4287 int measIdToAddModListElems; | 4235 int measIdToAddModListElems; |
4288 bIterator = DeserializeSequenceOf (&measIdToAddModListElems, MAX_MEAS_ID,
1, bIterator); | 4236 bIterator = DeserializeSequenceOf (&measIdToAddModListElems, MAX_MEAS_ID,
1, bIterator); |
4289 | 4237 |
4290 for (int i = 0; i < measIdToAddModListElems; i++) | 4238 for (int i = 0; i < measIdToAddModListElems; i++) |
4291 { | 4239 { |
4292 LteRrcSap::MeasIdToAddMod elem; | 4240 LteRrcSap::MeasIdToAddMod elem; |
4293 | 4241 |
4294 bIterator = DeserializeSequence (&bitset0, false, bIterator); | 4242 bIterator = DeserializeSequence (&bitset0, false, bIterator); |
4295 | 4243 |
4296 bIterator = DeserializeInteger (&n, 1, MAX_MEAS_ID, bIterator); | 4244 bIterator = DeserializeInteger (&n, 1, MAX_MEAS_ID, bIterator); |
4297 elem.measId = static_cast<uint8_t>(n); | 4245 elem.measId = static_cast<uint8_t> (n); |
4298 | 4246 |
4299 bIterator = DeserializeInteger (&n, 1, MAX_OBJECT_ID, bIterator); | 4247 bIterator = DeserializeInteger (&n, 1, MAX_OBJECT_ID, bIterator); |
4300 elem.measObjectId = static_cast<uint8_t>(n); | 4248 elem.measObjectId = static_cast<uint8_t> (n); |
4301 | 4249 |
4302 bIterator = DeserializeInteger (&n, 1, MAX_REPORT_CONFIG_ID, bIterator
); | 4250 bIterator = DeserializeInteger (&n, 1, MAX_REPORT_CONFIG_ID, bIterator
); |
4303 elem.reportConfigId = static_cast<uint8_t>(n); | 4251 elem.reportConfigId = static_cast<uint8_t> (n); |
4304 | 4252 |
4305 measConfig->measIdToAddModList.push_back (elem); | 4253 measConfig->measIdToAddModList.push_back (elem); |
4306 } | 4254 } |
4307 } | 4255 } |
4308 | 4256 |
4309 measConfig->haveQuantityConfig = bitset11[4]; | 4257 measConfig->haveQuantityConfig = bitset11[4]; |
4310 if (measConfig->haveQuantityConfig) | 4258 if (measConfig->haveQuantityConfig) |
4311 { | 4259 { |
4312 // quantityConfig | 4260 // quantityConfig |
4313 std::bitset<4> quantityConfigOpts; | 4261 std::bitset<4> quantityConfigOpts; |
(...skipping 146 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
4460 measConfig->measGapConfig.type = LteRrcSap::MeasGapConfig::SETUP; | 4408 measConfig->measGapConfig.type = LteRrcSap::MeasGapConfig::SETUP; |
4461 bIterator = DeserializeSequence (&bitset0, false, bIterator); | 4409 bIterator = DeserializeSequence (&bitset0, false, bIterator); |
4462 | 4410 |
4463 int gapOffsetChoice; | 4411 int gapOffsetChoice; |
4464 bIterator = DeserializeChoice (2, true, &gapOffsetChoice, bIterator); | 4412 bIterator = DeserializeChoice (2, true, &gapOffsetChoice, bIterator); |
4465 switch (gapOffsetChoice) | 4413 switch (gapOffsetChoice) |
4466 { | 4414 { |
4467 case 0: | 4415 case 0: |
4468 measConfig->measGapConfig.gapOffsetChoice = LteRrcSap::MeasGapConf
ig::GP0; | 4416 measConfig->measGapConfig.gapOffsetChoice = LteRrcSap::MeasGapConf
ig::GP0; |
4469 bIterator = DeserializeInteger (&n, 0, 39, bIterator); | 4417 bIterator = DeserializeInteger (&n, 0, 39, bIterator); |
4470 measConfig->measGapConfig.gapOffsetValue = static_cast<uint8_t>(n)
; | 4418 measConfig->measGapConfig.gapOffsetValue = static_cast<uint8_t> (n
); |
4471 break; | 4419 break; |
4472 case 1: | 4420 case 1: |
4473 default: | 4421 default: |
4474 measConfig->measGapConfig.gapOffsetChoice = LteRrcSap::MeasGapConf
ig::GP1; | 4422 measConfig->measGapConfig.gapOffsetChoice = LteRrcSap::MeasGapConf
ig::GP1; |
4475 bIterator = DeserializeInteger (&n, 0, 79, bIterator); | 4423 bIterator = DeserializeInteger (&n, 0, 79, bIterator); |
4476 measConfig->measGapConfig.gapOffsetValue = static_cast<uint8_t>(n)
; | 4424 measConfig->measGapConfig.gapOffsetValue = static_cast<uint8_t> (n
); |
4477 } | 4425 } |
4478 } | 4426 } |
4479 } | 4427 } |
4480 | 4428 |
4481 measConfig->haveSmeasure = bitset11[2]; | 4429 measConfig->haveSmeasure = bitset11[2]; |
4482 if (measConfig->haveSmeasure) | 4430 if (measConfig->haveSmeasure) |
4483 { | 4431 { |
4484 // s-Measure | 4432 // s-Measure |
4485 bIterator = DeserializeInteger (&n, 0, 97, bIterator); | 4433 bIterator = DeserializeInteger (&n, 0, 97, bIterator); |
4486 measConfig->sMeasure = static_cast<uint8_t>(n); | 4434 measConfig->sMeasure = static_cast<uint8_t> (n); |
4487 } | 4435 } |
4488 | 4436 |
4489 if (bitset11[1]) | 4437 if (bitset11[1]) |
4490 { | 4438 { |
4491 // preRegistrationInfoHRPD | 4439 // preRegistrationInfoHRPD |
4492 // ... | 4440 // ... |
4493 } | 4441 } |
4494 | 4442 |
4495 measConfig->haveSpeedStatePars = bitset11[0]; | 4443 measConfig->haveSpeedStatePars = bitset11[0]; |
4496 if (measConfig->haveSpeedStatePars) | 4444 if (measConfig->haveSpeedStatePars) |
(...skipping 52 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
4549 measConfig->speedStatePars.mobilityStateParameters.tHystNormal = 1
80; | 4497 measConfig->speedStatePars.mobilityStateParameters.tHystNormal = 1
80; |
4550 break; | 4498 break; |
4551 case 4: | 4499 case 4: |
4552 measConfig->speedStatePars.mobilityStateParameters.tHystNormal = 2
40; | 4500 measConfig->speedStatePars.mobilityStateParameters.tHystNormal = 2
40; |
4553 break; | 4501 break; |
4554 default: | 4502 default: |
4555 measConfig->speedStatePars.mobilityStateParameters.tHystNormal = 0
; | 4503 measConfig->speedStatePars.mobilityStateParameters.tHystNormal = 0
; |
4556 } | 4504 } |
4557 | 4505 |
4558 bIterator = DeserializeInteger (&n, 1, 16, bIterator); | 4506 bIterator = DeserializeInteger (&n, 1, 16, bIterator); |
4559 measConfig->speedStatePars.mobilityStateParameters.nCellChangeMedium =
static_cast<uint8_t>(n); | 4507 measConfig->speedStatePars.mobilityStateParameters.nCellChangeMedium =
static_cast<uint8_t> (n); |
4560 | 4508 |
4561 bIterator = DeserializeInteger (&n, 1, 16, bIterator); | 4509 bIterator = DeserializeInteger (&n, 1, 16, bIterator); |
4562 measConfig->speedStatePars.mobilityStateParameters.nCellChangeHigh = s
tatic_cast<uint8_t>(n); | 4510 measConfig->speedStatePars.mobilityStateParameters.nCellChangeHigh = s
tatic_cast<uint8_t> (n); |
4563 | 4511 |
4564 // Deserialize timeToTriggerSf | 4512 // Deserialize timeToTriggerSf |
4565 bIterator = DeserializeEnum (4, &n, bIterator); | 4513 bIterator = DeserializeEnum (4, &n, bIterator); |
4566 measConfig->speedStatePars.timeToTriggerSf.sfMedium = static_cast<uint
8_t>((n + 1) * 25); | 4514 measConfig->speedStatePars.timeToTriggerSf.sfMedium = static_cast<uint
8_t> ((n + 1) * 25); |
4567 bIterator = DeserializeEnum (4, &n, bIterator); | 4515 bIterator = DeserializeEnum (4, &n, bIterator); |
4568 measConfig->speedStatePars.timeToTriggerSf.sfHigh = static_cast<uint8_
t>((n + 1) * 25); | 4516 measConfig->speedStatePars.timeToTriggerSf.sfHigh = static_cast<uint8_
t> ((n + 1) * 25); |
4569 } | 4517 } |
4570 } | 4518 } |
4571 return bIterator; | 4519 return bIterator; |
4572 } | 4520 } |
| 4521 |
4573 //////////////////// RrcConnectionRequest class //////////////////////// | 4522 //////////////////// RrcConnectionRequest class //////////////////////// |
4574 | 4523 |
4575 // Constructor | 4524 // Constructor |
4576 RrcConnectionRequestHeader::RrcConnectionRequestHeader () : RrcUlCcchMessage () | 4525 RrcConnectionRequestHeader::RrcConnectionRequestHeader () : RrcUlCcchMessage () |
4577 { | 4526 { |
4578 m_mmec = std::bitset<8> (0ul); | 4527 m_mmec = std::bitset<8> (0ul); |
4579 m_mTmsi = std::bitset<32> (0ul); | 4528 m_mTmsi = std::bitset<32> (0ul); |
4580 m_establishmentCause = MO_SIGNALLING; | 4529 m_establishmentCause = MO_SIGNALLING; |
4581 m_spare = std::bitset<1> (0ul); | 4530 m_spare = std::bitset<1> (0ul); |
4582 } | 4531 } |
(...skipping 202 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
4785 | 4734 |
4786 bIterator = DeserializeDlCcchMessage (bIterator); | 4735 bIterator = DeserializeDlCcchMessage (bIterator); |
4787 | 4736 |
4788 bIterator = DeserializeInteger (&n,0,15,bIterator); | 4737 bIterator = DeserializeInteger (&n,0,15,bIterator); |
4789 | 4738 |
4790 // Deserialize RRCConnectionSetup sequence | 4739 // Deserialize RRCConnectionSetup sequence |
4791 bIterator = DeserializeSequence (&bitset0,false,bIterator); | 4740 bIterator = DeserializeSequence (&bitset0,false,bIterator); |
4792 | 4741 |
4793 // Deserialize rrc-TransactionIdentifier ::=INTEGER (0..3) | 4742 // Deserialize rrc-TransactionIdentifier ::=INTEGER (0..3) |
4794 bIterator = DeserializeInteger (&n,0,3,bIterator); | 4743 bIterator = DeserializeInteger (&n,0,3,bIterator); |
4795 m_rrcTransactionIdentifier = static_cast<uint8_t>(n); | 4744 m_rrcTransactionIdentifier = static_cast<uint8_t> (n); |
4796 | 4745 |
4797 // Deserialize criticalExtensions choice | 4746 // Deserialize criticalExtensions choice |
4798 int criticalExtensionChoice; | 4747 int criticalExtensionChoice; |
4799 bIterator = DeserializeChoice (2,false,&criticalExtensionChoice,bIterator); | 4748 bIterator = DeserializeChoice (2,false,&criticalExtensionChoice,bIterator); |
4800 if (criticalExtensionChoice == 1) | 4749 if (criticalExtensionChoice == 1) |
4801 { | 4750 { |
4802 // Deserialize criticalExtensionsFuture | 4751 // Deserialize criticalExtensionsFuture |
4803 bIterator = DeserializeSequence (&bitset0,false,bIterator); | 4752 bIterator = DeserializeSequence (&bitset0,false,bIterator); |
4804 } | 4753 } |
4805 else if (criticalExtensionChoice == 0) | 4754 else if (criticalExtensionChoice == 0) |
(...skipping 132 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
4938 RrcConnectionSetupCompleteHeader::Deserialize (Buffer::Iterator bIterator) | 4887 RrcConnectionSetupCompleteHeader::Deserialize (Buffer::Iterator bIterator) |
4939 { | 4888 { |
4940 std::bitset<0> bitset0; | 4889 std::bitset<0> bitset0; |
4941 | 4890 |
4942 bIterator = DeserializeUlDcchMessage (bIterator); | 4891 bIterator = DeserializeUlDcchMessage (bIterator); |
4943 | 4892 |
4944 bIterator = DeserializeSequence (&bitset0,false,bIterator); | 4893 bIterator = DeserializeSequence (&bitset0,false,bIterator); |
4945 | 4894 |
4946 int n; | 4895 int n; |
4947 bIterator = DeserializeInteger (&n,0,3,bIterator); | 4896 bIterator = DeserializeInteger (&n,0,3,bIterator); |
4948 m_rrcTransactionIdentifier = static_cast<uint8_t>(n); | 4897 m_rrcTransactionIdentifier = static_cast<uint8_t> (n); |
4949 | 4898 |
4950 bIterator = DeserializeChoice (2,false,&n,bIterator); | 4899 bIterator = DeserializeChoice (2,false,&n,bIterator); |
4951 | 4900 |
4952 if (n == 1) | 4901 if (n == 1) |
4953 { | 4902 { |
4954 // Deserialize criticalExtensionsFuture | 4903 // Deserialize criticalExtensionsFuture |
4955 bIterator = DeserializeSequence (&bitset0,false,bIterator); | 4904 bIterator = DeserializeSequence (&bitset0,false,bIterator); |
4956 } | 4905 } |
4957 else if (n == 0) | 4906 else if (n == 0) |
4958 { | 4907 { |
(...skipping 81 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
5040 uint32_t | 4989 uint32_t |
5041 RrcConnectionReconfigurationCompleteHeader::Deserialize (Buffer::Iterator bItera
tor) | 4990 RrcConnectionReconfigurationCompleteHeader::Deserialize (Buffer::Iterator bItera
tor) |
5042 { | 4991 { |
5043 std::bitset<0> bitset0; | 4992 std::bitset<0> bitset0; |
5044 int n; | 4993 int n; |
5045 | 4994 |
5046 bIterator = DeserializeUlDcchMessage (bIterator); | 4995 bIterator = DeserializeUlDcchMessage (bIterator); |
5047 bIterator = DeserializeSequence (&bitset0,false,bIterator); | 4996 bIterator = DeserializeSequence (&bitset0,false,bIterator); |
5048 | 4997 |
5049 bIterator = DeserializeInteger (&n,0,3,bIterator); | 4998 bIterator = DeserializeInteger (&n,0,3,bIterator); |
5050 m_rrcTransactionIdentifier = static_cast<uint8_t>(n); | 4999 m_rrcTransactionIdentifier = static_cast<uint8_t> (n); |
5051 | 5000 |
5052 bIterator = DeserializeChoice (2,false,&n,bIterator); | 5001 bIterator = DeserializeChoice (2,false,&n,bIterator); |
5053 | 5002 |
5054 if (n == 1) | 5003 if (n == 1) |
5055 { | 5004 { |
5056 // Deserialize criticalExtensionsFuture | 5005 // Deserialize criticalExtensionsFuture |
5057 bIterator = DeserializeSequence (&bitset0,false,bIterator); | 5006 bIterator = DeserializeSequence (&bitset0,false,bIterator); |
5058 } | 5007 } |
5059 else if (n == 0) | 5008 else if (n == 0) |
5060 { | 5009 { |
(...skipping 99 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
5160 SerializeSequence (std::bitset<1> (1),false); | 5109 SerializeSequence (std::bitset<1> (1),false); |
5161 SerializeInteger (m_mobilityControlInfo.carrierFreq.dlCarrierFreq,0,MA
X_EARFCN); | 5110 SerializeInteger (m_mobilityControlInfo.carrierFreq.dlCarrierFreq,0,MA
X_EARFCN); |
5162 SerializeInteger (m_mobilityControlInfo.carrierFreq.ulCarrierFreq,0,MA
X_EARFCN); | 5111 SerializeInteger (m_mobilityControlInfo.carrierFreq.ulCarrierFreq,0,MA
X_EARFCN); |
5163 } | 5112 } |
5164 | 5113 |
5165 if (m_mobilityControlInfo.haveCarrierBandwidth) | 5114 if (m_mobilityControlInfo.haveCarrierBandwidth) |
5166 { | 5115 { |
5167 SerializeSequence (std::bitset<1> (1),false); | 5116 SerializeSequence (std::bitset<1> (1),false); |
5168 | 5117 |
5169 // Serialize dl-Bandwidth | 5118 // Serialize dl-Bandwidth |
5170 switch (m_mobilityControlInfo.carrierBandwidth.dlBandwidth) | 5119 SerializeEnum (16, BandwidthToEnum (m_mobilityControlInfo.carrierBandw
idth.dlBandwidth)); |
5171 { | |
5172 case 6: | |
5173 SerializeEnum (16,0); | |
5174 break; | |
5175 case 15: | |
5176 SerializeEnum (16,1); | |
5177 break; | |
5178 case 25: | |
5179 SerializeEnum (16,2); | |
5180 break; | |
5181 case 50: | |
5182 SerializeEnum (16,3); | |
5183 break; | |
5184 case 75: | |
5185 SerializeEnum (16,4); | |
5186 break; | |
5187 case 100: | |
5188 SerializeEnum (16,5); | |
5189 break; | |
5190 default: | |
5191 SerializeEnum (16,6); | |
5192 } | |
5193 | 5120 |
5194 // Serialize ul-Bandwidth | 5121 // Serialize ul-Bandwidth |
5195 switch (m_mobilityControlInfo.carrierBandwidth.ulBandwidth) | 5122 SerializeEnum (16, BandwidthToEnum (m_mobilityControlInfo.carrierBandw
idth.ulBandwidth)); |
5196 { | |
5197 case 6: | |
5198 SerializeEnum (16,0); | |
5199 break; | |
5200 case 15: | |
5201 SerializeEnum (16,1); | |
5202 break; | |
5203 case 25: | |
5204 SerializeEnum (16,2); | |
5205 break; | |
5206 case 50: | |
5207 SerializeEnum (16,3); | |
5208 break; | |
5209 case 75: | |
5210 SerializeEnum (16,4); | |
5211 break; | |
5212 case 100: | |
5213 SerializeEnum (16,5); | |
5214 break; | |
5215 default: | |
5216 SerializeEnum (16,6); | |
5217 } | |
5218 } | 5123 } |
5219 | 5124 |
5220 // Serialize t304 | 5125 // Serialize t304 |
5221 SerializeEnum (8,0); | 5126 SerializeEnum (8,0); |
5222 | 5127 |
5223 // Serialize newUE-Identitiy | 5128 // Serialize newUE-Identitiy |
5224 SerializeBitstring (std::bitset<16> (m_mobilityControlInfo.newUeIdentity))
; | 5129 SerializeBitstring (std::bitset<16> (m_mobilityControlInfo.newUeIdentity))
; |
5225 | 5130 |
5226 // Serialize radioResourceConfigCommon | 5131 // Serialize radioResourceConfigCommon |
5227 SerializeRadioResourceConfigCommon (m_mobilityControlInfo.radioResourceCon
figCommon); | 5132 SerializeRadioResourceConfigCommon (m_mobilityControlInfo.radioResourceCon
figCommon); |
(...skipping 44 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
5272 std::bitset<0> bitset0; | 5177 std::bitset<0> bitset0; |
5273 | 5178 |
5274 bIterator = DeserializeDlDcchMessage (bIterator); | 5179 bIterator = DeserializeDlDcchMessage (bIterator); |
5275 | 5180 |
5276 // RRCConnectionReconfiguration sequence | 5181 // RRCConnectionReconfiguration sequence |
5277 bIterator = DeserializeSequence (&bitset0,false,bIterator); | 5182 bIterator = DeserializeSequence (&bitset0,false,bIterator); |
5278 | 5183 |
5279 // rrc-TransactionIdentifier | 5184 // rrc-TransactionIdentifier |
5280 int n; | 5185 int n; |
5281 bIterator = DeserializeInteger (&n,0,3,bIterator); | 5186 bIterator = DeserializeInteger (&n,0,3,bIterator); |
5282 m_rrcTransactionIdentifier = static_cast<uint8_t>(n); | 5187 m_rrcTransactionIdentifier = static_cast<uint8_t> (n); |
5283 | 5188 |
5284 // criticalExtensions | 5189 // criticalExtensions |
5285 int sel; | 5190 int sel; |
5286 bIterator = DeserializeChoice (2,false,&sel,bIterator); | 5191 bIterator = DeserializeChoice (2,false,&sel,bIterator); |
5287 if (sel == 1) | 5192 if (sel == 1) |
5288 { | 5193 { |
5289 // criticalExtensionsFuture | 5194 // criticalExtensionsFuture |
5290 bIterator = DeserializeSequence (&bitset0,false,bIterator); | 5195 bIterator = DeserializeSequence (&bitset0,false,bIterator); |
5291 } | 5196 } |
5292 else if (sel == 0) | 5197 else if (sel == 0) |
(...skipping 19 matching lines...) Expand all Loading... |
5312 | 5217 |
5313 m_haveMobilityControlInfo = rrcConnRecOpts[4]; | 5218 m_haveMobilityControlInfo = rrcConnRecOpts[4]; |
5314 if (m_haveMobilityControlInfo) | 5219 if (m_haveMobilityControlInfo) |
5315 { | 5220 { |
5316 // mobilityControlInfo | 5221 // mobilityControlInfo |
5317 std::bitset<4> mobCtrlOpts; | 5222 std::bitset<4> mobCtrlOpts; |
5318 bIterator = DeserializeSequence (&mobCtrlOpts,true,bIterator); | 5223 bIterator = DeserializeSequence (&mobCtrlOpts,true,bIterator); |
5319 | 5224 |
5320 // PhysCellId | 5225 // PhysCellId |
5321 bIterator = DeserializeInteger (&n,0,503,bIterator); | 5226 bIterator = DeserializeInteger (&n,0,503,bIterator); |
5322 m_mobilityControlInfo.targetPhysCellId = static_cast<uint16_t>(n); | 5227 m_mobilityControlInfo.targetPhysCellId = static_cast<uint16_t> (n)
; |
5323 | 5228 |
5324 // carrierFreq | 5229 // carrierFreq |
5325 m_mobilityControlInfo.haveCarrierFreq = mobCtrlOpts[3]; | 5230 m_mobilityControlInfo.haveCarrierFreq = mobCtrlOpts[3]; |
5326 if (m_mobilityControlInfo.haveCarrierFreq) | 5231 if (m_mobilityControlInfo.haveCarrierFreq) |
5327 { | 5232 { |
5328 std::bitset<1> ulCarrierFreqPresent; | 5233 std::bitset<1> ulCarrierFreqPresent; |
5329 bIterator = DeserializeSequence (&ulCarrierFreqPresent,false,b
Iterator); | 5234 bIterator = DeserializeSequence (&ulCarrierFreqPresent,false,b
Iterator); |
5330 | 5235 |
5331 bIterator = DeserializeInteger (&n,0,MAX_EARFCN,bIterator); | 5236 bIterator = DeserializeInteger (&n,0,MAX_EARFCN,bIterator); |
5332 m_mobilityControlInfo.carrierFreq.dlCarrierFreq = n; | 5237 m_mobilityControlInfo.carrierFreq.dlCarrierFreq = n; |
5333 | 5238 |
5334 if (ulCarrierFreqPresent[0]) | 5239 if (ulCarrierFreqPresent[0]) |
5335 { | 5240 { |
5336 bIterator = DeserializeInteger (&n,0,MAX_EARFCN,bIterator)
; | 5241 bIterator = DeserializeInteger (&n,0,MAX_EARFCN,bIterator)
; |
5337 m_mobilityControlInfo.carrierFreq.ulCarrierFreq = n; | 5242 m_mobilityControlInfo.carrierFreq.ulCarrierFreq = n; |
5338 } | 5243 } |
5339 } | 5244 } |
5340 | 5245 |
5341 // carrierBandwidth | 5246 // carrierBandwidth |
5342 m_mobilityControlInfo.haveCarrierBandwidth = mobCtrlOpts[2]; | 5247 m_mobilityControlInfo.haveCarrierBandwidth = mobCtrlOpts[2]; |
5343 if (m_mobilityControlInfo.haveCarrierBandwidth) | 5248 if (m_mobilityControlInfo.haveCarrierBandwidth) |
5344 { | 5249 { |
5345 std::bitset<1> ulBandwidthPresent; | 5250 std::bitset<1> ulBandwidthPresent; |
5346 bIterator = DeserializeSequence (&ulBandwidthPresent,false,bIt
erator); | 5251 bIterator = DeserializeSequence (&ulBandwidthPresent,false,bIt
erator); |
5347 | 5252 |
5348 bIterator = DeserializeEnum (16,&n,bIterator); | 5253 bIterator = DeserializeEnum (16,&n,bIterator); |
5349 switch (n) | 5254 m_mobilityControlInfo.carrierBandwidth.dlBandwidth = EnumToBan
dwidth (n); |
5350 { | |
5351 case 0: | |
5352 m_mobilityControlInfo.carrierBandwidth.dlBandwidth = 6; | |
5353 break; | |
5354 case 1: | |
5355 m_mobilityControlInfo.carrierBandwidth.dlBandwidth = 15; | |
5356 break; | |
5357 case 2: | |
5358 m_mobilityControlInfo.carrierBandwidth.dlBandwidth = 25; | |
5359 break; | |
5360 case 3: | |
5361 m_mobilityControlInfo.carrierBandwidth.dlBandwidth = 50; | |
5362 break; | |
5363 case 4: | |
5364 m_mobilityControlInfo.carrierBandwidth.dlBandwidth = 75; | |
5365 break; | |
5366 case 5: | |
5367 m_mobilityControlInfo.carrierBandwidth.dlBandwidth = 100; | |
5368 break; | |
5369 case 6: | |
5370 m_mobilityControlInfo.carrierBandwidth.dlBandwidth = 0; | |
5371 break; | |
5372 } | |
5373 | 5255 |
5374 if (ulBandwidthPresent[0]) | 5256 if (ulBandwidthPresent[0]) |
5375 { | 5257 { |
5376 bIterator = DeserializeEnum (16,&n,bIterator); | 5258 bIterator = DeserializeEnum (16,&n,bIterator); |
5377 switch (n) | 5259 m_mobilityControlInfo.carrierBandwidth.ulBandwidth = EnumT
oBandwidth (n); |
5378 { | |
5379 case 0: | |
5380 m_mobilityControlInfo.carrierBandwidth.ulBandwidth = 6
; | |
5381 break; | |
5382 case 1: | |
5383 m_mobilityControlInfo.carrierBandwidth.ulBandwidth = 1
5; | |
5384 break; | |
5385 case 2: | |
5386 m_mobilityControlInfo.carrierBandwidth.ulBandwidth = 2
5; | |
5387 break; | |
5388 case 3: | |
5389 m_mobilityControlInfo.carrierBandwidth.ulBandwidth = 5
0; | |
5390 break; | |
5391 case 4: | |
5392 m_mobilityControlInfo.carrierBandwidth.ulBandwidth = 7
5; | |
5393 break; | |
5394 case 5: | |
5395 m_mobilityControlInfo.carrierBandwidth.ulBandwidth = 1
00; | |
5396 break; | |
5397 case 6: | |
5398 m_mobilityControlInfo.carrierBandwidth.ulBandwidth = 0
; | |
5399 break; | |
5400 } | |
5401 } | 5260 } |
5402 } | 5261 } |
5403 | 5262 |
5404 // additionalSpectrumEmission | 5263 // additionalSpectrumEmission |
5405 if (mobCtrlOpts[1]) | 5264 if (mobCtrlOpts[1]) |
5406 { | 5265 { |
5407 // ... | 5266 // ... |
5408 } | 5267 } |
5409 | 5268 |
5410 // t304 | 5269 // t304 |
5411 bIterator = DeserializeEnum (8,&n,bIterator); | 5270 bIterator = DeserializeEnum (8,&n,bIterator); |
5412 | 5271 |
5413 // newUE-Identity | 5272 // newUE-Identity |
5414 std::bitset<16> cRnti; | 5273 std::bitset<16> cRnti; |
5415 bIterator = DeserializeBitstring (&cRnti, bIterator); | 5274 bIterator = DeserializeBitstring (&cRnti, bIterator); |
5416 m_mobilityControlInfo.newUeIdentity = static_cast<uint16_t>(cRnti.
to_ulong ()); | 5275 m_mobilityControlInfo.newUeIdentity = static_cast<uint16_t> (cRnti
.to_ulong ()); |
5417 | 5276 |
5418 // radioResourceConfigCommon | 5277 // radioResourceConfigCommon |
5419 bIterator = DeserializeRadioResourceConfigCommon (&m_mobilityContr
olInfo.radioResourceConfigCommon, bIterator); | 5278 bIterator = DeserializeRadioResourceConfigCommon (&m_mobilityContr
olInfo.radioResourceConfigCommon, bIterator); |
5420 | 5279 |
5421 m_mobilityControlInfo.haveRachConfigDedicated = mobCtrlOpts[0]; | 5280 m_mobilityControlInfo.haveRachConfigDedicated = mobCtrlOpts[0]; |
5422 if (m_mobilityControlInfo.haveRachConfigDedicated) | 5281 if (m_mobilityControlInfo.haveRachConfigDedicated) |
5423 { | 5282 { |
5424 bIterator = DeserializeSequence (&bitset0, false, bIterator); | 5283 bIterator = DeserializeSequence (&bitset0, false, bIterator); |
5425 bIterator = DeserializeInteger (&n,0,63, bIterator); | 5284 bIterator = DeserializeInteger (&n,0,63, bIterator); |
5426 m_mobilityControlInfo.rachConfigDedicated.raPreambleIndex = st
atic_cast<uint8_t>(n); | 5285 m_mobilityControlInfo.rachConfigDedicated.raPreambleIndex = st
atic_cast<uint8_t> (n); |
5427 bIterator = DeserializeInteger (&n,0,15, bIterator); | 5286 bIterator = DeserializeInteger (&n,0,15, bIterator); |
5428 m_mobilityControlInfo.rachConfigDedicated.raPrachMaskIndex = s
tatic_cast<uint8_t>(n); | 5287 m_mobilityControlInfo.rachConfigDedicated.raPrachMaskIndex = s
tatic_cast<uint8_t> (n); |
5429 } | 5288 } |
5430 } | 5289 } |
5431 | 5290 |
5432 // dedicatedInfoNASList | 5291 // dedicatedInfoNASList |
5433 if (rrcConnRecOpts[3]) | 5292 if (rrcConnRecOpts[3]) |
5434 { | 5293 { |
5435 // ... | 5294 // ... |
5436 } | 5295 } |
5437 | 5296 |
5438 // radioResourceConfigDedicated | 5297 // radioResourceConfigDedicated |
(...skipping 427 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
5866 // cipheringAlgorithm | 5725 // cipheringAlgorithm |
5867 SerializeEnum (8,0); | 5726 SerializeEnum (8,0); |
5868 // integrityProtAlgorithm | 5727 // integrityProtAlgorithm |
5869 SerializeEnum (8,0); | 5728 SerializeEnum (8,0); |
5870 | 5729 |
5871 // Serialize sourceUE-Identity | 5730 // Serialize sourceUE-Identity |
5872 SerializeBitstring (std::bitset<16> (m_asConfig.sourceUeIdentity)); | 5731 SerializeBitstring (std::bitset<16> (m_asConfig.sourceUeIdentity)); |
5873 | 5732 |
5874 // Serialize sourceMasterInformationBlock | 5733 // Serialize sourceMasterInformationBlock |
5875 SerializeSequence (std::bitset<0> (),false); | 5734 SerializeSequence (std::bitset<0> (),false); |
5876 SerializeEnum (6,m_asConfig.sourceMasterInformationBlock.dlBandwidth); // dl-B
andwidth | 5735 SerializeEnum (6, BandwidthToEnum (m_asConfig.sourceMasterInformationBlock.dlB
andwidth)); // dl-Bandwidth |
5877 SerializeSequence (std::bitset<0> (),false); // phich-Config sequence | 5736 SerializeSequence (std::bitset<0> (),false); // phich-Config sequence |
5878 SerializeEnum (2,0); // phich-Duration | 5737 SerializeEnum (2,0); // phich-Duration |
5879 SerializeEnum (4,0); // phich-Resource | 5738 SerializeEnum (4,0); // phich-Resource |
5880 SerializeBitstring (std::bitset<8> (m_asConfig.sourceMasterInformationBlock.sy
stemFrameNumber)); // systemFrameNumber | 5739 SerializeBitstring (std::bitset<8> (m_asConfig.sourceMasterInformationBlock.sy
stemFrameNumber)); // systemFrameNumber |
5881 SerializeBitstring (std::bitset<10> (321)); // spare | 5740 SerializeBitstring (std::bitset<10> (321)); // spare |
5882 | 5741 |
5883 // Serialize sourceSystemInformationBlockType1 sequence | 5742 // Serialize sourceSystemInformationBlockType1 sequence |
5884 SerializeSystemInformationBlockType1 (m_asConfig.sourceSystemInformationBlockT
ype1); | 5743 SerializeSystemInformationBlockType1 (m_asConfig.sourceSystemInformationBlockT
ype1); |
5885 | 5744 |
5886 // Serialize sourceSystemInformationBlockType2 | 5745 // Serialize sourceSystemInformationBlockType2 |
(...skipping 64 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
5951 bIterator = DeserializeRadioResourceConfigDedicated (&m_asConfig.s
ourceRadioResourceConfig,bIterator); | 5810 bIterator = DeserializeRadioResourceConfigDedicated (&m_asConfig.s
ourceRadioResourceConfig,bIterator); |
5952 | 5811 |
5953 // Deserialize sourceSecurityAlgorithmConfig | 5812 // Deserialize sourceSecurityAlgorithmConfig |
5954 bIterator = DeserializeSequence (&bitset0,false,bIterator); | 5813 bIterator = DeserializeSequence (&bitset0,false,bIterator); |
5955 bIterator = DeserializeEnum (8,&n,bIterator); // cipheringAlgorith
m | 5814 bIterator = DeserializeEnum (8,&n,bIterator); // cipheringAlgorith
m |
5956 bIterator = DeserializeEnum (8,&n,bIterator); // integrityProtAlgo
rithm | 5815 bIterator = DeserializeEnum (8,&n,bIterator); // integrityProtAlgo
rithm |
5957 | 5816 |
5958 // Deserialize sourceUE-Identity | 5817 // Deserialize sourceUE-Identity |
5959 std::bitset<16> cRnti; | 5818 std::bitset<16> cRnti; |
5960 bIterator = DeserializeBitstring (&cRnti,bIterator); | 5819 bIterator = DeserializeBitstring (&cRnti,bIterator); |
5961 m_asConfig.sourceUeIdentity = static_cast<uint16_t>(cRnti.to_ulong
()); | 5820 m_asConfig.sourceUeIdentity = static_cast<uint16_t> (cRnti.to_ulon
g ()); |
5962 | 5821 |
5963 // Deserialize sourceMasterInformationBlock | 5822 // Deserialize sourceMasterInformationBlock |
5964 bIterator = DeserializeSequence (&bitset0,false,bIterator); | 5823 bIterator = DeserializeSequence (&bitset0,false,bIterator); |
5965 bIterator = DeserializeEnum (6,&n,bIterator); // dl-Bandwidth | 5824 bIterator = DeserializeEnum (6,&n,bIterator); // dl-Bandwidth |
5966 m_asConfig.sourceMasterInformationBlock.dlBandwidth = static_cast<
uint8_t>(n); | 5825 m_asConfig.sourceMasterInformationBlock.dlBandwidth = EnumToBandwi
dth (n); |
5967 | 5826 |
5968 // phich-Config | 5827 // phich-Config |
5969 bIterator = DeserializeSequence (&bitset0,false,bIterator); | 5828 bIterator = DeserializeSequence (&bitset0,false,bIterator); |
5970 bIterator = DeserializeEnum (2,&n,bIterator); // phich-Duration | 5829 bIterator = DeserializeEnum (2,&n,bIterator); // phich-Duration |
5971 bIterator = DeserializeEnum (4,&n,bIterator); // phich-Resource | 5830 bIterator = DeserializeEnum (4,&n,bIterator); // phich-Resource |
5972 | 5831 |
5973 // systemFrameNumber | 5832 // systemFrameNumber |
5974 std::bitset<8> systemFrameNumber; | 5833 std::bitset<8> systemFrameNumber; |
5975 bIterator = DeserializeBitstring (&systemFrameNumber,bIterator); | 5834 bIterator = DeserializeBitstring (&systemFrameNumber,bIterator); |
5976 m_asConfig.sourceMasterInformationBlock.systemFrameNumber = static
_cast<uint8_t>(systemFrameNumber.to_ulong ()); | 5835 m_asConfig.sourceMasterInformationBlock.systemFrameNumber = static
_cast<uint8_t> (systemFrameNumber.to_ulong ()); |
5977 // spare | 5836 // spare |
5978 std::bitset<10> spare; | 5837 std::bitset<10> spare; |
5979 bIterator = DeserializeBitstring (&spare,bIterator); | 5838 bIterator = DeserializeBitstring (&spare,bIterator); |
5980 | 5839 |
5981 // Deserialize sourceSystemInformationBlockType1 | 5840 // Deserialize sourceSystemInformationBlockType1 |
5982 bIterator = DeserializeSystemInformationBlockType1 (&m_asConfig.so
urceSystemInformationBlockType1,bIterator); | 5841 bIterator = DeserializeSystemInformationBlockType1 (&m_asConfig.so
urceSystemInformationBlockType1,bIterator); |
5983 | 5842 |
5984 // Deserialize sourceSystemInformationBlockType2 | 5843 // Deserialize sourceSystemInformationBlockType2 |
5985 bIterator = DeserializeSystemInformationBlockType2 (&m_asConfig.so
urceSystemInformationBlockType2,bIterator); | 5844 bIterator = DeserializeSystemInformationBlockType2 (&m_asConfig.so
urceSystemInformationBlockType2,bIterator); |
5986 | 5845 |
(...skipping 146 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
6133 { | 5992 { |
6134 // Deserialize RRCConnectionReestablishmentRequest-r8-IEs | 5993 // Deserialize RRCConnectionReestablishmentRequest-r8-IEs |
6135 bIterator = DeserializeSequence (&bitset0,false,bIterator); | 5994 bIterator = DeserializeSequence (&bitset0,false,bIterator); |
6136 | 5995 |
6137 // Deserialize ReestabUE-Identity sequence | 5996 // Deserialize ReestabUE-Identity sequence |
6138 bIterator = DeserializeSequence (&bitset0,false,bIterator); | 5997 bIterator = DeserializeSequence (&bitset0,false,bIterator); |
6139 | 5998 |
6140 // Deserialize c-RNTI | 5999 // Deserialize c-RNTI |
6141 std::bitset<16> cRnti; | 6000 std::bitset<16> cRnti; |
6142 bIterator = DeserializeBitstring (&cRnti,bIterator); | 6001 bIterator = DeserializeBitstring (&cRnti,bIterator); |
6143 m_ueIdentity.cRnti = static_cast<uint16_t>(cRnti.to_ulong ()); | 6002 m_ueIdentity.cRnti = static_cast<uint16_t> (cRnti.to_ulong ()); |
6144 | 6003 |
6145 // Deserialize physCellId | 6004 // Deserialize physCellId |
6146 int physCellId; | 6005 int physCellId; |
6147 bIterator = DeserializeInteger (&physCellId,0,503,bIterator); | 6006 bIterator = DeserializeInteger (&physCellId,0,503,bIterator); |
6148 m_ueIdentity.physCellId = static_cast<uint16_t>(physCellId); | 6007 m_ueIdentity.physCellId = static_cast<uint16_t> (physCellId); |
6149 | 6008 |
6150 // Deserialize shortMAC-I | 6009 // Deserialize shortMAC-I |
6151 std::bitset<16> shortMacI; | 6010 std::bitset<16> shortMacI; |
6152 bIterator = DeserializeBitstring (&shortMacI,bIterator); | 6011 bIterator = DeserializeBitstring (&shortMacI,bIterator); |
6153 | 6012 |
6154 // Deserialize ReestablishmentCause | 6013 // Deserialize ReestablishmentCause |
6155 int reestCs; | 6014 int reestCs; |
6156 bIterator = DeserializeEnum (4,&reestCs,bIterator); | 6015 bIterator = DeserializeEnum (4,&reestCs,bIterator); |
6157 switch (reestCs) | 6016 switch (reestCs) |
6158 { | 6017 { |
(...skipping 107 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
6266 int n; | 6125 int n; |
6267 | 6126 |
6268 bIterator = DeserializeDlCcchMessage (bIterator); | 6127 bIterator = DeserializeDlCcchMessage (bIterator); |
6269 | 6128 |
6270 // Deserialize RrcConnectionReestablishment sequence | 6129 // Deserialize RrcConnectionReestablishment sequence |
6271 // 0 optional fields, no extension marker | 6130 // 0 optional fields, no extension marker |
6272 bIterator = DeserializeSequence (&bitset0,false,bIterator); | 6131 bIterator = DeserializeSequence (&bitset0,false,bIterator); |
6273 | 6132 |
6274 // Deserialize rrc-TransactionIdentifier | 6133 // Deserialize rrc-TransactionIdentifier |
6275 bIterator = DeserializeInteger (&n,0,3,bIterator); | 6134 bIterator = DeserializeInteger (&n,0,3,bIterator); |
6276 m_rrcTransactionIdentifier = static_cast<uint8_t>(n); | 6135 m_rrcTransactionIdentifier = static_cast<uint8_t> (n); |
6277 | 6136 |
6278 // Deserialize criticalExtensions choice | 6137 // Deserialize criticalExtensions choice |
6279 int criticalExtensionsChoice; | 6138 int criticalExtensionsChoice; |
6280 bIterator = DeserializeChoice (2,false,&criticalExtensionsChoice,bIterator); | 6139 bIterator = DeserializeChoice (2,false,&criticalExtensionsChoice,bIterator); |
6281 if (criticalExtensionsChoice == 1) | 6140 if (criticalExtensionsChoice == 1) |
6282 { | 6141 { |
6283 // Deserialize criticalExtensionsFuture | 6142 // Deserialize criticalExtensionsFuture |
6284 bIterator = DeserializeSequence (&bitset0,false,bIterator); | 6143 bIterator = DeserializeSequence (&bitset0,false,bIterator); |
6285 } | 6144 } |
6286 else if (criticalExtensionsChoice == 0) | 6145 else if (criticalExtensionsChoice == 0) |
(...skipping 99 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
6386 int n; | 6245 int n; |
6387 | 6246 |
6388 bIterator = DeserializeUlDcchMessage (bIterator); | 6247 bIterator = DeserializeUlDcchMessage (bIterator); |
6389 | 6248 |
6390 // Deserialize RrcConnectionReestablishmentComplete sequence | 6249 // Deserialize RrcConnectionReestablishmentComplete sequence |
6391 // 0 optional fields, no extension marker | 6250 // 0 optional fields, no extension marker |
6392 bIterator = DeserializeSequence (&bitset0,false,bIterator); | 6251 bIterator = DeserializeSequence (&bitset0,false,bIterator); |
6393 | 6252 |
6394 // Deserialize rrc-TransactionIdentifier | 6253 // Deserialize rrc-TransactionIdentifier |
6395 bIterator = DeserializeInteger (&n,0,3,bIterator); | 6254 bIterator = DeserializeInteger (&n,0,3,bIterator); |
6396 m_rrcTransactionIdentifier = static_cast<uint8_t>(n); | 6255 m_rrcTransactionIdentifier = static_cast<uint8_t> (n); |
6397 | 6256 |
6398 // Deserialize criticalExtensions choice | 6257 // Deserialize criticalExtensions choice |
6399 int criticalExtensionsChoice; | 6258 int criticalExtensionsChoice; |
6400 bIterator = DeserializeChoice (2,false,&criticalExtensionsChoice,bIterator); | 6259 bIterator = DeserializeChoice (2,false,&criticalExtensionsChoice,bIterator); |
6401 if (criticalExtensionsChoice == 1) | 6260 if (criticalExtensionsChoice == 1) |
6402 { | 6261 { |
6403 // Deserialize criticalExtensionsFuture | 6262 // Deserialize criticalExtensionsFuture |
6404 bIterator = DeserializeSequence (&bitset0,false,bIterator); | 6263 bIterator = DeserializeSequence (&bitset0,false,bIterator); |
6405 } | 6264 } |
6406 else if (criticalExtensionsChoice == 0) | 6265 else if (criticalExtensionsChoice == 0) |
(...skipping 101 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
6508 // ... | 6367 // ... |
6509 } | 6368 } |
6510 } | 6369 } |
6511 | 6370 |
6512 return GetSerializedSize (); | 6371 return GetSerializedSize (); |
6513 } | 6372 } |
6514 | 6373 |
6515 void | 6374 void |
6516 RrcConnectionReestablishmentRejectHeader::Print (std::ostream &os) const | 6375 RrcConnectionReestablishmentRejectHeader::Print (std::ostream &os) const |
6517 { | 6376 { |
6518 NS_UNUSED(os); | |
6519 } | 6377 } |
6520 | 6378 |
6521 void | 6379 void |
6522 RrcConnectionReestablishmentRejectHeader::SetMessage (LteRrcSap::RrcConnectionRe
establishmentReject msg) | 6380 RrcConnectionReestablishmentRejectHeader::SetMessage (LteRrcSap::RrcConnectionRe
establishmentReject msg) |
6523 { | 6381 { |
6524 m_rrcConnectionReestablishmentReject = msg; | 6382 m_rrcConnectionReestablishmentReject = msg; |
6525 m_isDataSerialized = false; | 6383 m_isDataSerialized = false; |
6526 } | 6384 } |
6527 | 6385 |
6528 LteRrcSap::RrcConnectionReestablishmentReject | 6386 LteRrcSap::RrcConnectionReestablishmentReject |
(...skipping 51 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
6580 int n; | 6438 int n; |
6581 | 6439 |
6582 bIterator = DeserializeDlDcchMessage (bIterator); | 6440 bIterator = DeserializeDlDcchMessage (bIterator); |
6583 | 6441 |
6584 // Deserialize RrcConnectionRelease sequence | 6442 // Deserialize RrcConnectionRelease sequence |
6585 // 0 optional fields, no extension marker | 6443 // 0 optional fields, no extension marker |
6586 bIterator = DeserializeSequence (&bitset0,false,bIterator); | 6444 bIterator = DeserializeSequence (&bitset0,false,bIterator); |
6587 | 6445 |
6588 // Deserialize rrc-TransactionIdentifier | 6446 // Deserialize rrc-TransactionIdentifier |
6589 bIterator = DeserializeInteger (&n,0,3,bIterator); | 6447 bIterator = DeserializeInteger (&n,0,3,bIterator); |
6590 m_rrcConnectionRelease.rrcTransactionIdentifier = static_cast<uint8_t>(n); | 6448 m_rrcConnectionRelease.rrcTransactionIdentifier = static_cast<uint8_t> (n); |
6591 | 6449 |
6592 // Deserialize criticalExtensions choice | 6450 // Deserialize criticalExtensions choice |
6593 int criticalExtensionsChoice; | 6451 int criticalExtensionsChoice; |
6594 bIterator = DeserializeChoice (2,false,&criticalExtensionsChoice,bIterator); | 6452 bIterator = DeserializeChoice (2,false,&criticalExtensionsChoice,bIterator); |
6595 if (criticalExtensionsChoice == 1) | 6453 if (criticalExtensionsChoice == 1) |
6596 { | 6454 { |
6597 // Deserialize criticalExtensionsFuture | 6455 // Deserialize criticalExtensionsFuture |
6598 bIterator = DeserializeSequence (&bitset0,false,bIterator); | 6456 bIterator = DeserializeSequence (&bitset0,false,bIterator); |
6599 } | 6457 } |
6600 else if (criticalExtensionsChoice == 0) | 6458 else if (criticalExtensionsChoice == 0) |
(...skipping 33 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
6634 bIterator = DeserializeNull (bIterator); | 6492 bIterator = DeserializeNull (bIterator); |
6635 } | 6493 } |
6636 } | 6494 } |
6637 | 6495 |
6638 return GetSerializedSize (); | 6496 return GetSerializedSize (); |
6639 } | 6497 } |
6640 | 6498 |
6641 void | 6499 void |
6642 RrcConnectionReleaseHeader::Print (std::ostream &os) const | 6500 RrcConnectionReleaseHeader::Print (std::ostream &os) const |
6643 { | 6501 { |
6644 NS_UNUSED(os); | |
6645 } | 6502 } |
6646 | 6503 |
6647 void | 6504 void |
6648 RrcConnectionReleaseHeader::SetMessage (LteRrcSap::RrcConnectionRelease msg) | 6505 RrcConnectionReleaseHeader::SetMessage (LteRrcSap::RrcConnectionRelease msg) |
6649 { | 6506 { |
6650 m_rrcConnectionRelease = msg; | 6507 m_rrcConnectionRelease = msg; |
6651 m_isDataSerialized = false; | 6508 m_isDataSerialized = false; |
6652 } | 6509 } |
6653 | 6510 |
6654 LteRrcSap::RrcConnectionRelease | 6511 LteRrcSap::RrcConnectionRelease |
(...skipping 71 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
6726 { | 6583 { |
6727 bIterator = DeserializeNull (bIterator); | 6584 bIterator = DeserializeNull (bIterator); |
6728 } | 6585 } |
6729 else if (c1Choice == 0) | 6586 else if (c1Choice == 0) |
6730 { | 6587 { |
6731 // Deserialize rrcConnectionReject-r8 | 6588 // Deserialize rrcConnectionReject-r8 |
6732 std::bitset<1> opts; | 6589 std::bitset<1> opts; |
6733 bIterator = DeserializeSequence (&opts,false,bIterator); | 6590 bIterator = DeserializeSequence (&opts,false,bIterator); |
6734 | 6591 |
6735 bIterator = DeserializeInteger (&n,1,16,bIterator); | 6592 bIterator = DeserializeInteger (&n,1,16,bIterator); |
6736 m_rrcConnectionReject.waitTime = static_cast<uint8_t>(n); | 6593 m_rrcConnectionReject.waitTime = static_cast<uint8_t> (n); |
6737 | 6594 |
6738 if (opts[0]) | 6595 if (opts[0]) |
6739 { | 6596 { |
6740 // Deserialize RRCConnectionReject-v8a0-IEs | 6597 // Deserialize RRCConnectionReject-v8a0-IEs |
6741 // ... | 6598 // ... |
6742 } | 6599 } |
6743 } | 6600 } |
6744 } | 6601 } |
6745 | 6602 |
6746 return GetSerializedSize (); | 6603 return GetSerializedSize (); |
(...skipping 181 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
6928 uint32_t | 6785 uint32_t |
6929 RrcUlDcchMessage::Deserialize (Buffer::Iterator bIterator) | 6786 RrcUlDcchMessage::Deserialize (Buffer::Iterator bIterator) |
6930 { | 6787 { |
6931 DeserializeUlDcchMessage (bIterator); | 6788 DeserializeUlDcchMessage (bIterator); |
6932 return 1; | 6789 return 1; |
6933 } | 6790 } |
6934 | 6791 |
6935 void | 6792 void |
6936 RrcUlDcchMessage::Print (std::ostream &os) const | 6793 RrcUlDcchMessage::Print (std::ostream &os) const |
6937 { | 6794 { |
6938 NS_UNUSED(os); | |
6939 std::cout << "UL DCCH MSG TYPE: " << m_messageType << std::endl; | 6795 std::cout << "UL DCCH MSG TYPE: " << m_messageType << std::endl; |
6940 } | 6796 } |
6941 | 6797 |
6942 void | 6798 void |
6943 RrcUlDcchMessage::PreSerialize () const | 6799 RrcUlDcchMessage::PreSerialize () const |
6944 { | 6800 { |
6945 SerializeUlDcchMessage (m_messageType); | 6801 SerializeUlDcchMessage (m_messageType); |
6946 } | 6802 } |
6947 | 6803 |
6948 Buffer::Iterator | 6804 Buffer::Iterator |
(...skipping 41 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
6990 uint32_t | 6846 uint32_t |
6991 RrcDlDcchMessage::Deserialize (Buffer::Iterator bIterator) | 6847 RrcDlDcchMessage::Deserialize (Buffer::Iterator bIterator) |
6992 { | 6848 { |
6993 DeserializeDlDcchMessage (bIterator); | 6849 DeserializeDlDcchMessage (bIterator); |
6994 return 1; | 6850 return 1; |
6995 } | 6851 } |
6996 | 6852 |
6997 void | 6853 void |
6998 RrcDlDcchMessage::Print (std::ostream &os) const | 6854 RrcDlDcchMessage::Print (std::ostream &os) const |
6999 { | 6855 { |
7000 NS_UNUSED(os); | |
7001 std::cout << "DL DCCH MSG TYPE: " << m_messageType << std::endl; | 6856 std::cout << "DL DCCH MSG TYPE: " << m_messageType << std::endl; |
7002 } | 6857 } |
7003 | 6858 |
7004 void | 6859 void |
7005 RrcDlDcchMessage::PreSerialize () const | 6860 RrcDlDcchMessage::PreSerialize () const |
7006 { | 6861 { |
7007 SerializeDlDcchMessage (m_messageType); | 6862 SerializeDlDcchMessage (m_messageType); |
7008 } | 6863 } |
7009 | 6864 |
7010 Buffer::Iterator | 6865 Buffer::Iterator |
(...skipping 41 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
7052 uint32_t | 6907 uint32_t |
7053 RrcUlCcchMessage::Deserialize (Buffer::Iterator bIterator) | 6908 RrcUlCcchMessage::Deserialize (Buffer::Iterator bIterator) |
7054 { | 6909 { |
7055 DeserializeUlCcchMessage (bIterator); | 6910 DeserializeUlCcchMessage (bIterator); |
7056 return 1; | 6911 return 1; |
7057 } | 6912 } |
7058 | 6913 |
7059 void | 6914 void |
7060 RrcUlCcchMessage::Print (std::ostream &os) const | 6915 RrcUlCcchMessage::Print (std::ostream &os) const |
7061 { | 6916 { |
7062 NS_UNUSED(os); | |
7063 std::cout << "UL CCCH MSG TYPE: " << m_messageType << std::endl; | 6917 std::cout << "UL CCCH MSG TYPE: " << m_messageType << std::endl; |
7064 } | 6918 } |
7065 | 6919 |
7066 void | 6920 void |
7067 RrcUlCcchMessage::PreSerialize () const | 6921 RrcUlCcchMessage::PreSerialize () const |
7068 { | 6922 { |
7069 SerializeUlCcchMessage (m_messageType); | 6923 SerializeUlCcchMessage (m_messageType); |
7070 } | 6924 } |
7071 | 6925 |
7072 Buffer::Iterator | 6926 Buffer::Iterator |
(...skipping 41 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
7114 uint32_t | 6968 uint32_t |
7115 RrcDlCcchMessage::Deserialize (Buffer::Iterator bIterator) | 6969 RrcDlCcchMessage::Deserialize (Buffer::Iterator bIterator) |
7116 { | 6970 { |
7117 DeserializeDlCcchMessage (bIterator); | 6971 DeserializeDlCcchMessage (bIterator); |
7118 return 1; | 6972 return 1; |
7119 } | 6973 } |
7120 | 6974 |
7121 void | 6975 void |
7122 RrcDlCcchMessage::Print (std::ostream &os) const | 6976 RrcDlCcchMessage::Print (std::ostream &os) const |
7123 { | 6977 { |
7124 NS_UNUSED(os); | |
7125 std::cout << "DL CCCH MSG TYPE: " << m_messageType << std::endl; | 6978 std::cout << "DL CCCH MSG TYPE: " << m_messageType << std::endl; |
7126 } | 6979 } |
7127 | 6980 |
7128 void | 6981 void |
7129 RrcDlCcchMessage::PreSerialize () const | 6982 RrcDlCcchMessage::PreSerialize () const |
7130 { | 6983 { |
7131 SerializeDlCcchMessage (m_messageType); | 6984 SerializeDlCcchMessage (m_messageType); |
7132 } | 6985 } |
7133 | 6986 |
7134 Buffer::Iterator | 6987 Buffer::Iterator |
(...skipping 24 matching lines...) Expand all Loading... |
7159 { | 7012 { |
7160 SerializeSequence (std::bitset<0> (),false); | 7013 SerializeSequence (std::bitset<0> (),false); |
7161 // Choose c1 | 7014 // Choose c1 |
7162 SerializeChoice (2,0,false); | 7015 SerializeChoice (2,0,false); |
7163 // Choose message type | 7016 // Choose message type |
7164 SerializeChoice (4,messageType,false); | 7017 SerializeChoice (4,messageType,false); |
7165 } | 7018 } |
7166 | 7019 |
7167 } // namespace ns3 | 7020 } // namespace ns3 |
7168 | 7021 |
LEFT | RIGHT |