OLD | NEW |
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 * Copyright (c) 2015 Danilo Abrignani |
4 * | 5 * |
5 * This program is free software; you can redistribute it and/or modify | 6 * 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 | 7 * it under the terms of the GNU General Public License version 2 as |
7 * published by the Free Software Foundation; | 8 * published by the Free Software Foundation; |
8 * | 9 * |
9 * This program is distributed in the hope that it will be useful, | 10 * This program is distributed in the hope that it will be useful, |
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of | 11 * but WITHOUT ANY WARRANTY; without even the implied warranty of |
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | 12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
12 * GNU General Public License for more details. | 13 * GNU General Public License for more details. |
13 * | 14 * |
14 * You should have received a copy of the GNU General Public License | 15 * You should have received a copy of the GNU General Public License |
15 * along with this program; if not, write to the Free Software | 16 * along with this program; if not, write to the Free Software |
16 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA | 17 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
17 * | 18 * |
18 * Author: Lluis Parcerisa <lparcerisa@cttc.cat> | 19 * Author: Lluis Parcerisa <lparcerisa@cttc.cat> |
| 20 * Danilo Abrignani <danilo.abrignani@unibo.it> (Update to R10 - Carrier
Aggregation - GSoC 2015) |
19 */ | 21 */ |
20 | 22 |
21 #include "ns3/log.h" | 23 #include "ns3/log.h" |
22 #include "ns3/lte-rrc-header.h" | 24 #include "ns3/lte-rrc-header.h" |
23 | 25 |
24 #include <stdio.h> | 26 #include <stdio.h> |
25 #include <sstream> | 27 #include <sstream> |
26 | 28 |
27 #define MAX_DRB 11 // According to section 6.4 3GPP TS 36.331 | 29 #define MAX_DRB 11 // According to section 6.4 3GPP TS 36.331 |
28 #define MAX_EARFCN 65535 | 30 #define MAX_EARFCN 65535 |
29 #define MAX_RAT_CAPABILITIES 8 | 31 #define MAX_RAT_CAPABILITIES 8 |
30 #define MAX_SI_MESSAGE 32 | 32 #define MAX_SI_MESSAGE 32 |
31 #define MAX_SIB 32 | 33 #define MAX_SIB 32 |
32 | 34 |
33 #define MAX_REPORT_CONFIG_ID 32 | 35 #define MAX_REPORT_CONFIG_ID 32 |
34 #define MAX_OBJECT_ID 32 | 36 #define MAX_OBJECT_ID 32 |
35 #define MAX_MEAS_ID 32 | 37 #define MAX_MEAS_ID 32 |
36 #define MAX_CELL_MEAS 32 | 38 #define MAX_CELL_MEAS 32 |
37 #define MAX_CELL_REPORT 8 | 39 #define MAX_CELL_REPORT 8 |
38 | 40 |
| 41 #define MAX_SCELL_CONF 5 |
39 namespace ns3 { | 42 namespace ns3 { |
40 | 43 |
41 NS_LOG_COMPONENT_DEFINE ("RrcHeader"); | 44 NS_LOG_COMPONENT_DEFINE ("RrcHeader"); |
42 | 45 |
43 //////////////////// RrcAsn1Header class /////////////////////////////// | 46 //////////////////// RrcAsn1Header class /////////////////////////////// |
44 RrcAsn1Header::RrcAsn1Header () | 47 RrcAsn1Header::RrcAsn1Header () |
45 { | 48 { |
46 } | 49 } |
47 | 50 |
48 TypeId | 51 TypeId |
49 RrcAsn1Header::GetTypeId (void) | 52 RrcAsn1Header::GetTypeId (void) |
50 { | 53 { |
51 static TypeId tid = TypeId ("ns3::RrcAsn1Header") | 54 static TypeId tid = TypeId ("ns3::RrcAsn1Header") |
52 .SetParent<Header> () | 55 .SetParent<Header> () |
53 .SetGroupName("Lte") | 56 .SetGroupName("Lte") |
54 ; | 57 ; |
55 return tid; | 58 return tid; |
56 } | 59 } |
57 | 60 |
58 TypeId | 61 TypeId |
59 RrcAsn1Header::GetInstanceTypeId (void) const | 62 RrcAsn1Header::GetInstanceTypeId (void) const |
60 { | 63 { |
61 return GetTypeId (); | 64 return GetTypeId (); |
62 } | 65 } |
63 | 66 |
64 int | 67 int |
65 RrcAsn1Header::GetMessageType () | 68 RrcAsn1Header::GetMessageType () |
66 { | 69 { |
67 return m_messageType; | 70 return m_messageType; |
68 } | 71 } |
69 | 72 |
70 void | 73 void |
71 RrcAsn1Header::SerializeDrbToAddModList (std::list<LteRrcSap::DrbToAddMod> drbTo
AddModList) const | 74 RrcAsn1Header::SerializeDrbToAddModList (std::list<LteRrcSap::DrbToAddMod> drb
ToAddModList) const |
72 { | 75 { |
73 // Serialize DRB-ToAddModList sequence-of | 76 // Serialize DRB-ToAddModList sequence-of |
74 SerializeSequenceOf (drbToAddModList.size (),MAX_DRB,1); | 77 SerializeSequenceOf (drbToAddModList.size (),MAX_DRB,1); |
75 | 78 |
76 // Serialize the elements in the sequence-of list | 79 // Serialize the elements in the sequence-of list |
77 std::list<LteRrcSap::DrbToAddMod>::iterator it = drbToAddModList.begin (); | 80 std::list<LteRrcSap::DrbToAddMod>::iterator it = drbToAddModList.begin (); |
78 for (; it != drbToAddModList.end (); it++) | 81 for (; it != drbToAddModList.end (); it++) |
79 { | 82 { |
80 // Serialize DRB-ToAddMod sequence | 83 // Serialize DRB-ToAddMod sequence |
81 // 5 otional fields. Extension marker is present. | 84 // 5 otional fields. Extension marker is present. |
82 std::bitset<5> drbToAddModListOptionalFieldsPresent = std::bitset<5> (); | 85 std::bitset<5> drbToAddModListOptionalFieldsPresent = std::bitset<5> (); |
83 drbToAddModListOptionalFieldsPresent.set (4,1); // eps-BearerIdentity pres
ent | 86 drbToAddModListOptionalFieldsPresent.set (4,1); // eps-BearerIdentity pr
esent |
84 drbToAddModListOptionalFieldsPresent.set (3,0); // pdcp-Config not present | 87 drbToAddModListOptionalFieldsPresent.set (3,0); // pdcp-Config not prese
nt |
85 drbToAddModListOptionalFieldsPresent.set (2,1); // rlc-Config present | 88 drbToAddModListOptionalFieldsPresent.set (2,1); // rlc-Config present |
86 drbToAddModListOptionalFieldsPresent.set (1,1); // logicalChannelIdentity
present | 89 drbToAddModListOptionalFieldsPresent.set (1,1); // logicalChannelIdentit
y present |
87 drbToAddModListOptionalFieldsPresent.set (0,1); // logicalChannelConfig pr
esent | 90 drbToAddModListOptionalFieldsPresent.set (0,1); // logicalChannelConfig
present |
88 SerializeSequence (drbToAddModListOptionalFieldsPresent,true); | 91 SerializeSequence (drbToAddModListOptionalFieldsPresent,true); |
89 | 92 |
90 // Serialize eps-BearerIdentity::=INTEGER (0..15) | 93 // Serialize eps-BearerIdentity::=INTEGER (0..15) |
91 SerializeInteger (it->epsBearerIdentity,0,15); | 94 SerializeInteger (it->epsBearerIdentity,0,15); |
92 | 95 |
93 // Serialize drb-Identity ::= INTEGER (1..32) | 96 // Serialize drb-Identity ::= INTEGER (1..32) |
94 SerializeInteger (it->drbIdentity,1,32); | 97 SerializeInteger (it->drbIdentity,1,32); |
95 | 98 |
96 switch (it->rlcConfig.choice) | 99 switch (it->rlcConfig.choice) |
97 { | 100 { |
98 case LteRrcSap::RlcConfig::UM_BI_DIRECTIONAL: | 101 case LteRrcSap::RlcConfig::UM_BI_DIRECTIONAL: |
99 // Serialize rlc-Config choice | 102 // Serialize rlc-Config choice |
100 SerializeChoice (4,1,true); | 103 SerializeChoice (4,1,true); |
101 | 104 |
102 // Serialize UL-UM-RLC | 105 // Serialize UL-UM-RLC |
103 SerializeSequence (std::bitset<0> (),false); | 106 SerializeSequence (std::bitset<0> (),false); |
104 SerializeEnum (2,0); // sn-FieldLength | 107 SerializeEnum (2,0); // sn-FieldLength |
105 | 108 |
106 // Serialize DL-UM-RLC | 109 // Serialize DL-UM-RLC |
107 SerializeSequence (std::bitset<0> (),false); | 110 SerializeSequence (std::bitset<0> (),false); |
108 SerializeEnum (2,0); // sn-FieldLength | 111 SerializeEnum (2,0); // sn-FieldLength |
109 SerializeEnum (32,0); // t-Reordering | 112 SerializeEnum (32,0); // t-Reordering |
110 break; | 113 break; |
111 | 114 |
112 case LteRrcSap::RlcConfig::UM_UNI_DIRECTIONAL_UL: | 115 case LteRrcSap::RlcConfig::UM_UNI_DIRECTIONAL_UL: |
113 // Serialize rlc-Config choice | 116 // Serialize rlc-Config choice |
114 SerializeChoice (4,2,true); | 117 SerializeChoice (4,2,true); |
115 | 118 |
116 // Serialize UL-UM-RLC | 119 // Serialize UL-UM-RLC |
117 SerializeSequence (std::bitset<0> (),false); | 120 SerializeSequence (std::bitset<0> (),false); |
118 SerializeEnum (2,0); // sn-FieldLength | 121 SerializeEnum (2,0); // sn-FieldLength |
119 break; | 122 break; |
120 | 123 |
121 case LteRrcSap::RlcConfig::UM_UNI_DIRECTIONAL_DL: | 124 case LteRrcSap::RlcConfig::UM_UNI_DIRECTIONAL_DL: |
122 // Serialize rlc-Config choice | 125 // Serialize rlc-Config choice |
123 SerializeChoice (4,3,true); | 126 SerializeChoice (4,3,true); |
124 | 127 |
125 // Serialize DL-UM-RLC | 128 // Serialize DL-UM-RLC |
126 SerializeSequence (std::bitset<0> (),false); | 129 SerializeSequence (std::bitset<0> (),false); |
127 SerializeEnum (2,0); // sn-FieldLength | 130 SerializeEnum (2,0); // sn-FieldLength |
128 SerializeEnum (32,0); // t-Reordering | 131 SerializeEnum (32,0); // t-Reordering |
129 break; | 132 break; |
130 | 133 |
131 case LteRrcSap::RlcConfig::AM: | 134 case LteRrcSap::RlcConfig::AM: |
132 default: | 135 default: |
133 // Serialize rlc-Config choice | 136 // Serialize rlc-Config choice |
134 SerializeChoice (4,0,true); | 137 SerializeChoice (4,0,true); |
135 | 138 |
136 // Serialize UL-AM-RLC | 139 // Serialize UL-AM-RLC |
137 SerializeSequence (std::bitset<0> (),false); | 140 SerializeSequence (std::bitset<0> (),false); |
138 SerializeEnum (64,0); // t-PollRetransmit | 141 SerializeEnum (64,0); // t-PollRetransmit |
139 SerializeEnum (8,0); // pollPDU | 142 SerializeEnum (8,0); // pollPDU |
140 SerializeEnum (16,0); // pollByte | 143 SerializeEnum (16,0); // pollByte |
141 SerializeEnum (8,0); // maxRetxThreshold | 144 SerializeEnum (8,0); // maxRetxThreshold |
142 | 145 |
143 // Serialize DL-AM-RLC | 146 // Serialize DL-AM-RLC |
144 SerializeSequence (std::bitset<0> (),false); | 147 SerializeSequence (std::bitset<0> (),false); |
145 SerializeEnum (32,0); // t-Reordering | 148 SerializeEnum (32,0); // t-Reordering |
146 SerializeEnum (64,0); // t-StatusProhibit | 149 SerializeEnum (64,0); // t-StatusProhibit |
147 break; | 150 break; |
148 } | 151 } |
149 | 152 |
150 // Serialize logicalChannelIdentity ::=INTEGER (3..10) | 153 // Serialize logicalChannelIdentity ::=INTEGER (3..10) |
151 SerializeInteger (it->logicalChannelIdentity,3,10); | 154 SerializeInteger (it->logicalChannelIdentity,3,10); |
152 | 155 |
153 // Serialize logicalChannelConfig | 156 // Serialize logicalChannelConfig |
154 SerializeLogicalChannelConfig (it->logicalChannelConfig); | 157 SerializeLogicalChannelConfig (it->logicalChannelConfig); |
155 } | 158 } |
156 } | 159 } |
157 | 160 |
158 void | 161 void |
159 RrcAsn1Header::SerializeSrbToAddModList (std::list<LteRrcSap::SrbToAddMod> srbTo
AddModList) const | 162 RrcAsn1Header::SerializeSrbToAddModList (std::list<LteRrcSap::SrbToAddMod> srb
ToAddModList) const |
160 { | 163 { |
161 // Serialize SRB-ToAddModList ::= SEQUENCE (SIZE (1..2)) OF SRB-ToAddMod | 164 // Serialize SRB-ToAddModList ::= SEQUENCE (SIZE (1..2)) OF SRB-ToAddMod |
162 SerializeSequenceOf (srbToAddModList.size (),2,1); | 165 SerializeSequenceOf (srbToAddModList.size (),2,1); |
163 | 166 |
164 // Serialize the elements in the sequence-of list | 167 // Serialize the elements in the sequence-of list |
165 std::list<LteRrcSap::SrbToAddMod>::iterator it = srbToAddModList.begin (); | 168 std::list<LteRrcSap::SrbToAddMod>::iterator it = srbToAddModList.begin (); |
166 for (; it != srbToAddModList.end (); it++) | 169 for (; it != srbToAddModList.end (); it++) |
167 { | 170 { |
168 // Serialize SRB-ToAddMod sequence | 171 // Serialize SRB-ToAddMod sequence |
169 // 2 otional fields. Extension marker is present. | 172 // 2 otional fields. Extension marker is present. |
170 std::bitset<2> srbToAddModListOptionalFieldsPresent = std::bitset<2> (); | 173 std::bitset<2> srbToAddModListOptionalFieldsPresent = std::bitset<2> (); |
171 srbToAddModListOptionalFieldsPresent.set (1,0); // rlc-Config not present | 174 srbToAddModListOptionalFieldsPresent.set (1,0); // rlc-Config not presen
t |
172 srbToAddModListOptionalFieldsPresent.set (0,1); // logicalChannelConfig pr
esent | 175 srbToAddModListOptionalFieldsPresent.set (0,1); // logicalChannelConfig
present |
173 SerializeSequence (srbToAddModListOptionalFieldsPresent,true); | 176 SerializeSequence (srbToAddModListOptionalFieldsPresent,true); |
174 | 177 |
175 // Serialize srb-Identity ::= INTEGER (1..2) | 178 // Serialize srb-Identity ::= INTEGER (1..2) |
176 SerializeInteger (it->srbIdentity,1,2); | 179 SerializeInteger (it->srbIdentity,1,2); |
177 | 180 |
178 // Serialize logicalChannelConfig choice | 181 // Serialize logicalChannelConfig choice |
179 // 2 options, selected option 0 (var "explicitValue", of type LogicalChann
elConfig) | 182 // 2 options, selected option 0 (var "explicitValue", of type LogicalCha
nnelConfig) |
180 SerializeChoice (2,0,false); | 183 SerializeChoice (2,0,false); |
181 | 184 |
182 // Serialize LogicalChannelConfig· | 185 // Serialize LogicalChannelConfig· |
183 SerializeLogicalChannelConfig (it->logicalChannelConfig); | 186 SerializeLogicalChannelConfig (it->logicalChannelConfig); |
184 } | 187 } |
185 } | 188 } |
186 | 189 |
187 void | 190 void |
188 RrcAsn1Header::SerializeLogicalChannelConfig (LteRrcSap::LogicalChannelConfig lo
gicalChannelConfig) const | 191 RrcAsn1Header::SerializeLogicalChannelConfig (LteRrcSap::LogicalChannelConfig
logicalChannelConfig) const |
189 { | 192 { |
190 // Serialize LogicalChannelConfig sequence | 193 // Serialize LogicalChannelConfig sequence |
191 // 1 optional field (ul-SpecificParameters), which is present. Extension marke
r present. | 194 // 1 optional field (ul-SpecificParameters), which is present. Extension mar
ker present. |
192 SerializeSequence (std::bitset<1> (1),true); | 195 SerializeSequence (std::bitset<1> (1),true); |
193 | 196 |
194 // Serialize ul-SpecificParameters sequence | 197 // Serialize ul-SpecificParameters sequence |
195 // 1 optional field (logicalChannelGroup), which is present. No extension mark
er. | 198 // 1 optional field (logicalChannelGroup), which is present. No extension ma
rker. |
196 SerializeSequence (std::bitset<1> (1),false); | 199 SerializeSequence (std::bitset<1> (1),false); |
197 | 200 |
198 // Serialize priority ::= INTEGER (1..16) | 201 // Serialize priority ::= INTEGER (1..16) |
199 SerializeInteger (logicalChannelConfig.priority,1,16); | 202 SerializeInteger (logicalChannelConfig.priority,1,16); |
200 | 203 |
201 // Serialize prioritisedBitRate | 204 // Serialize prioritisedBitRate |
202 int prioritizedBitRate; | 205 int prioritizedBitRate; |
203 switch (logicalChannelConfig.prioritizedBitRateKbps) | 206 switch (logicalChannelConfig.prioritizedBitRateKbps) |
204 { | 207 { |
205 case 0: | 208 case 0: |
206 prioritizedBitRate = 0; | 209 prioritizedBitRate = 0; |
207 break; | 210 break; |
208 case 8: | 211 case 8: |
209 prioritizedBitRate = 1; | 212 prioritizedBitRate = 1; |
210 break; | 213 break; |
211 case 16: | 214 case 16: |
212 prioritizedBitRate = 2; | 215 prioritizedBitRate = 2; |
213 break; | 216 break; |
214 case 32: | 217 case 32: |
215 prioritizedBitRate = 3; | 218 prioritizedBitRate = 3; |
216 break; | 219 break; |
217 case 64: | 220 case 64: |
218 prioritizedBitRate = 4; | 221 prioritizedBitRate = 4; |
219 break; | 222 break; |
220 case 128: | 223 case 128: |
221 prioritizedBitRate = 5; | 224 prioritizedBitRate = 5; |
222 break; | 225 break; |
223 case 256: | 226 case 256: |
224 prioritizedBitRate = 6; | 227 prioritizedBitRate = 6; |
225 break; | 228 break; |
226 default: | 229 default: |
227 prioritizedBitRate = 7; // Infinity | 230 prioritizedBitRate = 7; // Infinity |
228 } | 231 } |
229 SerializeEnum (16,prioritizedBitRate); | 232 SerializeEnum (16,prioritizedBitRate); |
230 | 233 |
231 // Serialize bucketSizeDuration | 234 // Serialize bucketSizeDuration |
232 int bucketSizeDuration; | 235 int bucketSizeDuration; |
233 switch (logicalChannelConfig.bucketSizeDurationMs) | 236 switch (logicalChannelConfig.bucketSizeDurationMs) |
234 { | 237 { |
235 case 50: | 238 case 50: |
236 bucketSizeDuration = 0; | 239 bucketSizeDuration = 0; |
237 break; | 240 break; |
238 case 100: | 241 case 100: |
239 bucketSizeDuration = 1; | 242 bucketSizeDuration = 1; |
240 break; | 243 break; |
241 case 150: | 244 case 150: |
242 bucketSizeDuration = 2; | 245 bucketSizeDuration = 2; |
243 break; | 246 break; |
244 case 300: | 247 case 300: |
245 bucketSizeDuration = 3; | 248 bucketSizeDuration = 3; |
246 break; | 249 break; |
247 case 500: | 250 case 500: |
248 bucketSizeDuration = 4; | 251 bucketSizeDuration = 4; |
249 break; | 252 break; |
250 case 1000: | 253 case 1000: |
251 bucketSizeDuration = 5; | 254 bucketSizeDuration = 5; |
252 break; | 255 break; |
253 default: | 256 default: |
254 bucketSizeDuration = 5; | 257 bucketSizeDuration = 5; |
255 } | 258 } |
256 SerializeEnum (8,bucketSizeDuration); | 259 SerializeEnum (8,bucketSizeDuration); |
257 | 260 |
258 // Serialize logicalChannelGroup ::= INTEGER (0..3) | 261 // Serialize logicalChannelGroup ::= INTEGER (0..3) |
259 SerializeInteger (logicalChannelConfig.logicalChannelGroup,0,3); | 262 SerializeInteger (logicalChannelConfig.logicalChannelGroup,0,3); |
260 } | 263 } |
261 | 264 |
262 void | 265 void |
263 RrcAsn1Header::SerializePhysicalConfigDedicated (LteRrcSap::PhysicalConfigDedica
ted physicalConfigDedicated) const | 266 RrcAsn1Header::SerializePhysicalConfigDedicated (LteRrcSap::PhysicalConfigDedi
cated physicalConfigDedicated) const |
264 { | 267 { |
265 // Serialize PhysicalConfigDedicated Sequence | 268 // Serialize PhysicalConfigDedicated Sequence |
266 std::bitset<10> optionalFieldsPhysicalConfigDedicated; | 269 std::bitset<10> optionalFieldsPhysicalConfigDedicated; |
267 optionalFieldsPhysicalConfigDedicated.set (9,physicalConfigDedicated.havePdsch
ConfigDedicated); // pdsch-ConfigDedicated | 270 optionalFieldsPhysicalConfigDedicated.set (9,physicalConfigDedicated.havePds
chConfigDedicated); // pdsch-ConfigDedicated |
268 optionalFieldsPhysicalConfigDedicated.set (8,0); // pucch-ConfigDedicated not
present | 271 optionalFieldsPhysicalConfigDedicated.set (8,0); // pucch-ConfigDedicated n
ot present |
269 optionalFieldsPhysicalConfigDedicated.set (7,0); // pusch-ConfigDedicated not
present | 272 optionalFieldsPhysicalConfigDedicated.set (7,0); // pusch-ConfigDedicated n
ot present |
270 optionalFieldsPhysicalConfigDedicated.set (6,0); // uplinkPowerControlDedicat
ed not present | 273 optionalFieldsPhysicalConfigDedicated.set (6,0); // uplinkPowerControlDedic
ated not present |
271 optionalFieldsPhysicalConfigDedicated.set (5,0); // tpc-PDCCH-ConfigPUCCH not
present | 274 optionalFieldsPhysicalConfigDedicated.set (5,0); // tpc-PDCCH-ConfigPUCCH n
ot present |
272 optionalFieldsPhysicalConfigDedicated.set (4,0); // tpc-PDCCH-ConfigPUSCH not
present | 275 optionalFieldsPhysicalConfigDedicated.set (4,0); // tpc-PDCCH-ConfigPUSCH n
ot present |
273 optionalFieldsPhysicalConfigDedicated.set (3,0); // cqi-ReportConfig not pres
ent | 276 optionalFieldsPhysicalConfigDedicated.set (3,0); // cqi-ReportConfig not pr
esent |
274 optionalFieldsPhysicalConfigDedicated.set (2,physicalConfigDedicated.haveSound
ingRsUlConfigDedicated); // soundingRS-UL-ConfigDedicated | 277 optionalFieldsPhysicalConfigDedicated.set (2,physicalConfigDedicated.haveSou
ndingRsUlConfigDedicated); // soundingRS-UL-ConfigDedicated |
275 optionalFieldsPhysicalConfigDedicated.set (1,physicalConfigDedicated.haveAnten
naInfoDedicated); // antennaInfo | 278 optionalFieldsPhysicalConfigDedicated.set (1,physicalConfigDedicated.haveAnt
ennaInfoDedicated); // antennaInfo |
276 optionalFieldsPhysicalConfigDedicated.set (0,0); // schedulingRequestConfig n
ot present | 279 optionalFieldsPhysicalConfigDedicated.set (0,0); // schedulingRequestConfig
not present |
277 SerializeSequence (optionalFieldsPhysicalConfigDedicated,true); | 280 SerializeSequence (optionalFieldsPhysicalConfigDedicated,true); |
278 | 281 |
279 if (physicalConfigDedicated.havePdschConfigDedicated) | 282 if (physicalConfigDedicated.havePdschConfigDedicated) |
280 { | 283 { |
281 // Serialize Pdsch-ConfigDedicated Sequence: | 284 // Serialize Pdsch-ConfigDedicated Sequence: |
282 // 0 optional / default fields, no extension marker. | 285 // 0 optional / default fields, no extension marker. |
283 SerializeSequence (std::bitset<0> (),false); | 286 SerializeSequence (std::bitset<0> (),false); |
284 | 287 |
285 // Serialize p-a | 288 // Serialize p-a |
286 // Assuming the value in the struct is the enum index | 289 // Assuming the value in the struct is the enum index |
287 SerializeEnum (8,physicalConfigDedicated.pdschConfigDedicated.pa); | 290 SerializeEnum (8,physicalConfigDedicated.pdschConfigDedicated.pa); |
288 | 291 |
289 // Serialize release | 292 // Serialize release |
290 SerializeNull (); | 293 SerializeNull (); |
291 } | 294 } |
292 | 295 |
293 if (physicalConfigDedicated.haveSoundingRsUlConfigDedicated) | 296 if (physicalConfigDedicated.haveSoundingRsUlConfigDedicated) |
294 { | 297 { |
295 // Serialize SoundingRS-UL-ConfigDedicated choice: | 298 // Serialize SoundingRS-UL-ConfigDedicated choice: |
296 switch (physicalConfigDedicated.soundingRsUlConfigDedicated.type) | 299 switch (physicalConfigDedicated.soundingRsUlConfigDedicated.type) |
297 { | 300 { |
298 case LteRrcSap::SoundingRsUlConfigDedicated::RESET: | 301 case LteRrcSap::SoundingRsUlConfigDedicated::RESET: |
299 SerializeChoice (2,0,false); | 302 SerializeChoice (2,0,false); |
300 SerializeNull (); | 303 SerializeNull (); |
301 break; | 304 break; |
302 | 305 |
303 case LteRrcSap::SoundingRsUlConfigDedicated::SETUP: | 306 case LteRrcSap::SoundingRsUlConfigDedicated::SETUP: |
304 default: | 307 default: |
305 // 2 options, selected: 1 (setup) | 308 // 2 options, selected: 1 (setup) |
306 SerializeChoice (2,1,false); | 309 SerializeChoice (2,1,false); |
307 | 310 |
308 // Serialize setup sequence | 311 // Serialize setup sequence |
309 // 0 optional / default fields, no extension marker. | 312 // 0 optional / default fields, no extension marker. |
310 SerializeSequence (std::bitset<0> (),false); | 313 SerializeSequence (std::bitset<0> (),false); |
311 | 314 |
312 // Serialize srs-Bandwidth | 315 // Serialize srs-Bandwidth |
313 SerializeEnum (4,physicalConfigDedicated.soundingRsUlConfigDedicated.s
rsBandwidth); | 316 SerializeEnum (4,physicalConfigDedicated.soundingRsUlConfigDedicated
.srsBandwidth); |
314 | 317 |
315 // Serialize srs-HoppingBandwidth | 318 // Serialize srs-HoppingBandwidth |
316 SerializeEnum (4,0); | 319 SerializeEnum (4,0); |
317 | 320 |
318 // Serialize freqDomainPosition | 321 // Serialize freqDomainPosition |
319 SerializeInteger (0,0,23); | 322 SerializeInteger (0,0,23); |
320 | 323 |
321 // Serialize duration | 324 // Serialize duration |
322 SerializeBoolean (false); | 325 SerializeBoolean (false); |
323 | 326 |
324 // Serialize srs-ConfigIndex | 327 // Serialize srs-ConfigIndex |
325 SerializeInteger (physicalConfigDedicated.soundingRsUlConfigDedicated.
srsConfigIndex,0,1023); | 328 SerializeInteger (physicalConfigDedicated.soundingRsUlConfigDedicate
d.srsConfigIndex,0,1023); |
326 | 329 |
327 // Serialize transmissionComb | 330 // Serialize transmissionComb |
328 SerializeInteger (0,0,1); | 331 SerializeInteger (0,0,1); |
329 | 332 |
330 // Serialize cyclicShift | 333 // Serialize cyclicShift |
331 SerializeEnum (8,0); | 334 SerializeEnum (8,0); |
332 | 335 |
333 break; | 336 break; |
334 } | 337 } |
335 } | 338 } |
336 | 339 |
337 if (physicalConfigDedicated.haveAntennaInfoDedicated) | 340 if (physicalConfigDedicated.haveAntennaInfoDedicated) |
338 { | 341 { |
339 // Serialize antennaInfo choice | 342 // Serialize antennaInfo choice |
340 // 2 options. Selected: 0 ("explicitValue" of type "AntennaInfoDedicated") | 343 // 2 options. Selected: 0 ("explicitValue" of type "AntennaInfoDedicated
") |
341 SerializeChoice (2,0,false); | 344 SerializeChoice (2,0,false); |
342 | 345 |
343 // Serialize AntennaInfoDedicated sequence | 346 // Serialize AntennaInfoDedicated sequence |
344 // 1 optional parameter, not present. No extension marker. | 347 // 1 optional parameter, not present. No extension marker. |
345 SerializeSequence (std::bitset<1> (0),false); | 348 SerializeSequence (std::bitset<1> (0),false); |
346 | 349 |
347 // Serialize transmissionMode | 350 // Serialize transmissionMode |
348 // Assuming the value in the struct is the enum index | 351 // Assuming the value in the struct is the enum index |
349 SerializeEnum (8,physicalConfigDedicated.antennaInfo.transmissionMode); | 352 SerializeEnum (8,physicalConfigDedicated.antennaInfo.transmissionMode); |
350 | 353 |
351 // Serialize ue-TransmitAntennaSelection choice | 354 // Serialize ue-TransmitAntennaSelection choice |
352 SerializeChoice (2,0,false); | 355 SerializeChoice (2,0,false); |
353 | 356 |
354 // Serialize release | 357 // Serialize release |
355 SerializeNull (); | 358 SerializeNull (); |
356 } | 359 } |
357 } | 360 } |
358 | 361 |
359 void | 362 void |
360 RrcAsn1Header::SerializeRadioResourceConfigDedicated (LteRrcSap::RadioResourceCo
nfigDedicated radioResourceConfigDedicated) const | 363 RrcAsn1Header::SerializeRadioResourceConfigDedicated (LteRrcSap::RadioResource
ConfigDedicated radioResourceConfigDedicated) const |
361 { | 364 { |
362 bool isSrbToAddModListPresent = !radioResourceConfigDedicated.srbToAddModList.
empty (); | 365 bool isSrbToAddModListPresent = !radioResourceConfigDedicated.srbToAddModLis
t.empty (); |
363 bool isDrbToAddModListPresent = !radioResourceConfigDedicated.drbToAddModList.
empty (); | 366 bool isDrbToAddModListPresent = !radioResourceConfigDedicated.drbToAddModLis
t.empty (); |
364 bool isDrbToReleaseListPresent = !radioResourceConfigDedicated.drbToReleaseLis
t.empty (); | 367 bool isDrbToReleaseListPresent = !radioResourceConfigDedicated.drbToReleaseL
ist.empty (); |
365 | 368 |
366 // 6 optional fields. Extension marker is present. | 369 // 6 optional fields. Extension marker is present. |
367 std::bitset<6> optionalFieldsPresent = std::bitset<6> (); | 370 std::bitset<6> optionalFieldsPresent = std::bitset<6> (); |
368 optionalFieldsPresent.set (5,isSrbToAddModListPresent); // srb-ToAddModList p
resent | 371 optionalFieldsPresent.set (5,isSrbToAddModListPresent); // srb-ToAddModList
present |
369 optionalFieldsPresent.set (4,isDrbToAddModListPresent); // drb-ToAddModList p
resent | 372 optionalFieldsPresent.set (4,isDrbToAddModListPresent); // drb-ToAddModList
present |
370 optionalFieldsPresent.set (3,isDrbToReleaseListPresent); // drb-ToReleaseList
present | 373 optionalFieldsPresent.set (3,isDrbToReleaseListPresent); // drb-ToReleaseLi
st present |
371 optionalFieldsPresent.set (2,0); // mac-MainConfig not present | 374 optionalFieldsPresent.set (2,0); // mac-MainConfig not present |
372 optionalFieldsPresent.set (1,0); // sps-Config not present | 375 optionalFieldsPresent.set (1,0); // sps-Config not present |
373 optionalFieldsPresent.set (0,(radioResourceConfigDedicated.havePhysicalConfigD
edicated) ? 1 : 0); | 376 optionalFieldsPresent.set (0,(radioResourceConfigDedicated.havePhysicalConfi
gDedicated) ? 1 : 0); |
374 SerializeSequence (optionalFieldsPresent,true); | 377 SerializeSequence (optionalFieldsPresent,true); |
375 | 378 |
376 // Serialize srbToAddModList | 379 // Serialize srbToAddModList |
377 if (isSrbToAddModListPresent) | 380 if (isSrbToAddModListPresent) |
378 { | 381 { |
379 SerializeSrbToAddModList (radioResourceConfigDedicated.srbToAddModList); | 382 SerializeSrbToAddModList (radioResourceConfigDedicated.srbToAddModList); |
380 } | 383 } |
381 | 384 |
382 // Serialize drbToAddModList | 385 // Serialize drbToAddModList |
383 if (isDrbToAddModListPresent) | 386 if (isDrbToAddModListPresent) |
384 { | 387 { |
385 SerializeDrbToAddModList (radioResourceConfigDedicated.drbToAddModList); | 388 SerializeDrbToAddModList (radioResourceConfigDedicated.drbToAddModList); |
386 } | 389 } |
387 | 390 |
388 // Serialize drbToReleaseList | 391 // Serialize drbToReleaseList |
389 if (isDrbToReleaseListPresent) | 392 if (isDrbToReleaseListPresent) |
390 { | 393 { |
391 SerializeSequenceOf (radioResourceConfigDedicated.drbToReleaseList.size ()
,MAX_DRB,1); | 394 SerializeSequenceOf (radioResourceConfigDedicated.drbToReleaseList.size
(),MAX_DRB,1); |
392 std::list<uint8_t>::iterator it = radioResourceConfigDedicated.drbToReleas
eList.begin (); | 395 std::list<uint8_t>::iterator it = radioResourceConfigDedicated.drbToRele
aseList.begin (); |
393 for (; it != radioResourceConfigDedicated.drbToReleaseList.end (); it++) | 396 for (; it != radioResourceConfigDedicated.drbToReleaseList.end (); it++) |
394 { | 397 { |
395 // DRB-Identity ::= INTEGER (1..32) | 398 // DRB-Identity ::= INTEGER (1..32) |
396 SerializeInteger (*it,1,32); | 399 SerializeInteger (*it,1,32); |
397 } | 400 } |
398 } | 401 } |
399 | 402 |
400 if (radioResourceConfigDedicated.havePhysicalConfigDedicated) | 403 if (radioResourceConfigDedicated.havePhysicalConfigDedicated) |
401 { | 404 { |
402 SerializePhysicalConfigDedicated (radioResourceConfigDedicated.physicalCon
figDedicated); | 405 SerializePhysicalConfigDedicated (radioResourceConfigDedicated.physicalC
onfigDedicated); |
403 } | 406 } |
404 } | 407 } |
405 | 408 |
406 void | 409 void |
407 RrcAsn1Header::SerializeSystemInformationBlockType1 (LteRrcSap::SystemInformatio
nBlockType1 systemInformationBlockType1) const | 410 RrcAsn1Header::SerializeSystemInformationBlockType1 (LteRrcSap::SystemInformat
ionBlockType1 systemInformationBlockType1) const |
408 { | 411 { |
409 // 3 optional fields, no extension marker. | 412 // 3 optional fields, no extension marker. |
410 std::bitset<3> sysInfoBlk1Opts; | 413 std::bitset<3> sysInfoBlk1Opts; |
411 sysInfoBlk1Opts.set (2,0); // p-Max absent | 414 sysInfoBlk1Opts.set (2,0); // p-Max absent |
412 sysInfoBlk1Opts.set (1,0); // tdd-Config absent | 415 sysInfoBlk1Opts.set (1,0); // tdd-Config absent |
413 sysInfoBlk1Opts.set (0,0); // nonCriticalExtension absent | 416 sysInfoBlk1Opts.set (0,0); // nonCriticalExtension absent |
414 SerializeSequence (sysInfoBlk1Opts,false); | 417 SerializeSequence (sysInfoBlk1Opts,false); |
415 | 418 |
416 // Serialize cellAccessRelatedInfo | 419 // Serialize cellAccessRelatedInfo |
417 // 1 optional field (csgIdentity) which is present, no extension marker. | 420 // 1 optional field (csgIdentity) which is present, no extension marker. |
418 SerializeSequence (std::bitset<1> (1),false); | 421 SerializeSequence (std::bitset<1> (1),false); |
419 | 422 |
420 // Serialize plmn-IdentityList | 423 // Serialize plmn-IdentityList |
421 SerializeSequenceOf (1,6,1); | 424 SerializeSequenceOf (1,6,1); |
422 | 425 |
423 // PLMN-IdentityInfo· | 426 // PLMN-IdentityInfo· |
424 SerializeSequence (std::bitset<0> (),false); | 427 SerializeSequence (std::bitset<0> (),false); |
425 | 428 |
426 SerializePlmnIdentity (systemInformationBlockType1.cellAccessRelatedInfo.plmnI
dentityInfo.plmnIdentity); | 429 SerializePlmnIdentity (systemInformationBlockType1.cellAccessRelatedInfo.plm
nIdentityInfo.plmnIdentity); |
427 | 430 |
428 // Serialize trackingAreaCode | 431 // Serialize trackingAreaCode |
429 SerializeBitstring (std::bitset<16> (0)); | 432 SerializeBitstring (std::bitset<16> (0)); |
430 // Serialize cellIdentity | 433 // Serialize cellIdentity |
431 SerializeBitstring (std::bitset<28> (systemInformationBlockType1.cellAccessRel
atedInfo.cellIdentity)); | 434 SerializeBitstring (std::bitset<28> (systemInformationBlockType1.cellAccessR
elatedInfo.cellIdentity)); |
432 // Serialize cellBarred | 435 // Serialize cellBarred |
433 SerializeEnum (2,0); | 436 SerializeEnum (2,0); |
434 // Serialize intraFreqReselection | 437 // Serialize intraFreqReselection |
435 SerializeEnum (2,0); | 438 SerializeEnum (2,0); |
436 // Serialize csg-Indication | 439 // Serialize csg-Indication |
437 SerializeBoolean (systemInformationBlockType1.cellAccessRelatedInfo.csgIndicat
ion); | 440 SerializeBoolean (systemInformationBlockType1.cellAccessRelatedInfo.csgIndic
ation); |
438 // Serialize csg-Identity | 441 // Serialize csg-Identity |
439 SerializeBitstring (std::bitset<27> (systemInformationBlockType1.cellAccessRel
atedInfo.csgIdentity)); | 442 SerializeBitstring (std::bitset<27> (systemInformationBlockType1.cellAccessR
elatedInfo.csgIdentity)); |
440 | 443 |
441 // Serialize cellSelectionInfo | 444 // Serialize cellSelectionInfo |
442 SerializeSequence (std::bitset<1> (0),false); | 445 SerializeSequence (std::bitset<1> (0),false); |
443 // Serialize q-RxLevMin | 446 // Serialize q-RxLevMin |
444 SerializeInteger (-50,-70,-22); | 447 SerializeInteger (-50,-70,-22); |
445 | 448 |
446 // Serialize freqBandIndicator | 449 // Serialize freqBandIndicator |
447 SerializeInteger (1,1,64); | 450 SerializeInteger (1,1,64); |
448 | 451 |
449 // Serialize schedulingInfoList | 452 // Serialize schedulingInfoList |
450 SerializeSequenceOf (1,MAX_SI_MESSAGE,1); | 453 SerializeSequenceOf (1,MAX_SI_MESSAGE,1); |
451 // SchedulingInfo | 454 // SchedulingInfo |
452 SerializeSequence (std::bitset<0> (),false); | 455 SerializeSequence (std::bitset<0> (),false); |
453 // si-Periodicity | 456 // si-Periodicity |
454 SerializeEnum (7,0); | 457 SerializeEnum (7,0); |
455 // sib-MappingInfo | 458 // sib-MappingInfo |
456 SerializeSequenceOf (0,MAX_SIB - 1,0); | 459 SerializeSequenceOf (0,MAX_SIB - 1,0); |
457 | 460 |
458 // Serialize si-WindowLength | 461 // Serialize si-WindowLength |
459 SerializeEnum (7,0); | 462 SerializeEnum (7,0); |
460 | 463 |
461 // Serialize systemInfoValueTag | 464 // Serialize systemInfoValueTag |
462 SerializeInteger (0,0,31); | 465 SerializeInteger (0,0,31); |
463 } | 466 } |
464 | 467 |
465 void | 468 void |
466 RrcAsn1Header::SerializeRadioResourceConfigCommon (LteRrcSap::RadioResourceConfi
gCommon radioResourceConfigCommon) const | 469 RrcAsn1Header::SerializeRadioResourceConfigCommon (LteRrcSap::RadioResourceCon
figCommon radioResourceConfigCommon) const |
467 { | 470 { |
468 // 9 optional fields. Extension marker yes. | 471 // 9 optional fields. Extension marker yes. |
469 std::bitset<9> rrCfgCmmOpts; | 472 std::bitset<9> rrCfgCmmOpts; |
470 rrCfgCmmOpts.set (8,1); // rach-ConfigCommon is present | 473 rrCfgCmmOpts.set (8,1); // rach-ConfigCommon is present |
471 rrCfgCmmOpts.set (7,0); // pdsch-ConfigCommon not present | 474 rrCfgCmmOpts.set (7,0); // pdsch-ConfigCommon not present |
472 rrCfgCmmOpts.set (6,0); // phich-Config not present | 475 rrCfgCmmOpts.set (6,0); // phich-Config not present |
473 rrCfgCmmOpts.set (5,0); // pucch-ConfigCommon not present | 476 rrCfgCmmOpts.set (5,0); // pucch-ConfigCommon not present |
474 rrCfgCmmOpts.set (4,0); // soundingRS-UL-ConfigCommon not present | 477 rrCfgCmmOpts.set (4,0); // soundingRS-UL-ConfigCommon not present |
475 rrCfgCmmOpts.set (3,0); // uplinkPowerControlCommon not present | 478 rrCfgCmmOpts.set (3,0); // uplinkPowerControlCommon not present |
476 rrCfgCmmOpts.set (2,0); // antennaInfoCommon not present | 479 rrCfgCmmOpts.set (2,0); // antennaInfoCommon not present |
477 rrCfgCmmOpts.set (1,0); // p-Max not present | 480 rrCfgCmmOpts.set (1,0); // p-Max not present |
478 rrCfgCmmOpts.set (0,0); // tdd-Config not present | 481 rrCfgCmmOpts.set (0,0); // tdd-Config not present |
479 | 482 |
480 SerializeSequence (rrCfgCmmOpts,true); | 483 SerializeSequence (rrCfgCmmOpts,true); |
481 | 484 |
482 if (rrCfgCmmOpts[8]) | 485 if (rrCfgCmmOpts[8]) |
483 { | 486 { |
484 // Serialize RACH-ConfigCommon | 487 // Serialize RACH-ConfigCommon |
485 SerializeRachConfigCommon (radioResourceConfigCommon.rachConfigCommon); | 488 SerializeRachConfigCommon (radioResourceConfigCommon.rachConfigCommon); |
486 } | 489 } |
487 | 490 |
488 // Serialize PRACH-Config | 491 // Serialize PRACH-Config |
489 // 1 optional, 0 extension marker. | 492 // 1 optional, 0 extension marker. |
490 SerializeSequence (std::bitset<1> (0),false); | 493 SerializeSequence (std::bitset<1> (0),false); |
491 | 494 |
492 // Serialize PRACH-Config rootSequenceIndex | 495 // Serialize PRACH-Config rootSequenceIndex |
493 SerializeInteger (0,0,1023); | 496 SerializeInteger (0,0,1023); |
494 | 497 |
495 // Serialize PUSCH-ConfigCommon | 498 // Serialize PUSCH-ConfigCommon |
496 SerializeSequence (std::bitset<0> (),false); | 499 SerializeSequence (std::bitset<0> (),false); |
497 | 500 |
498 // Serialize pusch-ConfigBasic | 501 // Serialize pusch-ConfigBasic |
499 SerializeSequence (std::bitset<0> (),false); | 502 SerializeSequence (std::bitset<0> (),false); |
500 SerializeInteger (1,1,4); | 503 SerializeInteger (1,1,4); |
501 SerializeEnum (2,0); | 504 SerializeEnum (2,0); |
502 SerializeInteger (0,0,98); | 505 SerializeInteger (0,0,98); |
503 SerializeBoolean (false); | 506 SerializeBoolean (false); |
504 | 507 |
505 // Serialize UL-ReferenceSignalsPUSCH | 508 // Serialize UL-ReferenceSignalsPUSCH |
506 SerializeSequence (std::bitset<0> (),false); | 509 SerializeSequence (std::bitset<0> (),false); |
507 SerializeBoolean (false); | 510 SerializeBoolean (false); |
508 SerializeInteger (0,0,29); | 511 SerializeInteger (0,0,29); |
509 SerializeBoolean (false); | 512 SerializeBoolean (false); |
510 SerializeInteger (4,0,7); | 513 SerializeInteger (4,0,7); |
511 | 514 |
512 // Serialize UL-CyclicPrefixLength | 515 // Serialize UL-CyclicPrefixLength |
513 SerializeEnum (2,0); | 516 SerializeEnum (2,0); |
514 } | 517 } |
515 | 518 |
516 void | 519 void |
517 RrcAsn1Header::SerializeRadioResourceConfigCommonSib (LteRrcSap::RadioResourceCo
nfigCommonSib radioResourceConfigCommonSib) const | 520 RrcAsn1Header::SerializeRadioResourceConfigCommonSib (LteRrcSap::RadioResource
ConfigCommonSib radioResourceConfigCommonSib) const |
518 { | 521 { |
519 SerializeSequence (std::bitset<0> (0),true); | 522 SerializeSequence (std::bitset<0> (0),true); |
520 | 523 |
521 // rach-ConfigCommon | 524 // rach-ConfigCommon |
522 SerializeRachConfigCommon (radioResourceConfigCommonSib.rachConfigCommon); | 525 SerializeRachConfigCommon (radioResourceConfigCommonSib.rachConfigCommon); |
523 | 526 |
524 // bcch-Config· | 527 // bcch-Config· |
525 SerializeSequence (std::bitset<0> (0),false); | 528 SerializeSequence (std::bitset<0> (0),false); |
526 SerializeEnum (4,0); // modificationPeriodCoeff | 529 SerializeEnum (4,0); // modificationPeriodCoeff |
527 // pcch-Config· | 530 // pcch-Config· |
528 SerializeSequence (std::bitset<0> (0),false); | 531 SerializeSequence (std::bitset<0> (0),false); |
529 SerializeEnum (4,0); // defaultPagingCycle | 532 SerializeEnum (4,0); // defaultPagingCycle |
530 SerializeEnum (8,0); // nB | 533 SerializeEnum (8,0); // nB |
531 // prach-Config· | 534 // prach-Config· |
532 SerializeSequence (std::bitset<1> (0),false); | 535 SerializeSequence (std::bitset<1> (0),false); |
533 SerializeInteger (0,0,1023); // rootSequenceIndex | 536 SerializeInteger (0,0,1023); // rootSequenceIndex |
534 // pdsch-ConfigCommon· | 537 // pdsch-ConfigCommon· |
535 SerializeSequence (std::bitset<0> (0),false); | 538 SerializeSequence (std::bitset<0> (0),false); |
536 SerializeInteger (0,-60,50); // referenceSignalPower | 539 SerializeInteger (0,-60,50); // referenceSignalPower |
537 SerializeInteger (0,0,3); // p-b | 540 SerializeInteger (0,0,3); // p-b |
538 // pusch-ConfigCommon· | 541 // pusch-ConfigCommon· |
539 SerializeSequence (std::bitset<0> (0),false); | 542 SerializeSequence (std::bitset<0> (0),false); |
540 SerializeSequence (std::bitset<0> (0),false); // pusch-ConfigBasic | 543 SerializeSequence (std::bitset<0> (0),false); // pusch-ConfigBasic |
541 SerializeInteger (1,1,4); // n-SB | 544 SerializeInteger (1,1,4); // n-SB |
542 SerializeEnum (2,0); // hoppingMode | 545 SerializeEnum (2,0); // hoppingMode |
543 SerializeInteger (0,0,98); // pusch-HoppingOffset | 546 SerializeInteger (0,0,98); // pusch-HoppingOffset |
544 SerializeBoolean (false); // enable64QAM | 547 SerializeBoolean (false); // enable64QAM |
545 SerializeSequence (std::bitset<0> (0),false); // UL-ReferenceSignalsPUSCH | 548 SerializeSequence (std::bitset<0> (0),false); // UL-ReferenceSignalsPUSCH |
546 SerializeBoolean (false); // groupHoppingEnabled | 549 SerializeBoolean (false); // groupHoppingEnabled |
547 SerializeInteger (0,0,29); // groupAssignmentPUSCH | 550 SerializeInteger (0,0,29); // groupAssignmentPUSCH |
548 SerializeBoolean (false); // sequenceHoppingEnabled | 551 SerializeBoolean (false); // sequenceHoppingEnabled |
549 SerializeInteger (0,0,7); // cyclicShift | 552 SerializeInteger (0,0,7); // cyclicShift |
550 // pucch-ConfigCommon· | 553 // pucch-ConfigCommon· |
551 SerializeSequence (std::bitset<0> (0),false); | 554 SerializeSequence (std::bitset<0> (0),false); |
552 SerializeEnum (3,0); // deltaPUCCH-Shift | 555 SerializeEnum (3,0); // deltaPUCCH-Shift |
553 SerializeInteger (0,0,98); // nRB-CQI | 556 SerializeInteger (0,0,98); // nRB-CQI |
554 SerializeInteger (0,0,7); // nCS-AN | 557 SerializeInteger (0,0,7); // nCS-AN |
555 SerializeInteger (0,0,2047); // n1PUCCH-AN | 558 SerializeInteger (0,0,2047); // n1PUCCH-AN |
556 // soundingRS-UL-ConfigCommon· | 559 // soundingRS-UL-ConfigCommon· |
557 SerializeChoice (2,0,false); | 560 SerializeChoice (2,0,false); |
558 SerializeNull (); // release | 561 SerializeNull (); // release |
559 // uplinkPowerControlCommon· | 562 // uplinkPowerControlCommon· |
560 SerializeSequence (std::bitset<0> (0),false); | 563 SerializeSequence (std::bitset<0> (0),false); |
561 SerializeInteger (0,-126,24); // p0-NominalPUSCH | 564 SerializeInteger (0,-126,24); // p0-NominalPUSCH |
562 SerializeEnum (8,0); // alpha | 565 SerializeEnum (8,0); // alpha |
563 SerializeInteger (-50,-127,-96); // p0-NominalPUCCH | 566 SerializeInteger (-50,-127,-96); // p0-NominalPUCCH |
564 SerializeSequence (std::bitset<0> (0),false); // deltaFList-PUCCH | 567 SerializeSequence (std::bitset<0> (0),false); // deltaFList-PUCCH |
565 SerializeEnum (3,0); // deltaF-PUCCH-Format1 | 568 SerializeEnum (3,0); // deltaF-PUCCH-Format1 |
566 SerializeEnum (3,0); // deltaF-PUCCH-Format1b | 569 SerializeEnum (3,0); // deltaF-PUCCH-Format1b |
567 SerializeEnum (4,0); // deltaF-PUCCH-Format2 | 570 SerializeEnum (4,0); // deltaF-PUCCH-Format2 |
568 SerializeEnum (3,0); // deltaF-PUCCH-Format2a | 571 SerializeEnum (3,0); // deltaF-PUCCH-Format2a |
569 SerializeEnum (3,0); // deltaF-PUCCH-Format2b | 572 SerializeEnum (3,0); // deltaF-PUCCH-Format2b |
570 SerializeInteger (0,-1,6); | 573 SerializeInteger (0,-1,6); |
571 // ul-CyclicPrefixLength· | 574 // ul-CyclicPrefixLength· |
572 SerializeEnum (2,0); | 575 SerializeEnum (2,0); |
573 } | 576 } |
574 | 577 |
575 void | 578 void |
576 RrcAsn1Header::SerializeSystemInformationBlockType2 (LteRrcSap::SystemInformatio
nBlockType2 systemInformationBlockType2) const | 579 RrcAsn1Header::SerializeSystemInformationBlockType2 (LteRrcSap::SystemInformat
ionBlockType2 systemInformationBlockType2) const |
577 { | 580 { |
578 SerializeSequence (std::bitset<2> (0),true); | 581 SerializeSequence (std::bitset<2> (0),true); |
579 | 582 |
580 // RadioResourceConfigCommonSib | 583 // RadioResourceConfigCommonSib |
581 SerializeRadioResourceConfigCommonSib (systemInformationBlockType2.radioResour
ceConfigCommon); | 584 SerializeRadioResourceConfigCommonSib (systemInformationBlockType2.radioReso
urceConfigCommon); |
582 | 585 |
583 // ue-TimersAndConstants | 586 // ue-TimersAndConstants |
584 SerializeSequence (std::bitset<0> (0),true); | 587 SerializeSequence (std::bitset<0> (0),true); |
585 SerializeEnum (8,0); // t300 | 588 SerializeEnum (8,0); // t300 |
586 SerializeEnum (8,0); // t301 | 589 SerializeEnum (8,0); // t301 |
587 SerializeEnum (7,0); // t310 | 590 SerializeEnum (7,0); // t310 |
588 SerializeEnum (8,0); // n310 | 591 SerializeEnum (8,0); // n310 |
589 SerializeEnum (7,0); // t311 | 592 SerializeEnum (7,0); // t311 |
590 SerializeEnum (8,0); // n311 | 593 SerializeEnum (8,0); // n311 |
591 | 594 |
592 // freqInfo | 595 // freqInfo |
593 SerializeSequence (std::bitset<2> (3),false); | 596 SerializeSequence (std::bitset<2> (3),false); |
594 SerializeInteger ((int) systemInformationBlockType2.freqInfo.ulCarrierFreq, 0,
MAX_EARFCN); | 597 SerializeInteger ((int) systemInformationBlockType2.freqInfo.ulCarrierFreq,
0, MAX_EARFCN); |
595 switch (systemInformationBlockType2.freqInfo.ulBandwidth) | 598 switch (systemInformationBlockType2.freqInfo.ulBandwidth) |
596 { | 599 { |
597 case 6: | 600 case 6: |
598 SerializeEnum (6,0); | 601 SerializeEnum (6,0); |
599 break; | 602 break; |
600 case 15: | 603 case 15: |
601 SerializeEnum (6,1); | 604 SerializeEnum (6,1); |
602 break; | 605 break; |
603 case 25: | 606 case 25: |
604 SerializeEnum (6,2); | 607 SerializeEnum (6,2); |
605 break; | 608 break; |
606 case 50: | 609 case 50: |
607 SerializeEnum (6,3); | 610 SerializeEnum (6,3); |
608 break; | 611 break; |
609 case 75: | 612 case 75: |
610 SerializeEnum (6,4); | 613 SerializeEnum (6,4); |
611 break; | 614 break; |
612 case 100: | 615 case 100: |
613 SerializeEnum (6,5); | 616 SerializeEnum (6,5); |
614 break; | 617 break; |
615 default: | 618 default: |
616 SerializeEnum (6,0); | 619 SerializeEnum (6,0); |
617 } | 620 } |
618 | 621 |
619 SerializeInteger (29,1,32); // additionalSpectrumEmission | 622 SerializeInteger (29,1,32); // additionalSpectrumEmission |
620 // timeAlignmentTimerCommon | 623 // timeAlignmentTimerCommon |
621 SerializeEnum (8,0); | 624 SerializeEnum (8,0); |
622 } | 625 } |
623 | 626 |
624 void | 627 void |
625 RrcAsn1Header::SerializeMeasResults (LteRrcSap::MeasResults measResults) const | 628 RrcAsn1Header::SerializeMeasResults (LteRrcSap::MeasResults measResults) const |
626 { | 629 { |
627 // Watchdog: if list has 0 elements, set boolean to false | 630 // Watchdog: if list has 0 elements, set boolean to false |
628 if (measResults.measResultListEutra.empty ()) | 631 if (measResults.measResultListEutra.empty ()) |
629 { | 632 { |
630 measResults.haveMeasResultNeighCells = false; | 633 measResults.haveMeasResultNeighCells = false; |
631 } | 634 } |
632 | 635 |
633 // Serialize MeasResults sequence, 1 optional value, extension marker present | 636 // Serialize MeasResults sequence, 1 optional value, extension marker presen
t |
634 SerializeSequence (std::bitset<1> (measResults.haveMeasResultNeighCells),true)
; | 637 SerializeSequence (std::bitset<1> (measResults.haveMeasResultNeighCells),tru
e); |
635 | 638 |
636 // Serialize measId | 639 // Serialize measId |
637 SerializeInteger (measResults.measId,1,MAX_MEAS_ID); | 640 SerializeInteger (measResults.measId,1,MAX_MEAS_ID); |
638 | 641 |
639 // Serialize measResultServCell sequence | 642 // Serialize measResultServCell sequence |
640 SerializeSequence (std::bitset<0> (0),false); | 643 SerializeSequence (std::bitset<0> (0),false); |
641 | 644 |
642 // Serialize rsrpResult | 645 // Serialize rsrpResult |
643 SerializeInteger (measResults.rsrpResult,0,97); | 646 SerializeInteger (measResults.rsrpResult,0,97); |
644 | 647 |
645 // Serialize rsrqResult | 648 // Serialize rsrqResult |
646 SerializeInteger (measResults.rsrqResult,0,34); | 649 SerializeInteger (measResults.rsrqResult,0,34); |
647 | 650 |
648 if (measResults.haveMeasResultNeighCells) | 651 if (measResults.haveMeasResultNeighCells) |
649 { | 652 { |
650 // Serialize Choice = 0 (MeasResultListEUTRA) | 653 // Serialize Choice = 0 (MeasResultListEUTRA) |
651 SerializeChoice (4,0,false); | 654 SerializeChoice (4,0,false); |
652 | 655 |
653 // Serialize measResultNeighCells | 656 // Serialize measResultNeighCells |
654 SerializeSequenceOf (measResults.measResultListEutra.size (),MAX_CELL_REPO
RT,1); | 657 SerializeSequenceOf (measResults.measResultListEutra.size (),MAX_CELL_RE
PORT,1); |
655 | 658 |
656 // serialize MeasResultEutra elements in the list | 659 // serialize MeasResultEutra elements in the list |
657 std::list<LteRrcSap::MeasResultEutra>::iterator it; | 660 std::list<LteRrcSap::MeasResultEutra>::iterator it; |
658 for (it = measResults.measResultListEutra.begin (); it != measResults.meas
ResultListEutra.end (); it++) | 661 for (it = measResults.measResultListEutra.begin (); it != measResults.me
asResultListEutra.end (); it++) |
659 { | 662 { |
660 SerializeSequence (std::bitset<1> (it->haveCgiInfo),false); | 663 SerializeSequence (std::bitset<1> (it->haveCgiInfo),false); |
661 | 664 |
662 // Serialize PhysCellId | 665 // Serialize PhysCellId |
663 SerializeInteger (it->physCellId, 0, 503); | 666 SerializeInteger (it->physCellId, 0, 503); |
664 | 667 |
665 // Serialize CgiInfo | 668 // Serialize CgiInfo |
666 if (it->haveCgiInfo) | 669 if (it->haveCgiInfo) |
667 { | 670 { |
668 SerializeSequence (std::bitset<1> (it->cgiInfo.plmnIdentityList.si
ze ()),false); | 671 SerializeSequence (std::bitset<1> (it->cgiInfo.plmnIdentityList.
size ()),false); |
669 | 672 |
670 // Serialize cellGlobalId | 673 // Serialize cellGlobalId |
671 SerializeSequence (std::bitset<0> (0),false); | 674 SerializeSequence (std::bitset<0> (0),false); |
672 SerializePlmnIdentity (it->cgiInfo.plmnIdentity); | 675 SerializePlmnIdentity (it->cgiInfo.plmnIdentity); |
673 SerializeBitstring (std::bitset<28> (it->cgiInfo.cellIdentity)); | 676 SerializeBitstring (std::bitset<28> (it->cgiInfo.cellIdentity)); |
674 | 677 |
675 // Serialize trackingAreaCode | 678 // Serialize trackingAreaCode |
676 SerializeBitstring (std::bitset<16> (it->cgiInfo.trackingAreaCode)
); | 679 SerializeBitstring (std::bitset<16> (it->cgiInfo.trackingAreaCod
e)); |
677 | 680 |
678 // Serialize plmn-IdentityList | 681 // Serialize plmn-IdentityList |
679 if (!it->cgiInfo.plmnIdentityList.empty ()) | 682 if (!it->cgiInfo.plmnIdentityList.empty ()) |
680 { | 683 { |
681 SerializeSequenceOf (it->cgiInfo.plmnIdentityList.size (),5,1)
; | 684 SerializeSequenceOf (it->cgiInfo.plmnIdentityList.size (),5,
1); |
682 std::list<uint32_t>::iterator it2; | 685 std::list<uint32_t>::iterator it2; |
683 for (it2 = it->cgiInfo.plmnIdentityList.begin (); it2 != it->c
giInfo.plmnIdentityList.end (); it2++) | 686 for (it2 = it->cgiInfo.plmnIdentityList.begin (); it2 != it-
>cgiInfo.plmnIdentityList.end (); it2++) |
684 { | 687 { |
685 SerializePlmnIdentity (*it2); | 688 SerializePlmnIdentity (*it2); |
686 } | 689 } |
687 } | 690 } |
688 } | 691 } |
689 | 692 |
690 // Serialize measResult | 693 // Serialize measResult |
691 std::bitset<2> measResultFieldsPresent; | 694 std::bitset<2> measResultFieldsPresent; |
692 measResultFieldsPresent[1] = it->haveRsrpResult; | 695 measResultFieldsPresent[1] = it->haveRsrpResult; |
693 measResultFieldsPresent[0] = it->haveRsrqResult; | 696 measResultFieldsPresent[0] = it->haveRsrqResult; |
694 SerializeSequence (measResultFieldsPresent,true); | 697 SerializeSequence (measResultFieldsPresent,true); |
695 | 698 |
696 if (it->haveRsrpResult) | 699 if (it->haveRsrpResult) |
697 { | 700 { |
698 SerializeInteger (it->rsrpResult,0,97); | 701 SerializeInteger (it->rsrpResult,0,97); |
699 } | 702 } |
700 | 703 |
701 if (it->haveRsrqResult) | 704 if (it->haveRsrqResult) |
702 { | 705 { |
703 SerializeInteger (it->rsrqResult,0,34); | 706 SerializeInteger (it->rsrqResult,0,34); |
704 } | 707 } |
705 } | 708 } |
706 } | 709 } |
707 } | 710 } |
708 | 711 |
709 void | 712 void |
710 RrcAsn1Header::SerializePlmnIdentity (uint32_t plmnId) const | 713 RrcAsn1Header::SerializePlmnIdentity (uint32_t plmnId) const |
711 { | 714 { |
712 // plmn-Identity sequence, mcc is optional, no extension marker | 715 // plmn-Identity sequence, mcc is optional, no extension marker |
713 SerializeSequence (std::bitset<1> (0), false); | 716 SerializeSequence (std::bitset<1> (0), false); |
714 | 717 |
715 // Serialize mnc | 718 // Serialize mnc |
716 int nDig = (plmnId > 99) ? 3 : 2; | 719 int nDig = (plmnId > 99) ? 3 : 2; |
717 | 720 |
718 SerializeSequenceOf (nDig,3,2); | 721 SerializeSequenceOf (nDig,3,2); |
719 for (int i = nDig - 1; i >= 0; i--) | 722 for (int i = nDig - 1; i >= 0; i--) |
720 { | 723 { |
721 int n = floor (plmnId / pow (10,i)); | 724 int n = floor (plmnId / pow (10,i)); |
722 SerializeInteger (n,0,9); | 725 SerializeInteger (n,0,9); |
723 plmnId -= n * pow (10,i); | 726 plmnId -= n * pow (10,i); |
724 } | 727 } |
725 | 728 |
726 // cellReservedForOperatorUse· | 729 // cellReservedForOperatorUse· |
727 SerializeEnum (2,0); | 730 SerializeEnum (2,0); |
728 } | 731 } |
729 | 732 |
730 void· | 733 void· |
731 RrcAsn1Header::SerializeRachConfigCommon (LteRrcSap::RachConfigCommon rachConfig
Common) const | 734 RrcAsn1Header::SerializeRachConfigCommon (LteRrcSap::RachConfigCommon rachConf
igCommon) const |
732 { | 735 { |
733 // rach-ConfigCommon | 736 // rach-ConfigCommon |
734 SerializeSequence (std::bitset<0> (0),true); | 737 SerializeSequence (std::bitset<0> (0),true); |
735 | 738 |
736 // preambleInfo | 739 // preambleInfo |
737 SerializeSequence (std::bitset<1> (0),false); | 740 SerializeSequence (std::bitset<1> (0),false); |
738 | 741 |
739 // numberOfRA-Preambles | 742 // numberOfRA-Preambles |
740 switch (rachConfigCommon.preambleInfo.numberOfRaPreambles) | 743 switch (rachConfigCommon.preambleInfo.numberOfRaPreambles) |
741 { | 744 { |
742 case 4: | 745 case 4: |
743 SerializeEnum (16,0); | 746 SerializeEnum (16,0); |
744 break; | 747 break; |
745 case 8: | 748 case 8: |
746 SerializeEnum (16,1); | 749 SerializeEnum (16,1); |
747 break; | 750 break; |
748 case 12: | 751 case 12: |
749 SerializeEnum (16,2); | 752 SerializeEnum (16,2); |
750 break; | 753 break; |
751 case 16: | 754 case 16: |
752 SerializeEnum (16,3); | 755 SerializeEnum (16,3); |
753 break; | 756 break; |
754 case 20: | 757 case 20: |
755 SerializeEnum (16,4); | 758 SerializeEnum (16,4); |
756 break; | 759 break; |
757 case 24: | 760 case 24: |
758 SerializeEnum (16,5); | 761 SerializeEnum (16,5); |
759 break; | 762 break; |
760 case 28: | 763 case 28: |
761 SerializeEnum (16,6); | 764 SerializeEnum (16,6); |
762 break; | 765 break; |
763 case 32: | 766 case 32: |
764 SerializeEnum (16,7); | 767 SerializeEnum (16,7); |
765 break; | 768 break; |
766 case 36: | 769 case 36: |
767 SerializeEnum (16,8); | 770 SerializeEnum (16,8); |
768 break; | 771 break; |
769 case 40: | 772 case 40: |
770 SerializeEnum (16,9); | 773 SerializeEnum (16,9); |
771 break; | 774 break; |
772 case 44: | 775 case 44: |
773 SerializeEnum (16,10); | 776 SerializeEnum (16,10); |
774 break; | 777 break; |
775 case 48: | 778 case 48: |
776 SerializeEnum (16,11); | 779 SerializeEnum (16,11); |
777 break; | 780 break; |
778 case 52: | 781 case 52: |
779 SerializeEnum (16,12); | 782 SerializeEnum (16,12); |
780 break; | 783 break; |
781 case 56: | 784 case 56: |
782 SerializeEnum (16,13); | 785 SerializeEnum (16,13); |
783 break; | 786 break; |
784 case 60: | 787 case 60: |
785 SerializeEnum (16,14); | 788 SerializeEnum (16,14); |
786 break; | 789 break; |
787 case 64: | 790 case 64: |
788 SerializeEnum (16,15); | 791 SerializeEnum (16,15); |
789 break; | 792 break; |
790 default: | 793 default: |
791 SerializeEnum (16,0); | 794 SerializeEnum (16,0); |
792 } | 795 } |
793 | 796 |
794 SerializeSequence (std::bitset<0> (0),false); // powerRampingParameters | 797 SerializeSequence (std::bitset<0> (0),false); // powerRampingParameters |
795 SerializeEnum (4,0); // powerRampingStep | 798 SerializeEnum (4,0); // powerRampingStep |
796 SerializeEnum (16,0); // preambleInitialReceivedTargetPower | 799 SerializeEnum (16,0); // preambleInitialReceivedTargetPower |
797 SerializeSequence (std::bitset<0> (0),false); // ra-SupervisionInfo | 800 SerializeSequence (std::bitset<0> (0),false); // ra-SupervisionInfo |
798 | 801 |
799 // preambleTransMax | 802 // preambleTransMax |
800 switch (rachConfigCommon.raSupervisionInfo.preambleTransMax) | 803 switch (rachConfigCommon.raSupervisionInfo.preambleTransMax) |
801 { | 804 { |
802 case 3: | 805 case 3: |
803 SerializeEnum (11,0); | 806 SerializeEnum (11,0); |
804 break; | 807 break; |
805 case 4: | 808 case 4: |
806 SerializeEnum (11,1); | 809 SerializeEnum (11,1); |
807 break; | 810 break; |
808 case 5: | 811 case 5: |
809 SerializeEnum (11,2); | 812 SerializeEnum (11,2); |
810 break; | 813 break; |
811 case 6: | 814 case 6: |
812 SerializeEnum (11,3); | 815 SerializeEnum (11,3); |
813 break; | 816 break; |
814 case 7: | 817 case 7: |
815 SerializeEnum (11,4); | 818 SerializeEnum (11,4); |
816 break; | 819 break; |
817 case 8: | 820 case 8: |
818 SerializeEnum (11,5); | 821 SerializeEnum (11,5); |
819 break; | 822 break; |
820 case 10: | 823 case 10: |
821 SerializeEnum (11,6); | 824 SerializeEnum (11,6); |
822 break; | 825 break; |
823 case 20: | 826 case 20: |
824 SerializeEnum (11,7); | 827 SerializeEnum (11,7); |
825 break; | 828 break; |
826 case 50: | 829 case 50: |
827 SerializeEnum (11,8); | 830 SerializeEnum (11,8); |
828 break; | 831 break; |
829 case 100: | 832 case 100: |
830 SerializeEnum (11,9); | 833 SerializeEnum (11,9); |
831 break; | 834 break; |
832 case 200: | 835 case 200: |
833 SerializeEnum (11,10); | 836 SerializeEnum (11,10); |
834 break; | 837 break; |
835 default: | 838 default: |
836 SerializeEnum (11,0); | 839 SerializeEnum (11,0); |
837 } | 840 } |
838 | 841 |
839 // ra-ResponseWindowSize | 842 // ra-ResponseWindowSize |
840 switch (rachConfigCommon.raSupervisionInfo.raResponseWindowSize) | 843 switch (rachConfigCommon.raSupervisionInfo.raResponseWindowSize) |
841 { | 844 { |
842 case 2: | 845 case 2: |
843 SerializeEnum (8,0); | 846 SerializeEnum (8,0); |
844 break; | 847 break; |
845 case 3: | 848 case 3: |
846 SerializeEnum (8,1); | 849 SerializeEnum (8,1); |
847 break; | 850 break; |
848 case 4: | 851 case 4: |
849 SerializeEnum (8,2); | 852 SerializeEnum (8,2); |
850 break; | 853 break; |
851 case 5: | 854 case 5: |
852 SerializeEnum (8,3); | 855 SerializeEnum (8,3); |
853 break; | 856 break; |
854 case 6: | 857 case 6: |
855 SerializeEnum (8,4); | 858 SerializeEnum (8,4); |
856 break; | 859 break; |
857 case 7: | 860 case 7: |
858 SerializeEnum (8,5); | 861 SerializeEnum (8,5); |
859 break; | 862 break; |
860 case 8: | 863 case 8: |
861 SerializeEnum (8,6); | 864 SerializeEnum (8,6); |
862 break; | 865 break; |
863 case 10: | 866 case 10: |
864 SerializeEnum (8,7); | 867 SerializeEnum (8,7); |
865 break; | 868 break; |
866 default: | 869 default: |
867 SerializeEnum (8,0); | 870 SerializeEnum (8,0); |
868 } | 871 } |
869 | 872 |
870 SerializeEnum (8,0); // mac-ContentionResolutionTimer | 873 SerializeEnum (8,0); // mac-ContentionResolutionTimer |
871 SerializeInteger (1,1,8); // maxHARQ-Msg3Tx | 874 SerializeInteger (1,1,8); // maxHARQ-Msg3Tx |
872 } | 875 } |
873 | 876 |
874 void | 877 void |
875 RrcAsn1Header::SerializeQoffsetRange (int8_t qOffsetRange) const | 878 RrcAsn1Header::SerializeQoffsetRange (int8_t qOffsetRange) const |
876 { | 879 { |
877 switch (qOffsetRange) | 880 switch (qOffsetRange) |
878 { | 881 { |
879 case -24: | 882 case -24: |
880 SerializeEnum (31,0); | 883 SerializeEnum (31,0); |
881 break; | 884 break; |
882 case -22: | 885 case -22: |
883 SerializeEnum (31,1); | 886 SerializeEnum (31,1); |
884 break; | 887 break; |
885 case -20: | 888 case -20: |
886 SerializeEnum (31,2); | 889 SerializeEnum (31,2); |
887 break; | 890 break; |
888 case -18: | 891 case -18: |
889 SerializeEnum (31,3); | 892 SerializeEnum (31,3); |
890 break; | 893 break; |
891 case -16: | 894 case -16: |
892 SerializeEnum (31,4); | 895 SerializeEnum (31,4); |
893 break; | 896 break; |
894 case -14: | 897 case -14: |
895 SerializeEnum (31,5); | 898 SerializeEnum (31,5); |
896 break; | 899 break; |
897 case -12: | 900 case -12: |
898 SerializeEnum (31,6); | 901 SerializeEnum (31,6); |
899 break; | 902 break; |
900 case -10: | 903 case -10: |
901 SerializeEnum (31,7); | 904 SerializeEnum (31,7); |
902 break; | 905 break; |
903 case -8: | 906 case -8: |
904 SerializeEnum (31,8); | 907 SerializeEnum (31,8); |
905 break; | 908 break; |
906 case -6: | 909 case -6: |
907 SerializeEnum (31,9); | 910 SerializeEnum (31,9); |
908 break; | 911 break; |
909 case -5: | 912 case -5: |
910 SerializeEnum (31,10); | 913 SerializeEnum (31,10); |
911 break; | 914 break; |
912 case -4: | 915 case -4: |
913 SerializeEnum (31,11); | 916 SerializeEnum (31,11); |
914 break; | 917 break; |
915 case -3: | 918 case -3: |
916 SerializeEnum (31,12); | 919 SerializeEnum (31,12); |
917 break; | 920 break; |
918 case -2: | 921 case -2: |
919 SerializeEnum (31,13); | 922 SerializeEnum (31,13); |
920 break; | 923 break; |
921 case -1: | 924 case -1: |
922 SerializeEnum (31,14); | 925 SerializeEnum (31,14); |
923 break; | 926 break; |
924 case 0: | 927 case 0: |
925 SerializeEnum (31,15); | 928 SerializeEnum (31,15); |
926 break; | 929 break; |
927 case 1: | 930 case 1: |
928 SerializeEnum (31,16); | 931 SerializeEnum (31,16); |
929 break; | 932 break; |
930 case 2: | 933 case 2: |
931 SerializeEnum (31,17); | 934 SerializeEnum (31,17); |
932 break; | 935 break; |
933 case 3: | 936 case 3: |
934 SerializeEnum (31,18); | 937 SerializeEnum (31,18); |
935 break; | 938 break; |
936 case 4: | 939 case 4: |
937 SerializeEnum (31,19); | 940 SerializeEnum (31,19); |
938 break; | 941 break; |
939 case 5: | 942 case 5: |
940 SerializeEnum (31,20); | 943 SerializeEnum (31,20); |
941 break; | 944 break; |
942 case 6: | 945 case 6: |
943 SerializeEnum (31,21); | 946 SerializeEnum (31,21); |
944 break; | 947 break; |
945 case 8: | 948 case 8: |
946 SerializeEnum (31,22); | 949 SerializeEnum (31,22); |
947 break; | 950 break; |
948 case 10: | 951 case 10: |
949 SerializeEnum (31,23); | 952 SerializeEnum (31,23); |
950 break; | 953 break; |
951 case 12: | 954 case 12: |
952 SerializeEnum (31,24); | 955 SerializeEnum (31,24); |
953 break; | 956 break; |
954 case 14: | 957 case 14: |
955 SerializeEnum (31,25); | 958 SerializeEnum (31,25); |
956 break; | 959 break; |
957 case 16: | 960 case 16: |
958 SerializeEnum (31,26); | 961 SerializeEnum (31,26); |
959 break; | 962 break; |
960 case 18: | 963 case 18: |
961 SerializeEnum (31,27); | 964 SerializeEnum (31,27); |
962 break; | 965 break; |
963 case 20: | 966 case 20: |
964 SerializeEnum (31,28); | 967 SerializeEnum (31,28); |
965 break; | 968 break; |
966 case 22: | 969 case 22: |
967 SerializeEnum (31,29); | 970 SerializeEnum (31,29); |
968 break; | 971 break; |
969 case 24: | 972 case 24: |
970 SerializeEnum (31,30); | 973 SerializeEnum (31,30); |
971 break; | 974 break; |
972 default: | 975 default: |
973 SerializeEnum (31,15); | 976 SerializeEnum (31,15); |
974 } | 977 } |
975 } | 978 } |
976 | 979 |
977 void | 980 void |
978 RrcAsn1Header::SerializeThresholdEutra (LteRrcSap::ThresholdEutra thresholdEutra
) const | 981 RrcAsn1Header::SerializeThresholdEutra (LteRrcSap::ThresholdEutra thresholdEut
ra) const |
979 { | 982 { |
980 switch (thresholdEutra.choice) | 983 switch (thresholdEutra.choice) |
981 { | 984 { |
982 case LteRrcSap::ThresholdEutra::THRESHOLD_RSRP: | 985 case LteRrcSap::ThresholdEutra::THRESHOLD_RSRP: |
983 SerializeChoice (2,0,false); | 986 SerializeChoice (2,0,false); |
984 SerializeInteger (thresholdEutra.range, 0, 97); | 987 SerializeInteger (thresholdEutra.range, 0, 97); |
985 break; | 988 break; |
986 case LteRrcSap::ThresholdEutra::THRESHOLD_RSRQ: | 989 case LteRrcSap::ThresholdEutra::THRESHOLD_RSRQ: |
987 default: | 990 default: |
988 SerializeChoice (2,1,false); | 991 SerializeChoice (2,1,false); |
989 SerializeInteger (thresholdEutra.range, 0, 34); | 992 SerializeInteger (thresholdEutra.range, 0, 34); |
990 } | 993 } |
991 } | 994 } |
992 | 995 |
993 void | 996 void |
994 RrcAsn1Header::SerializeMeasConfig (LteRrcSap::MeasConfig measConfig) const | 997 RrcAsn1Header::SerializeMeasConfig (LteRrcSap::MeasConfig measConfig) const |
995 { | 998 { |
996 // Serialize MeasConfig sequence | 999 // Serialize MeasConfig sequence |
997 // 11 optional fields, extension marker present | 1000 // 11 optional fields, extension marker present |
998 std::bitset<11> measConfigOptional; | 1001 std::bitset<11> measConfigOptional; |
999 measConfigOptional.set (10, !measConfig.measObjectToRemoveList.empty () ); | 1002 measConfigOptional.set (10, !measConfig.measObjectToRemoveList.empty () ); |
1000 measConfigOptional.set (9, !measConfig.measObjectToAddModList.empty () ); | 1003 measConfigOptional.set (9, !measConfig.measObjectToAddModList.empty () ); |
1001 measConfigOptional.set (8, !measConfig.reportConfigToRemoveList.empty () ); | 1004 measConfigOptional.set (8, !measConfig.reportConfigToRemoveList.empty () ); |
1002 measConfigOptional.set (7, !measConfig.reportConfigToAddModList.empty () ); | 1005 measConfigOptional.set (7, !measConfig.reportConfigToAddModList.empty () ); |
1003 measConfigOptional.set (6, !measConfig.measIdToRemoveList.empty () ); | 1006 measConfigOptional.set (6, !measConfig.measIdToRemoveList.empty () ); |
1004 measConfigOptional.set (5, !measConfig.measIdToAddModList.empty () ); | 1007 measConfigOptional.set (5, !measConfig.measIdToAddModList.empty () ); |
1005 measConfigOptional.set (4, measConfig.haveQuantityConfig );· | 1008 measConfigOptional.set (4, measConfig.haveQuantityConfig );· |
1006 measConfigOptional.set (3, measConfig.haveMeasGapConfig );· | 1009 measConfigOptional.set (3, measConfig.haveMeasGapConfig );· |
1007 measConfigOptional.set (2, measConfig.haveSmeasure );· | 1010 measConfigOptional.set (2, measConfig.haveSmeasure );· |
1008 measConfigOptional.set (1, false ); // preRegistrationInfoHRPD | 1011 measConfigOptional.set (1, false ); // preRegistrationInfoHRPD |
1009 measConfigOptional.set (0, measConfig.haveSpeedStatePars );· | 1012 measConfigOptional.set (0, measConfig.haveSpeedStatePars );· |
1010 SerializeSequence (measConfigOptional,true); | 1013 SerializeSequence (measConfigOptional,true); |
1011 | 1014 |
1012 if (!measConfig.measObjectToRemoveList.empty ()) | 1015 if (!measConfig.measObjectToRemoveList.empty ()) |
1013 { | 1016 { |
1014 SerializeSequenceOf (measConfig.measObjectToRemoveList.size (),MAX_OBJECT_
ID,1); | 1017 SerializeSequenceOf (measConfig.measObjectToRemoveList.size (),MAX_OBJEC
T_ID,1); |
1015 for (std::list<uint8_t>::iterator it = measConfig.measObjectToRemoveList.b
egin (); it != measConfig.measObjectToRemoveList.end (); it++) | 1018 for (std::list<uint8_t>::iterator it = measConfig.measObjectToRemoveList
.begin (); it != measConfig.measObjectToRemoveList.end (); it++) |
1016 { | 1019 { |
1017 SerializeInteger (*it, 1, MAX_OBJECT_ID); | 1020 SerializeInteger (*it, 1, MAX_OBJECT_ID); |
1018 } | 1021 } |
1019 } | 1022 } |
1020 | 1023 |
1021 if (!measConfig.measObjectToAddModList.empty ()) | 1024 if (!measConfig.measObjectToAddModList.empty ()) |
1022 { | 1025 { |
1023 SerializeSequenceOf (measConfig.measObjectToAddModList.size (),MAX_OBJECT_
ID,1); | 1026 SerializeSequenceOf (measConfig.measObjectToAddModList.size (),MAX_OBJEC
T_ID,1); |
1024 for (std::list<LteRrcSap::MeasObjectToAddMod>::iterator it = measConfig.me
asObjectToAddModList.begin (); it != measConfig.measObjectToAddModList.end (); i
t++) | 1027 for (std::list<LteRrcSap::MeasObjectToAddMod>::iterator it = measConfig.
measObjectToAddModList.begin (); it != measConfig.measObjectToAddModList.end ();
it++) |
1025 { | 1028 { |
1026 SerializeSequence (std::bitset<0> (), false); | 1029 SerializeSequence (std::bitset<0> (), false); |
1027 SerializeInteger (it->measObjectId, 1, MAX_OBJECT_ID); | 1030 SerializeInteger (it->measObjectId, 1, MAX_OBJECT_ID); |
1028 SerializeChoice (4, 0, true); // Select MeasObjectEUTRA | 1031 SerializeChoice (4, 0, true); // Select MeasObjectEUTRA |
1029 | 1032 |
1030 // Serialize measObjectEutra | 1033 // Serialize measObjectEutra |
1031 std::bitset<5> measObjOpts; | 1034 std::bitset<5> measObjOpts; |
1032 measObjOpts.set (4,!it->measObjectEutra.cellsToRemoveList.empty () ); | 1035 measObjOpts.set (4,!it->measObjectEutra.cellsToRemoveList.empty () )
; |
1033 measObjOpts.set (3,!it->measObjectEutra.cellsToAddModList.empty () ); | 1036 measObjOpts.set (3,!it->measObjectEutra.cellsToAddModList.empty () )
; |
1034 measObjOpts.set (2,!it->measObjectEutra.blackCellsToRemoveList.empty (
) ); | 1037 measObjOpts.set (2,!it->measObjectEutra.blackCellsToRemoveList.empty
() ); |
1035 measObjOpts.set (1,!it->measObjectEutra.blackCellsToAddModList.empty (
) ); | 1038 measObjOpts.set (1,!it->measObjectEutra.blackCellsToAddModList.empty
() ); |
1036 measObjOpts.set (0,it->measObjectEutra.haveCellForWhichToReportCGI); | 1039 measObjOpts.set (0,it->measObjectEutra.haveCellForWhichToReportCGI); |
1037 SerializeSequence (measObjOpts, true); | 1040 SerializeSequence (measObjOpts, true); |
1038 | 1041 |
1039 // Serialize carrierFreq | 1042 // Serialize carrierFreq |
1040 SerializeInteger (it->measObjectEutra.carrierFreq, 0, MAX_EARFCN); | 1043 SerializeInteger (it->measObjectEutra.carrierFreq, 0, MAX_EARFCN); |
1041 | 1044 |
1042 // Serialize allowedMeasBandwidth | 1045 // Serialize allowedMeasBandwidth |
1043 switch (it->measObjectEutra.allowedMeasBandwidth) | 1046 switch (it->measObjectEutra.allowedMeasBandwidth) |
1044 { | 1047 { |
1045 case 6: | 1048 case 6: |
1046 SerializeEnum (6,0); | 1049 SerializeEnum (6,0); |
1047 break; | 1050 break; |
1048 case 15: | 1051 case 15: |
1049 SerializeEnum (6,1); | 1052 SerializeEnum (6,1); |
1050 break; | 1053 break; |
1051 case 25: | 1054 case 25: |
1052 SerializeEnum (6,2); | 1055 SerializeEnum (6,2); |
1053 break; | 1056 break; |
1054 case 50: | 1057 case 50: |
1055 SerializeEnum (6,3); | 1058 SerializeEnum (6,3); |
1056 break; | 1059 break; |
1057 case 75: | 1060 case 75: |
1058 SerializeEnum (6,4); | 1061 SerializeEnum (6,4); |
1059 break; | 1062 break; |
1060 case 100: | 1063 case 100: |
1061 SerializeEnum (6,5); | 1064 SerializeEnum (6,5); |
1062 break; | 1065 break; |
1063 default: | 1066 default: |
1064 SerializeEnum (6,0); | 1067 SerializeEnum (6,0); |
1065 } | 1068 } |
1066 | 1069 |
1067 SerializeBoolean (it->measObjectEutra.presenceAntennaPort1); | 1070 SerializeBoolean (it->measObjectEutra.presenceAntennaPort1); |
1068 SerializeBitstring (std::bitset<2> (it->measObjectEutra.neighCellConfi
g)); | 1071 SerializeBitstring (std::bitset<2> (it->measObjectEutra.neighCellCon
fig)); |
1069 SerializeQoffsetRange (it->measObjectEutra.offsetFreq); | 1072 SerializeQoffsetRange (it->measObjectEutra.offsetFreq); |
1070 | 1073 |
1071 if (!it->measObjectEutra.cellsToRemoveList.empty ()) | 1074 if (!it->measObjectEutra.cellsToRemoveList.empty ()) |
1072 { | 1075 { |
1073 SerializeSequenceOf (it->measObjectEutra.cellsToRemoveList.size ()
,MAX_CELL_MEAS,1); | 1076 SerializeSequenceOf (it->measObjectEutra.cellsToRemoveList.size
(),MAX_CELL_MEAS,1); |
1074 for (std::list<uint8_t>::iterator it2 = it->measObjectEutra.cellsT
oRemoveList.begin (); it2 != it->measObjectEutra.cellsToRemoveList.end (); it2++
) | 1077 for (std::list<uint8_t>::iterator it2 = it->measObjectEutra.cell
sToRemoveList.begin (); it2 != it->measObjectEutra.cellsToRemoveList.end (); it2
++) |
1075 { | 1078 { |
1076 SerializeInteger (*it2, 1, MAX_CELL_MEAS); | 1079 SerializeInteger (*it2, 1, MAX_CELL_MEAS); |
1077 } | 1080 } |
1078 } | 1081 } |
1079 | 1082 |
1080 if (!it->measObjectEutra.cellsToAddModList.empty ()) | 1083 if (!it->measObjectEutra.cellsToAddModList.empty ()) |
1081 { | 1084 { |
1082 SerializeSequenceOf (it->measObjectEutra.cellsToAddModList.size ()
, MAX_CELL_MEAS, 1); | 1085 SerializeSequenceOf (it->measObjectEutra.cellsToAddModList.size
(), MAX_CELL_MEAS, 1); |
1083 for (std::list<LteRrcSap::CellsToAddMod>::iterator it2 = it->measO
bjectEutra.cellsToAddModList.begin (); it2 != it->measObjectEutra.cellsToAddModL
ist.end (); it2++) | 1086 for (std::list<LteRrcSap::CellsToAddMod>::iterator it2 = it->mea
sObjectEutra.cellsToAddModList.begin (); it2 != it->measObjectEutra.cellsToAddMo
dList.end (); it2++) |
1084 { | 1087 { |
1085 SerializeSequence (std::bitset<0> (), false); | 1088 SerializeSequence (std::bitset<0> (), false); |
1086 | 1089 |
1087 // Serialize cellIndex | 1090 // Serialize cellIndex |
1088 SerializeInteger (it2->cellIndex, 1, MAX_CELL_MEAS); | 1091 SerializeInteger (it2->cellIndex, 1, MAX_CELL_MEAS); |
1089 | 1092 |
1090 // Serialize PhysCellId | 1093 // Serialize PhysCellId |
1091 SerializeInteger (it2->physCellId,0,503); | 1094 SerializeInteger (it2->physCellId,0,503); |
1092 | 1095 |
1093 // Serialize cellIndividualOffset | 1096 // Serialize cellIndividualOffset |
1094 SerializeQoffsetRange (it2->cellIndividualOffset); | 1097 SerializeQoffsetRange (it2->cellIndividualOffset); |
1095 } | 1098 } |
1096 } | 1099 } |
1097 | 1100 |
1098 if (!it->measObjectEutra.blackCellsToRemoveList.empty () ) | 1101 if (!it->measObjectEutra.blackCellsToRemoveList.empty () ) |
1099 { | 1102 { |
1100 SerializeSequenceOf (it->measObjectEutra.blackCellsToRemoveList.si
ze (),MAX_CELL_MEAS,1); | 1103 SerializeSequenceOf (it->measObjectEutra.blackCellsToRemoveList.
size (),MAX_CELL_MEAS,1); |
1101 for (std::list<uint8_t>::iterator it2 = it->measObjectEutra.blackC
ellsToRemoveList.begin (); it2 != it->measObjectEutra.blackCellsToRemoveList.end
(); it2++) | 1104 for (std::list<uint8_t>::iterator it2 = it->measObjectEutra.blac
kCellsToRemoveList.begin (); it2 != it->measObjectEutra.blackCellsToRemoveList.e
nd (); it2++) |
1102 { | 1105 { |
1103 SerializeInteger (*it2, 1, MAX_CELL_MEAS); | 1106 SerializeInteger (*it2, 1, MAX_CELL_MEAS); |
1104 } | 1107 } |
1105 } | 1108 } |
1106 | 1109 |
1107 if (!it->measObjectEutra.blackCellsToAddModList.empty () ) | 1110 if (!it->measObjectEutra.blackCellsToAddModList.empty () ) |
1108 { | 1111 { |
1109 SerializeSequenceOf (it->measObjectEutra.blackCellsToAddModList.si
ze (), MAX_CELL_MEAS, 1); | 1112 SerializeSequenceOf (it->measObjectEutra.blackCellsToAddModList.
size (), MAX_CELL_MEAS, 1); |
1110 for (std::list<LteRrcSap::BlackCellsToAddMod>::iterator it2 = it->
measObjectEutra.blackCellsToAddModList.begin (); it2 != it->measObjectEutra.blac
kCellsToAddModList.end (); it2++) | 1113 for (std::list<LteRrcSap::BlackCellsToAddMod>::iterator it2 = it
->measObjectEutra.blackCellsToAddModList.begin (); it2 != it->measObjectEutra.bl
ackCellsToAddModList.end (); it2++) |
1111 { | 1114 { |
1112 SerializeSequence (std::bitset<0> (),false); | 1115 SerializeSequence (std::bitset<0> (),false); |
1113 SerializeInteger (it2->cellIndex, 1, MAX_CELL_MEAS); | 1116 SerializeInteger (it2->cellIndex, 1, MAX_CELL_MEAS); |
1114 | 1117 |
1115 // Serialize PhysCellIdRange | 1118 // Serialize PhysCellIdRange |
1116 // range optional | 1119 // range optional |
1117 std::bitset<1> rangePresent = std::bitset<1> (it2->physCellIdR
ange.haveRange); | 1120 std::bitset<1> rangePresent = std::bitset<1> (it2->physCellI
dRange.haveRange); |
1118 SerializeSequence (rangePresent,false); | 1121 SerializeSequence (rangePresent,false); |
1119 SerializeInteger (it2->physCellIdRange.start,0,503); | 1122 SerializeInteger (it2->physCellIdRange.start,0,503); |
1120 if (it2->physCellIdRange.haveRange) | 1123 if (it2->physCellIdRange.haveRange) |
1121 { | 1124 { |
1122 switch (it2->physCellIdRange.range) | 1125 switch (it2->physCellIdRange.range) |
1123 { | 1126 { |
1124 case 4: | 1127 case 4: |
1125 SerializeEnum (16, 0); | 1128 SerializeEnum (16, 0); |
1126 break; | 1129 break; |
1127 case 8: | 1130 case 8: |
1128 SerializeEnum (16, 1); | 1131 SerializeEnum (16, 1); |
1129 break; | 1132 break; |
1130 case 12: | 1133 case 12: |
1131 SerializeEnum (16, 2); | 1134 SerializeEnum (16, 2); |
1132 break; | 1135 break; |
1133 case 16: | 1136 case 16: |
1134 SerializeEnum (16, 3); | 1137 SerializeEnum (16, 3); |
1135 break; | 1138 break; |
1136 case 24: | 1139 case 24: |
1137 SerializeEnum (16, 4); | 1140 SerializeEnum (16, 4); |
1138 break; | 1141 break; |
1139 case 32: | 1142 case 32: |
1140 SerializeEnum (16, 5); | 1143 SerializeEnum (16, 5); |
1141 break; | 1144 break; |
1142 case 48: | 1145 case 48: |
1143 SerializeEnum (16, 6); | 1146 SerializeEnum (16, 6); |
1144 break; | 1147 break; |
1145 case 64: | 1148 case 64: |
1146 SerializeEnum (16, 7); | 1149 SerializeEnum (16, 7); |
1147 break; | 1150 break; |
1148 case 84: | 1151 case 84: |
1149 SerializeEnum (16, 8); | 1152 SerializeEnum (16, 8); |
1150 break; | 1153 break; |
1151 case 96: | 1154 case 96: |
1152 SerializeEnum (16, 9); | 1155 SerializeEnum (16, 9); |
1153 break; | 1156 break; |
1154 case 128: | 1157 case 128: |
1155 SerializeEnum (16, 10); | 1158 SerializeEnum (16, 10); |
1156 break; | 1159 break; |
1157 case 168: | 1160 case 168: |
1158 SerializeEnum (16, 11); | 1161 SerializeEnum (16, 11); |
1159 break; | 1162 break; |
1160 case 252: | 1163 case 252: |
1161 SerializeEnum (16, 12); | 1164 SerializeEnum (16, 12); |
1162 break; | 1165 break; |
1163 case 504: | 1166 case 504: |
1164 SerializeEnum (16, 13); | 1167 SerializeEnum (16, 13); |
1165 break; | 1168 break; |
1166 default: | 1169 default: |
1167 SerializeEnum (16, 0); | 1170 SerializeEnum (16, 0); |
1168 } | 1171 } |
1169 } | 1172 } |
1170 } | 1173 } |
1171 | 1174 |
1172 } | 1175 } |
1173 | 1176 |
1174 if (it->measObjectEutra.haveCellForWhichToReportCGI) | 1177 if (it->measObjectEutra.haveCellForWhichToReportCGI) |
1175 { | 1178 { |
1176 SerializeInteger (it->measObjectEutra.cellForWhichToReportCGI,0,50
3); | 1179 SerializeInteger (it->measObjectEutra.cellForWhichToReportCGI,0,
503); |
1177 } | 1180 } |
1178 } | 1181 } |
1179 } | 1182 } |
1180 | 1183 |
1181 | 1184 |
1182 if (!measConfig.reportConfigToRemoveList.empty () ) | 1185 if (!measConfig.reportConfigToRemoveList.empty () ) |
1183 { | 1186 { |
1184 SerializeSequenceOf (measConfig.reportConfigToRemoveList.size (),MAX_REPOR
T_CONFIG_ID,1); | 1187 SerializeSequenceOf (measConfig.reportConfigToRemoveList.size (),MAX_REP
ORT_CONFIG_ID,1); |
1185 for (std::list<uint8_t>::iterator it = measConfig.reportConfigToRemoveList
.begin (); it != measConfig.reportConfigToRemoveList.end (); it++) | 1188 for (std::list<uint8_t>::iterator it = measConfig.reportConfigToRemoveLi
st.begin (); it != measConfig.reportConfigToRemoveList.end (); it++) |
1186 { | 1189 { |
1187 SerializeInteger (*it, 1,MAX_REPORT_CONFIG_ID); | 1190 SerializeInteger (*it, 1,MAX_REPORT_CONFIG_ID); |
1188 } | 1191 } |
1189 } | 1192 } |
1190 | 1193 |
1191 if (!measConfig.reportConfigToAddModList.empty () ) | 1194 if (!measConfig.reportConfigToAddModList.empty () ) |
1192 { | 1195 { |
1193 SerializeSequenceOf (measConfig.reportConfigToAddModList.size (),MAX_REPOR
T_CONFIG_ID,1); | 1196 SerializeSequenceOf (measConfig.reportConfigToAddModList.size (),MAX_REP
ORT_CONFIG_ID,1); |
1194 for (std::list<LteRrcSap::ReportConfigToAddMod>::iterator it = measConfig.
reportConfigToAddModList.begin (); it != measConfig.reportConfigToAddModList.end
(); it++) | 1197 for (std::list<LteRrcSap::ReportConfigToAddMod>::iterator it = measConfi
g.reportConfigToAddModList.begin (); it != measConfig.reportConfigToAddModList.e
nd (); it++) |
1195 { | 1198 { |
1196 SerializeSequence (std::bitset<0> (), false); | 1199 SerializeSequence (std::bitset<0> (), false); |
1197 SerializeInteger (it->reportConfigId,1,MAX_REPORT_CONFIG_ID); | 1200 SerializeInteger (it->reportConfigId,1,MAX_REPORT_CONFIG_ID); |
1198 SerializeChoice (2,0,false); // reportConfigEUTRA | 1201 SerializeChoice (2,0,false); // reportConfigEUTRA |
1199 | 1202 |
1200 // Serialize ReportConfigEUTRA | 1203 // Serialize ReportConfigEUTRA |
1201 SerializeSequence (std::bitset<0> (), true); | 1204 SerializeSequence (std::bitset<0> (), true); |
1202 switch (it->reportConfigEutra.triggerType) | 1205 switch (it->reportConfigEutra.triggerType) |
1203 { | 1206 { |
1204 case LteRrcSap::ReportConfigEutra::PERIODICAL: | 1207 case LteRrcSap::ReportConfigEutra::PERIODICAL: |
1205 SerializeChoice (2, 1, false);· | 1208 SerializeChoice (2, 1, false);· |
1206 SerializeSequence (std::bitset<0> (),false); | 1209 SerializeSequence (std::bitset<0> (),false); |
1207 switch (it->reportConfigEutra.purpose) | 1210 switch (it->reportConfigEutra.purpose) |
1208 { | 1211 { |
1209 case LteRrcSap::ReportConfigEutra::REPORT_CGI: | 1212 case LteRrcSap::ReportConfigEutra::REPORT_CGI: |
1210 SerializeEnum (2,1); | 1213 SerializeEnum (2,1); |
1211 break; | 1214 break; |
1212 case LteRrcSap::ReportConfigEutra::REPORT_STRONGEST_CELLS: | 1215 case LteRrcSap::ReportConfigEutra::REPORT_STRONGEST_CELLS: |
1213 default: | 1216 default: |
1214 SerializeEnum (2,0); | 1217 SerializeEnum (2,0); |
1215 } | 1218 } |
1216 break; | 1219 break; |
1217 case LteRrcSap::ReportConfigEutra::EVENT: | 1220 case LteRrcSap::ReportConfigEutra::EVENT: |
1218 default:· | 1221 default:· |
1219 SerializeChoice (2, 0, false); | 1222 SerializeChoice (2, 0, false); |
1220 SerializeSequence (std::bitset<0> (),false); | 1223 SerializeSequence (std::bitset<0> (),false); |
1221 switch (it->reportConfigEutra.eventId) | 1224 switch (it->reportConfigEutra.eventId) |
1222 { | 1225 { |
1223 case LteRrcSap::ReportConfigEutra::EVENT_A1: | 1226 case LteRrcSap::ReportConfigEutra::EVENT_A1: |
1224 SerializeChoice (5, 0, true); | 1227 SerializeChoice (5, 0, true); |
1225 SerializeSequence (std::bitset<0> (),false); | 1228 SerializeSequence (std::bitset<0> (),false); |
1226 SerializeThresholdEutra (it->reportConfigEutra.threshold1); | 1229 SerializeThresholdEutra (it->reportConfigEutra.threshold1); |
1227 break; | 1230 break; |
1228 case LteRrcSap::ReportConfigEutra::EVENT_A2: | 1231 case LteRrcSap::ReportConfigEutra::EVENT_A2: |
1229 SerializeChoice (5, 1, true); | 1232 SerializeChoice (5, 1, true); |
1230 SerializeSequence (std::bitset<0> (),false); | 1233 SerializeSequence (std::bitset<0> (),false); |
1231 SerializeThresholdEutra (it->reportConfigEutra.threshold1); | 1234 SerializeThresholdEutra (it->reportConfigEutra.threshold1); |
1232 break; | 1235 break; |
1233 case LteRrcSap::ReportConfigEutra::EVENT_A3: | 1236 case LteRrcSap::ReportConfigEutra::EVENT_A3: |
1234 SerializeChoice (5, 2, true); | 1237 SerializeChoice (5, 2, true); |
1235 SerializeSequence (std::bitset<0> (),false); | 1238 SerializeSequence (std::bitset<0> (),false); |
1236 SerializeInteger (it->reportConfigEutra.a3Offset,-30,30); | 1239 SerializeInteger (it->reportConfigEutra.a3Offset,-30,30); |
1237 SerializeBoolean (it->reportConfigEutra.reportOnLeave); | 1240 SerializeBoolean (it->reportConfigEutra.reportOnLeave); |
1238 break; | 1241 break; |
1239 case LteRrcSap::ReportConfigEutra::EVENT_A4: | 1242 case LteRrcSap::ReportConfigEutra::EVENT_A4: |
1240 SerializeChoice (5, 3, true); | 1243 SerializeChoice (5, 3, true); |
1241 SerializeSequence (std::bitset<0> (),false); | 1244 SerializeSequence (std::bitset<0> (),false); |
1242 SerializeThresholdEutra (it->reportConfigEutra.threshold1); | 1245 SerializeThresholdEutra (it->reportConfigEutra.threshold1); |
1243 break; | 1246 break; |
1244 case LteRrcSap::ReportConfigEutra::EVENT_A5: | 1247 case LteRrcSap::ReportConfigEutra::EVENT_A5: |
1245 default: | 1248 default: |
1246 SerializeChoice (5, 4, true); | 1249 SerializeChoice (5, 4, true); |
1247 SerializeSequence (std::bitset<0> (),false); | 1250 SerializeSequence (std::bitset<0> (),false); |
1248 SerializeThresholdEutra (it->reportConfigEutra.threshold1); | 1251 SerializeThresholdEutra (it->reportConfigEutra.threshold1); |
1249 SerializeThresholdEutra (it->reportConfigEutra.threshold2); | 1252 SerializeThresholdEutra (it->reportConfigEutra.threshold2); |
1250 } | 1253 } |
1251 | 1254 |
1252 SerializeInteger (it->reportConfigEutra.hysteresis, 0, 30); | 1255 SerializeInteger (it->reportConfigEutra.hysteresis, 0, 30); |
1253 | 1256 |
1254 switch (it->reportConfigEutra.timeToTrigger) | 1257 switch (it->reportConfigEutra.timeToTrigger) |
1255 { | 1258 { |
1256 case 0: | 1259 case 0: |
1257 SerializeEnum (16, 0); | 1260 SerializeEnum (16, 0); |
1258 break; | 1261 break; |
1259 case 40: | 1262 case 40: |
1260 SerializeEnum (16, 1); | 1263 SerializeEnum (16, 1); |
1261 break; | 1264 break; |
1262 case 64: | 1265 case 64: |
1263 SerializeEnum (16, 2); | 1266 SerializeEnum (16, 2); |
1264 break; | 1267 break; |
1265 case 80: | 1268 case 80: |
1266 SerializeEnum (16, 3); | 1269 SerializeEnum (16, 3); |
1267 break; | 1270 break; |
1268 case 100: | 1271 case 100: |
1269 SerializeEnum (16, 4); | 1272 SerializeEnum (16, 4); |
1270 break; | 1273 break; |
1271 case 128: | 1274 case 128: |
1272 SerializeEnum (16, 5); | 1275 SerializeEnum (16, 5); |
1273 break; | 1276 break; |
1274 case 160: | 1277 case 160: |
1275 SerializeEnum (16, 6); | 1278 SerializeEnum (16, 6); |
1276 break; | 1279 break; |
1277 case 256: | 1280 case 256: |
1278 SerializeEnum (16, 7); | 1281 SerializeEnum (16, 7); |
1279 break; | 1282 break; |
1280 case 320: | 1283 case 320: |
1281 SerializeEnum (16, 8); | 1284 SerializeEnum (16, 8); |
1282 break; | 1285 break; |
1283 case 480: | 1286 case 480: |
1284 SerializeEnum (16, 9); | 1287 SerializeEnum (16, 9); |
1285 break; | 1288 break; |
1286 case 512: | 1289 case 512: |
1287 SerializeEnum (16, 10); | 1290 SerializeEnum (16, 10); |
1288 break; | 1291 break; |
1289 case 640: | 1292 case 640: |
1290 SerializeEnum (16, 11); | 1293 SerializeEnum (16, 11); |
1291 break; | 1294 break; |
1292 case 1024: | 1295 case 1024: |
1293 SerializeEnum (16, 12); | 1296 SerializeEnum (16, 12); |
1294 break; | 1297 break; |
1295 case 1280: | 1298 case 1280: |
1296 SerializeEnum (16, 13); | 1299 SerializeEnum (16, 13); |
1297 break; | 1300 break; |
1298 case 2560: | 1301 case 2560: |
1299 SerializeEnum (16, 14); | 1302 SerializeEnum (16, 14); |
1300 break; | 1303 break; |
1301 case 5120: | 1304 case 5120: |
1302 default: | 1305 default: |
1303 SerializeEnum (16, 15); | 1306 SerializeEnum (16, 15); |
1304 } | 1307 } |
1305 } // end trigger type | 1308 } // end trigger type |
1306 | 1309 |
1307 // Serialize triggerQuantity | 1310 // Serialize triggerQuantity |
1308 if (it->reportConfigEutra.triggerQuantity == LteRrcSap::ReportConfigEu
tra::RSRP) | 1311 if (it->reportConfigEutra.triggerQuantity == LteRrcSap::ReportConfig
Eutra::RSRP) |
1309 { | 1312 { |
1310 SerializeEnum (2, 0); | 1313 SerializeEnum (2, 0); |
1311 } | 1314 } |
1312 else | 1315 else |
1313 { | 1316 { |
1314 SerializeEnum (2, 1); | 1317 SerializeEnum (2, 1); |
1315 } | 1318 } |
1316 | 1319 |
1317 // Serialize reportQuantity | 1320 // Serialize reportQuantity |
1318 if (it->reportConfigEutra.reportQuantity == LteRrcSap::ReportConfigEut
ra::SAME_AS_TRIGGER_QUANTITY) | 1321 if (it->reportConfigEutra.reportQuantity == LteRrcSap::ReportConfigE
utra::SAME_AS_TRIGGER_QUANTITY) |
1319 { | 1322 { |
1320 SerializeEnum (2, 0); | 1323 SerializeEnum (2, 0); |
1321 } | 1324 } |
1322 else | 1325 else |
1323 { | 1326 { |
1324 SerializeEnum (2, 1); | 1327 SerializeEnum (2, 1); |
1325 } | 1328 } |
1326 | 1329 |
1327 // Serialize maxReportCells | 1330 // Serialize maxReportCells |
1328 SerializeInteger (it->reportConfigEutra.maxReportCells, 1, MAX_CELL_RE
PORT); | 1331 SerializeInteger (it->reportConfigEutra.maxReportCells, 1, MAX_CELL_
REPORT); |
1329 | 1332 |
1330 // Serialize reportInterval | 1333 // Serialize reportInterval |
1331 switch (it->reportConfigEutra.reportInterval) | 1334 switch (it->reportConfigEutra.reportInterval) |
1332 { | 1335 { |
1333 case LteRrcSap::ReportConfigEutra::MS120: | 1336 case LteRrcSap::ReportConfigEutra::MS120: |
1334 SerializeEnum (16, 0); | 1337 SerializeEnum (16, 0); |
1335 break; | 1338 break; |
1336 case LteRrcSap::ReportConfigEutra::MS240: | 1339 case LteRrcSap::ReportConfigEutra::MS240: |
1337 SerializeEnum (16, 1); | 1340 SerializeEnum (16, 1); |
1338 break; | 1341 break; |
1339 case LteRrcSap::ReportConfigEutra::MS480: | 1342 case LteRrcSap::ReportConfigEutra::MS480: |
1340 SerializeEnum (16, 2); | 1343 SerializeEnum (16, 2); |
1341 break; | 1344 break; |
1342 case LteRrcSap::ReportConfigEutra::MS640: | 1345 case LteRrcSap::ReportConfigEutra::MS640: |
1343 SerializeEnum (16, 3); | 1346 SerializeEnum (16, 3); |
1344 break; | 1347 break; |
1345 case LteRrcSap::ReportConfigEutra::MS1024: | 1348 case LteRrcSap::ReportConfigEutra::MS1024: |
1346 SerializeEnum (16, 4); | 1349 SerializeEnum (16, 4); |
1347 break; | 1350 break; |
1348 case LteRrcSap::ReportConfigEutra::MS2048: | 1351 case LteRrcSap::ReportConfigEutra::MS2048: |
1349 SerializeEnum (16, 5); | 1352 SerializeEnum (16, 5); |
1350 break; | 1353 break; |
1351 case LteRrcSap::ReportConfigEutra::MS5120: | 1354 case LteRrcSap::ReportConfigEutra::MS5120: |
1352 SerializeEnum (16, 6); | 1355 SerializeEnum (16, 6); |
1353 break; | 1356 break; |
1354 case LteRrcSap::ReportConfigEutra::MS10240: | 1357 case LteRrcSap::ReportConfigEutra::MS10240: |
1355 SerializeEnum (16, 7); | 1358 SerializeEnum (16, 7); |
1356 break; | 1359 break; |
1357 case LteRrcSap::ReportConfigEutra::MIN1: | 1360 case LteRrcSap::ReportConfigEutra::MIN1: |
1358 SerializeEnum (16, 8); | 1361 SerializeEnum (16, 8); |
1359 break; | 1362 break; |
1360 case LteRrcSap::ReportConfigEutra::MIN6: | 1363 case LteRrcSap::ReportConfigEutra::MIN6: |
1361 SerializeEnum (16, 9); | 1364 SerializeEnum (16, 9); |
1362 break; | 1365 break; |
1363 case LteRrcSap::ReportConfigEutra::MIN12: | 1366 case LteRrcSap::ReportConfigEutra::MIN12: |
1364 SerializeEnum (16, 10); | 1367 SerializeEnum (16, 10); |
1365 break; | 1368 break; |
1366 case LteRrcSap::ReportConfigEutra::MIN30: | 1369 case LteRrcSap::ReportConfigEutra::MIN30: |
1367 SerializeEnum (16, 11); | 1370 SerializeEnum (16, 11); |
1368 break; | 1371 break; |
1369 case LteRrcSap::ReportConfigEutra::MIN60: | 1372 case LteRrcSap::ReportConfigEutra::MIN60: |
1370 SerializeEnum (16, 12); | 1373 SerializeEnum (16, 12); |
1371 break; | 1374 break; |
1372 case LteRrcSap::ReportConfigEutra::SPARE3: | 1375 case LteRrcSap::ReportConfigEutra::SPARE3: |
1373 SerializeEnum (16, 13); | 1376 SerializeEnum (16, 13); |
1374 break; | 1377 break; |
1375 case LteRrcSap::ReportConfigEutra::SPARE2: | 1378 case LteRrcSap::ReportConfigEutra::SPARE2: |
1376 SerializeEnum (16, 14); | 1379 SerializeEnum (16, 14); |
1377 break; | 1380 break; |
1378 case LteRrcSap::ReportConfigEutra::SPARE1: | 1381 case LteRrcSap::ReportConfigEutra::SPARE1: |
1379 default: | 1382 default: |
1380 SerializeEnum (16, 15); | 1383 SerializeEnum (16, 15); |
1381 } | 1384 } |
1382 | 1385 |
1383 // Serialize reportAmount | 1386 // Serialize reportAmount |
1384 switch (it->reportConfigEutra.reportAmount) | 1387 switch (it->reportConfigEutra.reportAmount) |
1385 { | 1388 { |
1386 case 1: | 1389 case 1: |
1387 SerializeEnum (8, 0); | 1390 SerializeEnum (8, 0); |
1388 break; | 1391 break; |
1389 case 2: | 1392 case 2: |
1390 SerializeEnum (8, 1); | 1393 SerializeEnum (8, 1); |
1391 break; | 1394 break; |
1392 case 4: | 1395 case 4: |
1393 SerializeEnum (8, 2); | 1396 SerializeEnum (8, 2); |
1394 break; | 1397 break; |
1395 case 8: | 1398 case 8: |
1396 SerializeEnum (8, 3); | 1399 SerializeEnum (8, 3); |
1397 break; | 1400 break; |
1398 case 16: | 1401 case 16: |
1399 SerializeEnum (8, 4); | 1402 SerializeEnum (8, 4); |
1400 break; | 1403 break; |
1401 case 32: | 1404 case 32: |
1402 SerializeEnum (8, 5); | 1405 SerializeEnum (8, 5); |
1403 break; | 1406 break; |
1404 case 64: | 1407 case 64: |
1405 SerializeEnum (8, 6); | 1408 SerializeEnum (8, 6); |
1406 break; | 1409 break; |
1407 default: | 1410 default: |
1408 SerializeEnum (8, 7); | 1411 SerializeEnum (8, 7); |
1409 } | 1412 } |
1410 } | 1413 } |
1411 } | 1414 } |
1412 | 1415 |
1413 if (!measConfig.measIdToRemoveList.empty () ) | 1416 if (!measConfig.measIdToRemoveList.empty () ) |
1414 { | 1417 { |
1415 SerializeSequenceOf (measConfig.measIdToRemoveList.size (), MAX_MEAS_ID, 1
); | 1418 SerializeSequenceOf (measConfig.measIdToRemoveList.size (), MAX_MEAS_ID,
1); |
1416 for (std::list<uint8_t>::iterator it = measConfig.measIdToRemoveList.begin
(); it != measConfig.measIdToRemoveList.end (); it++) | 1419 for (std::list<uint8_t>::iterator it = measConfig.measIdToRemoveList.beg
in (); it != measConfig.measIdToRemoveList.end (); it++) |
1417 { | 1420 { |
1418 SerializeInteger (*it, 1, MAX_MEAS_ID); | 1421 SerializeInteger (*it, 1, MAX_MEAS_ID); |
1419 } | 1422 } |
1420 } | 1423 } |
1421 | 1424 |
1422 if (!measConfig.measIdToAddModList.empty () ) | 1425 if (!measConfig.measIdToAddModList.empty () ) |
1423 { | 1426 { |
1424 SerializeSequenceOf ( measConfig.measIdToAddModList.size (), MAX_MEAS_ID,
1); | 1427 SerializeSequenceOf ( measConfig.measIdToAddModList.size (), MAX_MEAS_ID
, 1); |
1425 for (std::list<LteRrcSap::MeasIdToAddMod>::iterator it = measConfig.measId
ToAddModList.begin (); it != measConfig.measIdToAddModList.end (); it++) | 1428 for (std::list<LteRrcSap::MeasIdToAddMod>::iterator it = measConfig.meas
IdToAddModList.begin (); it != measConfig.measIdToAddModList.end (); it++) |
1426 { | 1429 { |
1427 SerializeInteger (it->measId, 1, MAX_MEAS_ID); | 1430 SerializeInteger (it->measId, 1, MAX_MEAS_ID); |
1428 SerializeInteger (it->measObjectId, 1, MAX_OBJECT_ID); | 1431 SerializeInteger (it->measObjectId, 1, MAX_OBJECT_ID); |
1429 SerializeInteger (it->reportConfigId, 1, MAX_REPORT_CONFIG_ID); | 1432 SerializeInteger (it->reportConfigId, 1, MAX_REPORT_CONFIG_ID); |
1430 } | 1433 } |
1431 } | 1434 } |
1432 | 1435 |
1433 if (measConfig.haveQuantityConfig ) | 1436 if (measConfig.haveQuantityConfig ) |
1434 { | 1437 { |
1435 // QuantityConfig sequence | 1438 // QuantityConfig sequence |
1436 // 4 optional fields, only first (EUTRA) present. Extension marker yes. | 1439 // 4 optional fields, only first (EUTRA) present. Extension marker yes. |
1437 std::bitset<4> quantityConfigOpts (0); | 1440 std::bitset<4> quantityConfigOpts (0); |
1438 quantityConfigOpts.set (3,1); | 1441 quantityConfigOpts.set (3,1); |
1439 SerializeSequence (quantityConfigOpts, true); | 1442 SerializeSequence (quantityConfigOpts, true); |
1440 SerializeSequence (std::bitset<0> (), false); | 1443 SerializeSequence (std::bitset<0> (), false); |
1441 | 1444 |
1442 switch (measConfig.quantityConfig.filterCoefficientRSRP) | 1445 switch (measConfig.quantityConfig.filterCoefficientRSRP) |
1443 { | 1446 { |
1444 case 0: | 1447 case 0: |
1445 SerializeEnum (16, 0); | 1448 SerializeEnum (16, 0); |
1446 break; | 1449 break; |
1447 case 1: | 1450 case 1: |
1448 SerializeEnum (16, 1); | 1451 SerializeEnum (16, 1); |
1449 break; | 1452 break; |
1450 case 2: | 1453 case 2: |
1451 SerializeEnum (16, 2); | 1454 SerializeEnum (16, 2); |
1452 break; | 1455 break; |
1453 case 3: | 1456 case 3: |
1454 SerializeEnum (16, 3); | 1457 SerializeEnum (16, 3); |
1455 break; | 1458 break; |
1456 case 4: | 1459 case 4: |
1457 SerializeEnum (16, 4); | 1460 SerializeEnum (16, 4); |
1458 break; | 1461 break; |
1459 case 5: | 1462 case 5: |
1460 SerializeEnum (16, 5); | 1463 SerializeEnum (16, 5); |
1461 break; | 1464 break; |
1462 case 6: | 1465 case 6: |
1463 SerializeEnum (16, 6); | 1466 SerializeEnum (16, 6); |
1464 break; | 1467 break; |
1465 case 7: | 1468 case 7: |
1466 SerializeEnum (16, 7); | 1469 SerializeEnum (16, 7); |
1467 break; | 1470 break; |
1468 case 8: | 1471 case 8: |
1469 SerializeEnum (16, 8); | 1472 SerializeEnum (16, 8); |
1470 break; | 1473 break; |
1471 case 9: | 1474 case 9: |
1472 SerializeEnum (16, 9); | 1475 SerializeEnum (16, 9); |
1473 break; | 1476 break; |
1474 case 11: | 1477 case 11: |
1475 SerializeEnum (16, 10); | 1478 SerializeEnum (16, 10); |
1476 break; | 1479 break; |
1477 case 13: | 1480 case 13: |
1478 SerializeEnum (16, 11); | 1481 SerializeEnum (16, 11); |
1479 break; | 1482 break; |
1480 case 15: | 1483 case 15: |
1481 SerializeEnum (16, 12); | 1484 SerializeEnum (16, 12); |
1482 break; | 1485 break; |
1483 case 17: | 1486 case 17: |
1484 SerializeEnum (16, 13); | 1487 SerializeEnum (16, 13); |
1485 break; | 1488 break; |
1486 case 19: | 1489 case 19: |
1487 SerializeEnum (16, 14); | 1490 SerializeEnum (16, 14); |
1488 break; | 1491 break; |
1489 default: | 1492 default: |
1490 SerializeEnum (16, 4); | 1493 SerializeEnum (16, 4); |
1491 } | 1494 } |
1492 | 1495 |
1493 switch (measConfig.quantityConfig.filterCoefficientRSRQ) | 1496 switch (measConfig.quantityConfig.filterCoefficientRSRQ) |
1494 { | 1497 { |
1495 case 0: | 1498 case 0: |
1496 SerializeEnum (16, 0); | 1499 SerializeEnum (16, 0); |
1497 break; | 1500 break; |
1498 case 1: | 1501 case 1: |
1499 SerializeEnum (16, 1); | 1502 SerializeEnum (16, 1); |
1500 break; | 1503 break; |
1501 case 2: | 1504 case 2: |
1502 SerializeEnum (16, 2); | 1505 SerializeEnum (16, 2); |
1503 break; | 1506 break; |
1504 case 3: | 1507 case 3: |
1505 SerializeEnum (16, 3); | 1508 SerializeEnum (16, 3); |
1506 break; | 1509 break; |
1507 case 4: | 1510 case 4: |
1508 SerializeEnum (16, 4); | 1511 SerializeEnum (16, 4); |
1509 break; | 1512 break; |
1510 case 5: | 1513 case 5: |
1511 SerializeEnum (16, 5); | 1514 SerializeEnum (16, 5); |
1512 break; | 1515 break; |
1513 case 6: | 1516 case 6: |
1514 SerializeEnum (16, 6); | 1517 SerializeEnum (16, 6); |
1515 break; | 1518 break; |
1516 case 7: | 1519 case 7: |
1517 SerializeEnum (16, 7); | 1520 SerializeEnum (16, 7); |
1518 break; | 1521 break; |
1519 case 8: | 1522 case 8: |
1520 SerializeEnum (16, 8); | 1523 SerializeEnum (16, 8); |
1521 break; | 1524 break; |
1522 case 9: | 1525 case 9: |
1523 SerializeEnum (16, 9); | 1526 SerializeEnum (16, 9); |
1524 break; | 1527 break; |
1525 case 11: | 1528 case 11: |
1526 SerializeEnum (16, 10); | 1529 SerializeEnum (16, 10); |
1527 break; | 1530 break; |
1528 case 13: | 1531 case 13: |
1529 SerializeEnum (16, 11); | 1532 SerializeEnum (16, 11); |
1530 break; | 1533 break; |
1531 case 15: | 1534 case 15: |
1532 SerializeEnum (16, 12); | 1535 SerializeEnum (16, 12); |
1533 break; | 1536 break; |
1534 case 17: | 1537 case 17: |
1535 SerializeEnum (16, 13); | 1538 SerializeEnum (16, 13); |
1536 break; | 1539 break; |
1537 case 19: | 1540 case 19: |
1538 SerializeEnum (16, 14); | 1541 SerializeEnum (16, 14); |
1539 break; | 1542 break; |
1540 default: | 1543 default: |
1541 SerializeEnum (16, 4); | 1544 SerializeEnum (16, 4); |
1542 } | 1545 } |
1543 } | 1546 } |
1544 | 1547 |
1545 if (measConfig.haveMeasGapConfig ) | 1548 if (measConfig.haveMeasGapConfig ) |
1546 { | 1549 { |
1547 switch (measConfig.measGapConfig.type) | 1550 switch (measConfig.measGapConfig.type) |
1548 { | 1551 { |
1549 case LteRrcSap::MeasGapConfig::RESET: | 1552 case LteRrcSap::MeasGapConfig::RESET: |
1550 SerializeChoice (2, 0, false); | 1553 SerializeChoice (2, 0, false); |
1551 SerializeNull (); | 1554 SerializeNull (); |
1552 break; | 1555 break; |
1553 case LteRrcSap::MeasGapConfig::SETUP: | 1556 case LteRrcSap::MeasGapConfig::SETUP: |
1554 default: | 1557 default: |
1555 SerializeChoice (2, 1, false); | 1558 SerializeChoice (2, 1, false); |
1556 SerializeSequence (std::bitset<0> (),false); | 1559 SerializeSequence (std::bitset<0> (),false); |
1557 switch (measConfig.measGapConfig.gapOffsetChoice) | 1560 switch (measConfig.measGapConfig.gapOffsetChoice) |
1558 { | 1561 { |
1559 case LteRrcSap::MeasGapConfig::GP0: | 1562 case LteRrcSap::MeasGapConfig::GP0: |
1560 SerializeChoice (2, 0, true); | 1563 SerializeChoice (2, 0, true); |
1561 SerializeInteger (measConfig.measGapConfig.gapOffsetValue, 0, 39); | 1564 SerializeInteger (measConfig.measGapConfig.gapOffsetValue, 0, 39
); |
1562 break; | 1565 break; |
1563 case LteRrcSap::MeasGapConfig::GP1: | 1566 case LteRrcSap::MeasGapConfig::GP1: |
1564 default: | 1567 default: |
1565 SerializeChoice (2, 1, true); | 1568 SerializeChoice (2, 1, true); |
1566 SerializeInteger (measConfig.measGapConfig.gapOffsetValue, 0, 79); | 1569 SerializeInteger (measConfig.measGapConfig.gapOffsetValue, 0, 79
); |
1567 } | 1570 } |
1568 } | 1571 } |
1569 } | 1572 } |
1570 | 1573 |
1571 if (measConfig.haveSmeasure ) | 1574 if (measConfig.haveSmeasure ) |
1572 { | 1575 { |
1573 SerializeInteger (measConfig.sMeasure, 0, 97); | 1576 SerializeInteger (measConfig.sMeasure, 0, 97); |
1574 } | 1577 } |
1575 | 1578 |
1576 // ...Here preRegistrationInfoHRPD would be serialized | 1579 // ...Here preRegistrationInfoHRPD would be serialized |
1577 | 1580 |
1578 if (measConfig.haveSpeedStatePars ) | 1581 if (measConfig.haveSpeedStatePars ) |
1579 { | 1582 { |
1580 switch (measConfig.speedStatePars.type) | 1583 switch (measConfig.speedStatePars.type) |
1581 { | 1584 { |
1582 case LteRrcSap::SpeedStatePars::RESET: | 1585 case LteRrcSap::SpeedStatePars::RESET: |
1583 SerializeChoice (2, 0, false); | 1586 SerializeChoice (2, 0, false); |
1584 SerializeNull (); | 1587 SerializeNull (); |
1585 break; | 1588 break; |
1586 case LteRrcSap::SpeedStatePars::SETUP: | 1589 case LteRrcSap::SpeedStatePars::SETUP: |
1587 default: | 1590 default: |
1588 SerializeChoice (2, 1, false); | 1591 SerializeChoice (2, 1, false); |
1589 SerializeSequence (std::bitset<0> (), false); | 1592 SerializeSequence (std::bitset<0> (), false); |
1590 switch (measConfig.speedStatePars.mobilityStateParameters.tEvaluation) | 1593 switch (measConfig.speedStatePars.mobilityStateParameters.tEvaluatio
n) |
1591 { | 1594 { |
1592 case 30: | 1595 case 30: |
1593 SerializeEnum (8, 0); | 1596 SerializeEnum (8, 0); |
1594 break; | 1597 break; |
1595 case 60: | 1598 case 60: |
1596 SerializeEnum (8, 1); | 1599 SerializeEnum (8, 1); |
1597 break; | 1600 break; |
1598 case 120: | 1601 case 120: |
1599 SerializeEnum (8, 2); | 1602 SerializeEnum (8, 2); |
1600 break; | 1603 break; |
1601 case 180: | 1604 case 180: |
1602 SerializeEnum (8, 3); | 1605 SerializeEnum (8, 3); |
1603 break; | 1606 break; |
1604 case 240: | 1607 case 240: |
1605 SerializeEnum (8, 4); | 1608 SerializeEnum (8, 4); |
1606 break; | 1609 break; |
1607 default: | 1610 default: |
1608 SerializeEnum (8, 5); | 1611 SerializeEnum (8, 5); |
1609 break; | 1612 break; |
1610 } | 1613 } |
1611 | 1614 |
1612 switch (measConfig.speedStatePars.mobilityStateParameters.tHystNormal) | 1615 switch (measConfig.speedStatePars.mobilityStateParameters.tHystNorma
l) |
1613 { | 1616 { |
1614 case 30: | 1617 case 30: |
1615 SerializeEnum (8, 0); | 1618 SerializeEnum (8, 0); |
1616 break; | 1619 break; |
1617 case 60: | 1620 case 60: |
1618 SerializeEnum (8, 1); | 1621 SerializeEnum (8, 1); |
1619 break; | 1622 break; |
1620 case 120: | 1623 case 120: |
1621 SerializeEnum (8, 2); | 1624 SerializeEnum (8, 2); |
1622 break; | 1625 break; |
1623 case 180: | 1626 case 180: |
1624 SerializeEnum (8, 3); | 1627 SerializeEnum (8, 3); |
1625 break; | 1628 break; |
1626 case 240: | 1629 case 240: |
1627 SerializeEnum (8, 4); | 1630 SerializeEnum (8, 4); |
1628 break; | 1631 break; |
1629 default: | 1632 default: |
1630 SerializeEnum (8, 5); | 1633 SerializeEnum (8, 5); |
1631 break; | 1634 break; |
1632 } | 1635 } |
1633 | 1636 |
1634 SerializeInteger (measConfig.speedStatePars.mobilityStateParameters.nC
ellChangeMedium, 1, 16); | 1637 SerializeInteger (measConfig.speedStatePars.mobilityStateParameters.
nCellChangeMedium, 1, 16); |
1635 SerializeInteger (measConfig.speedStatePars.mobilityStateParameters.nC
ellChangeHigh, 1, 16); | 1638 SerializeInteger (measConfig.speedStatePars.mobilityStateParameters.
nCellChangeHigh, 1, 16); |
1636 | 1639 |
1637 SerializeSequence (std::bitset<0> (), false); | 1640 SerializeSequence (std::bitset<0> (), false); |
1638 switch (measConfig.speedStatePars.timeToTriggerSf.sfMedium) | 1641 switch (measConfig.speedStatePars.timeToTriggerSf.sfMedium) |
1639 { | 1642 { |
1640 case 25: | 1643 case 25: |
1641 SerializeEnum (4, 0); | 1644 SerializeEnum (4, 0); |
1642 break; | 1645 break; |
1643 case 50: | 1646 case 50: |
1644 SerializeEnum (4, 1); | 1647 SerializeEnum (4, 1); |
1645 break; | 1648 break; |
1646 case 75: | 1649 case 75: |
1647 SerializeEnum (4, 2); | 1650 SerializeEnum (4, 2); |
1648 break; | 1651 break; |
1649 case 100: | 1652 case 100: |
1650 default: | 1653 default: |
1651 SerializeEnum (4, 3); | 1654 SerializeEnum (4, 3); |
1652 } | 1655 } |
1653 | 1656 |
1654 switch (measConfig.speedStatePars.timeToTriggerSf.sfHigh) | 1657 switch (measConfig.speedStatePars.timeToTriggerSf.sfHigh) |
1655 { | 1658 { |
1656 case 25: | 1659 case 25: |
1657 SerializeEnum (4, 0); | 1660 SerializeEnum (4, 0); |
1658 break; | 1661 break; |
1659 case 50: | 1662 case 50: |
1660 SerializeEnum (4, 1); | 1663 SerializeEnum (4, 1); |
1661 break; | 1664 break; |
1662 case 75: | 1665 case 75: |
1663 SerializeEnum (4, 2); | 1666 SerializeEnum (4, 2); |
1664 break; | 1667 break; |
1665 case 100: | 1668 case 100: |
1666 default: | 1669 default: |
1667 SerializeEnum (4, 3); | 1670 SerializeEnum (4, 3); |
1668 } | 1671 } |
1669 } | 1672 } |
1670 } | 1673 } |
1671 } | 1674 } |
1672 | 1675 void |
1673 Buffer::Iterator | 1676 RrcAsn1Header::SerializeNonCriticalExtensionConfiguration (LteRrcSap::NonCriti
calExtensionConfiguration nonCriticalExtension) const |
1674 RrcAsn1Header::DeserializeThresholdEutra (LteRrcSap::ThresholdEutra * thresholdE
utra, Buffer::Iterator bIterator) | 1677 { |
1675 { | 1678 // 3 optional fields. Extension marker not present. |
1676 int thresholdEutraChoice, range; | 1679 std::bitset<3> noncriticalExtension_v1020; |
1677 bIterator = DeserializeChoice (2, false, &thresholdEutraChoice, bIterator); | 1680 noncriticalExtension_v1020.set (1,0); // No sCellToRealeaseList-r10 |
1678 | 1681 noncriticalExtension_v1020.set (1,1); // sCellToAddModList-r10 |
1679 switch (thresholdEutraChoice) | 1682 noncriticalExtension_v1020.set (0,0); // No nonCriticalExtension RRCConnecti
onReconfiguration-v1130-IEs |
1680 { | 1683 SerializeSequence (noncriticalExtension_v1020,false); |
1681 case 0: | 1684 if (!nonCriticalExtension.sCellsToAddModList.empty ()) |
1682 thresholdEutra->choice = LteRrcSap::ThresholdEutra::THRESHOLD_RSRP; | 1685 { |
1683 bIterator = DeserializeInteger (&range, 0, 97, bIterator); | 1686 SerializeSequenceOf (nonCriticalExtension.sCellsToAddModList.size (),MAX
_OBJECT_ID,1); |
1684 thresholdEutra->range = range; | 1687 for (std::list<LteRrcSap::SCellToAddMod>::iterator it = nonCriticalExten
sion.sCellsToAddModList.begin (); it != nonCriticalExtension.sCellsToAddModList.
end (); it++) |
1685 break; | 1688 { |
1686 case 1: | 1689 std::bitset<4> sCellToAddMod_r10; |
1687 default: | 1690 sCellToAddMod_r10.set (3,1); // sCellIndex |
1688 thresholdEutra->choice = LteRrcSap::ThresholdEutra::THRESHOLD_RSRQ; | 1691 sCellToAddMod_r10.set (2,1); // CellIdentification |
1689 bIterator = DeserializeInteger (&range, 0, 34, bIterator); | 1692 sCellToAddMod_r10.set (1,1); // RadioResourceConfigCommonSCell |
1690 thresholdEutra->range = range; | 1693 sCellToAddMod_r10.set (0,it->haveRadioResourceConfigDedicatedSCell);
// No nonCriticalExtension RRC |
1691 } | 1694 SerializeSequence (sCellToAddMod_r10, false); |
1692 | 1695 SerializeInteger (it->sCellIndex,1,65536); //sCellIndex········· |
1693 return bIterator; | 1696 |
1694 } | 1697 // Serialize CellIdentification |
1695 | 1698 std::bitset<2> cellIdentification_r10; |
1696 Buffer::Iterator | 1699 cellIdentification_r10.set(1,1); // phyCellId-r10 |
1697 RrcAsn1Header::DeserializeQoffsetRange (int8_t * qOffsetRange, Buffer::Iterator
bIterator) | 1700 cellIdentification_r10.set(0,1); // dl-CarrierFreq-r10 |
1698 { | 1701 SerializeSequence (cellIdentification_r10, false); |
1699 int n; | 1702 |
1700 bIterator = DeserializeEnum (31, &n, bIterator); | 1703 SerializeInteger (it->cellIdentification.physCellId,1,65536); |
1701 switch (n) | 1704 SerializeInteger (it->cellIdentification.dlCarrierFreq,1,65536); |
1702 { | 1705 ············ |
1703 case 0: | 1706 //Serialize RadioResourceConfigCommonSCell |
1704 *qOffsetRange = -24; | 1707 SerializeRadioResourceConfigCommonSCell (it->radioResourceConfigComm
onSCell); |
1705 break; | 1708 ············ |
1706 case 1: | 1709 if (it->haveRadioResourceConfigDedicatedSCell) |
1707 *qOffsetRange = -22; | 1710 { |
1708 break; | 1711 //Serialize RadioResourceConfigDedicatedSCell |
1709 case 2: | 1712 SerializeRadioResourceDedicatedSCell (it->radioResourceConfigDed
icateSCell); |
1710 *qOffsetRange = -20; | 1713 } |
1711 break; | 1714 ············ |
1712 case 3: | 1715 } |
1713 *qOffsetRange = -18; | 1716 } |
1714 break; | 1717 else |
1715 case 4: | 1718 { |
1716 *qOffsetRange = -16; | 1719 // NS_ASSERT_MSG ( this << "NonCriticalExtension.sCellsToAddModLi
st cannot be empty ", false); |
1717 break; | 1720 } |
1718 case 5: | 1721 ·· |
1719 *qOffsetRange = -14; | 1722 } |
1720 break; | 1723 void |
1721 case 6: | 1724 RrcAsn1Header::SerializeRadioResourceConfigCommonSCell (LteRrcSap::RadioResour
ceConfigCommonSCell rrccsc) const |
1722 *qOffsetRange = -12; | 1725 { |
1723 break; | 1726 // 2 optional fields. Extension marker not present. |
1724 case 7: | 1727 std::bitset<2> radioResourceConfigCommonSCell_r10; |
1725 *qOffsetRange = -10; | 1728 radioResourceConfigCommonSCell_r10.set (1,rrccsc.haveNonUlConfiguration); //
NonUlConfiguration |
1726 break; | 1729 radioResourceConfigCommonSCell_r10.set (0,rrccsc.haveUlConfiguration); // Ul
Configuration |
1727 case 8: | 1730 SerializeSequence (radioResourceConfigCommonSCell_r10,false); |
1728 *qOffsetRange = -8; | 1731 ····· |
1729 break; | 1732 if (radioResourceConfigCommonSCell_r10[1]) |
1730 case 9: | 1733 { |
1731 *qOffsetRange = -6; | 1734 // 5 optional fields. Extension marker not present. |
1732 break; | 1735 std::bitset<5> nonUlConfiguration_r10; |
1733 case 10: | 1736 nonUlConfiguration_r10.set (4,1); // Dl- bandwidth --> convert in enum |
1734 *qOffsetRange = -5; | 1737 nonUlConfiguration_r10.set (3,1); // AntennaInfoCommon-r10 |
1735 break; | 1738 nonUlConfiguration_r10.set (2,0); // phich-Config-r10 Not Implemented |
1736 case 11: | 1739 nonUlConfiguration_r10.set (1,1); // pdschConfigCommon |
1737 *qOffsetRange = -4; | 1740 nonUlConfiguration_r10.set (0,0); // Tdd-Config-r10 Not Implemented |
1738 break; | 1741 SerializeSequence (nonUlConfiguration_r10,false); |
1739 case 12: | 1742 |
1740 *qOffsetRange = -3; | 1743 SerializeInteger (rrccsc.nonUlConfiguration.dlBandwidth,6,100);· |
1741 break; | 1744 ········ |
1742 case 13: | 1745 std::bitset<1> antennaInfoCommon_r10; |
1743 *qOffsetRange = -2; | 1746 antennaInfoCommon_r10.set (0,1); |
1744 break; | 1747 SerializeSequence (antennaInfoCommon_r10,false); |
1745 case 14: | 1748 SerializeInteger (rrccsc.nonUlConfiguration.antennaInfoCommon.antennaPor
tsCount,0,65536); |
1746 *qOffsetRange = -1; | 1749 ········ |
1747 break; | 1750 std::bitset<2> pdschConfigCommon_r10; |
1748 case 15: | 1751 pdschConfigCommon_r10.set (1,1); |
1749 *qOffsetRange = 0; | 1752 pdschConfigCommon_r10.set (0,1); |
1750 break; | 1753 SerializeSequence (pdschConfigCommon_r10,false); |
1751 case 16: | 1754 ········ |
1752 *qOffsetRange = 1; | 1755 SerializeInteger (rrccsc.nonUlConfiguration.pdschConfigCommon.referenceS
ignalPower,-60,50); |
1753 break; | 1756 SerializeInteger (rrccsc.nonUlConfiguration.pdschConfigCommon.pb,0,3);· |
1754 case 17: | 1757 ········ |
1755 *qOffsetRange = 2; | 1758 } |
1756 break; | 1759 if (radioResourceConfigCommonSCell_r10[0]) |
1757 case 18: | 1760 { |
1758 *qOffsetRange = 3; | 1761 //Serialize Ul Configuration |
1759 break; | 1762 // 7 optional fields. Extension marker present. |
1760 case 19: | 1763 std::bitset<7> UlConfiguration_r10; |
1761 *qOffsetRange = 4; | 1764 UlConfiguration_r10.set (6,1); // ul-Configuration-r10 |
1762 break; | 1765 UlConfiguration_r10.set (5,0); // p-Max-r10 Not Implemented |
1763 case 20: | 1766 UlConfiguration_r10.set (4,1); // uplinkPowerControlCommonSCell-r10 |
1764 *qOffsetRange = 5; | 1767 UlConfiguration_r10.set (3,0); // soundingRS-UL-ConfigCommon-r10 |
1765 break; | 1768 UlConfiguration_r10.set (2,0); // ul-CyclicPrefixLength-r10 |
1766 case 21: | 1769 UlConfiguration_r10.set (1,1); // prach-ConfigSCell-r10 |
1767 *qOffsetRange = 6; | 1770 UlConfiguration_r10.set (0,0); // pusch-ConfigCommon-r10 Not Implemented |
1768 break; | 1771 SerializeSequence (UlConfiguration_r10,true); |
1769 case 22: | 1772 |
1770 *qOffsetRange = 8; | 1773 //Serialize ulFreqInfo |
1771 break; | 1774 std::bitset<3> FreqInfo_r10; |
1772 case 23: | 1775 FreqInfo_r10.set (2,1); // ulCarrierFreq |
1773 *qOffsetRange = 10; | 1776 FreqInfo_r10.set (1,1); // UlBandwidth |
1774 break; | 1777 FreqInfo_r10.set (0,0); // additionalSpectrumEmissionSCell-r10 Not Impl
emented |
1775 case 24: | 1778 SerializeSequence (FreqInfo_r10,false); |
1776 *qOffsetRange = 12; | 1779 ········· |
1777 break; | 1780 SerializeInteger (rrccsc.ulConfiguration.ulFreqInfo.ulCarrierFreq,0,655
36); |
1778 case 25: | 1781 SerializeInteger (rrccsc.ulConfiguration.ulFreqInfo.ulBandwidth,6,100); |
1779 *qOffsetRange = 14; | 1782 |
1780 break; | 1783 //Serialize UlPowerControllCommonSCell |
1781 case 26: | 1784 std::bitset<2> UlPowerControlCommonSCell_r10; |
1782 *qOffsetRange = 16; | 1785 UlPowerControlCommonSCell_r10.set (1,0); // p0-NominalPUSCH-r10 Not Imp
lemented······· |
1783 break; | 1786 UlPowerControlCommonSCell_r10.set (0,1); // alpha |
1784 case 27: | 1787 SerializeSequence (UlPowerControlCommonSCell_r10,false); |
1785 *qOffsetRange = 18; | 1788 ········· |
1786 break; | 1789 SerializeInteger (rrccsc.ulConfiguration.ulPowerControlCommonSCell.alph
a,0,65536); |
1787 case 28: | 1790 |
1788 *qOffsetRange = 20; | 1791 //Serialize soundingRs-UlConfigCommon |
1789 break; | 1792 //Not Implemented |
1790 case 29: | 1793 |
1791 *qOffsetRange = 22; | 1794 //Serialize PrachConfigSCell |
1792 break; | 1795 std::bitset<1> prachConfigSCell_r10; |
1793 case 30: | 1796 prachConfigSCell_r10.set(0,1); |
1794 default: | 1797 SerializeSequence(prachConfigSCell_r10,false); |
1795 *qOffsetRange = 24; | 1798 SerializeInteger (rrccsc.ulConfiguration.prachConfigSCell.index,0,256);················· |
1796 } | 1799 } |
1797 return bIterator; | 1800 |
1798 } | 1801 ····· |
1799 | 1802 } |
1800 Buffer::Iterator | 1803 void |
1801 RrcAsn1Header::DeserializeRadioResourceConfigDedicated (LteRrcSap::RadioResource
ConfigDedicated *radioResourceConfigDedicated, Buffer::Iterator bIterator) | 1804 RrcAsn1Header::SerializeRadioResourceDedicatedSCell (LteRrcSap::RadioResourceC
onfigDedicatedSCell rrcdsc) const |
1802 { | 1805 { |
1803 // Deserialize RadioResourceConfigDedicated sequence | 1806 //Serialize RadioResourceConfigDedicatedSCell |
1804 std::bitset<6> optionalFieldsPresent = std::bitset<6> (); | 1807 std::bitset<1> RadioResourceConfigDedicatedSCell_r10; |
1805 bIterator = DeserializeSequence (&optionalFieldsPresent,true,bIterator); | 1808 RadioResourceConfigDedicatedSCell_r10.set (0,1); |
1806 | 1809 SerializeSequence (RadioResourceConfigDedicatedSCell_r10,false); |
1807 if (optionalFieldsPresent[5]) | 1810 |
1808 { | 1811 LteRrcSap::PhysicalConfigDedicatedSCell pcdsc = rrcdsc.physicalConfigDedicat
edSCell; |
1809 // Deserialize srb-ToAddModList | 1812 SerializePhysicalConfigDedicatedSCell (pcdsc); |
1810 bIterator = DeserializeSrbToAddModList (&(radioResourceConfigDedicated->sr
bToAddModList),bIterator); | 1813 } |
1811 } | 1814 ·· |
1812 | 1815 void |
1813 if (optionalFieldsPresent[4]) | 1816 RrcAsn1Header::SerializePhysicalConfigDedicatedSCell (LteRrcSap::PhysicalConfi
gDedicatedSCell pcdsc) const |
1814 { | 1817 { |
1815 // Deserialize drb-ToAddModList | 1818 std::bitset<2> pcdscOpt; |
1816 bIterator = DeserializeDrbToAddModList (&(radioResourceConfigDedicated->dr
bToAddModList),bIterator); | 1819 pcdscOpt.set (1,pcdsc.haveNonUlConfiguration); |
1817 } | 1820 pcdscOpt.set (0,pcdsc.haveUlConfiguration); |
1818 | 1821 SerializeSequence (pcdscOpt, true); |
1819 if (optionalFieldsPresent[3]) | 1822 |
1820 { | 1823 if (pcdscOpt[1]) |
1821 // Deserialize drb-ToReleaseList | 1824 { |
1822 int n; | 1825 //Serialize NonUl configuration |
1823 int val; | 1826 std::bitset<4> nulOpt; |
1824 bIterator = DeserializeSequenceOf (&n,MAX_DRB,1,bIterator); | 1827 nulOpt.set (3,pcdsc.haveAntennaInfoDedicated); |
1825 for (int i = 0; i < n; i++) | 1828 nulOpt.set (2,0); // crossCarrierSchedulingConfig-r10 NOT IMplemented |
1826 { | 1829 nulOpt.set (1,0); // csi-RS-Config-r10 Not Implemented |
1827 bIterator = DeserializeInteger (&val,1,32,bIterator); | 1830 nulOpt.set (0, pcdsc.havePdschConfigDedicated); // pdsch-ConfigDedicated
-r10 |
1828 radioResourceConfigDedicated->drbToReleaseList.push_back (val); | 1831 SerializeSequence (nulOpt,false); |
1829 } | 1832 ········ |
1830 } | 1833 if (pcdsc.haveAntennaInfoDedicated) |
1831 | 1834 { |
1832 if (optionalFieldsPresent[2]) | 1835 // Serialize antennaInfo choice |
1833 { | 1836 // 2 options. Selected: 0 ("explicitValue" of type "AntennaInfoDedic
ated") |
1834 // Deserialize mac-MainConfig | 1837 SerializeChoice (2,0,false); |
1835 // ... | 1838 |
1836 } | 1839 // Serialize AntennaInfoDedicated sequence |
1837 | 1840 // 1 optional parameter, not present. No extension marker. |
1838 if (optionalFieldsPresent[1]) | 1841 SerializeSequence (std::bitset<1> (0),false); |
1839 { | 1842 |
1840 // Deserialize sps-Config | 1843 // Serialize transmissionMode |
1841 // ... | 1844 // Assuming the value in the struct is the enum index |
1842 } | 1845 SerializeEnum (8,pcdsc.antennaInfo.transmissionMode); |
1843 | 1846 |
1844 radioResourceConfigDedicated->havePhysicalConfigDedicated = optionalFieldsPres
ent[0]; | 1847 // Serialize ue-TransmitAntennaSelection choice |
1845 if (optionalFieldsPresent[0]) | 1848 SerializeChoice (2,0,false); |
1846 { | 1849 |
1847 // Deserialize physicalConfigDedicated | 1850 // Serialize release |
1848 bIterator = DeserializePhysicalConfigDedicated (&radioResourceConfigDedica
ted->physicalConfigDedicated,bIterator); | 1851 SerializeNull (); |
1849 } | 1852 } |
1850 | 1853 if (pcdsc.havePdschConfigDedicated) |
1851 return bIterator; | 1854 { |
1852 } | 1855 // Serialize Pdsch-ConfigDedicated Sequence: |
1853 | 1856 // 0 optional / default fields, no extension marker. |
1854 Buffer::Iterator | 1857 SerializeSequence (std::bitset<0> (),false); |
1855 RrcAsn1Header::DeserializeSrbToAddModList (std::list<LteRrcSap::SrbToAddMod> *sr
bToAddModList, Buffer::Iterator bIterator) | 1858 |
1856 { | 1859 // Serialize p-a |
1857 int numElems; | 1860 // Assuming the value in the struct is the enum index |
1858 bIterator = DeserializeSequenceOf (&numElems,2,1,bIterator); | 1861 SerializeEnum (8,pcdsc.pdschConfigDedicated.pa); |
1859 | 1862 |
1860 srbToAddModList->clear (); | 1863 // Serialize release |
1861 | 1864 SerializeNull (); |
1862 // Deserialize SRB-ToAddMod elements | 1865 } |
1863 for (int i = 0; i < numElems; i++) | 1866 |
1864 { | 1867 |
1865 LteRrcSap::SrbToAddMod srbToAddMod; | 1868 } |
1866 // Deserialize SRB-ToAddMod sequence | 1869 if (pcdscOpt[0]) |
1867 // 2 optional fields, extension marker present | 1870 { |
1868 std::bitset<2> optionalFields; | 1871 //Serialize Ul Configuration |
1869 bIterator = DeserializeSequence (&optionalFields,true,bIterator); | 1872 std::bitset<7> ulOpt; |
1870 | 1873 ulOpt.set (6, pcdsc.haveAntennaInfoUlDedicated);// antennaInfoUL-r10 |
1871 // Deserialize srbIdentity | 1874 ulOpt.set (5,0); // pusch-ConfigDedicatedSCell-r10 not present· |
1872 int n; | 1875 ulOpt.set (4,0); // uplinkPowerControlDedicatedSCell-r10 not present |
1873 bIterator = DeserializeInteger (&n,1,2,bIterator); | 1876 ulOpt.set (3,0); // cqi-ReportConfigSCell-r10 not present |
1874 srbToAddMod.srbIdentity = n; | 1877 ulOpt.set (2,pcdsc.haveSoundingRsUlConfigDedicated);// soundingRS-UL-Con
figDedicated-r10 |
1875 | 1878 ulOpt.set (1,0); // soundingRS-UL-ConfigDedicated-v1020 not present |
1876 if (optionalFields[1]) | 1879 ulOpt.set (0,0); // soundingRS-UL-ConfigDedicatedAperiodic-r10 not prese
nt |
1877 { | 1880 SerializeSequence (ulOpt,false); |
1878 // Deserialize rlcConfig choice | 1881 ········ |
1879 // ... | 1882 if (pcdsc.haveAntennaInfoUlDedicated) |
1880 } | 1883 { |
1881 | 1884 // Serialize antennaInfo choice |
1882 if (optionalFields[0]) | 1885 // 2 options. Selected: 0 ("explicitValue" of type "AntennaInfoDedic
ated") |
1883 { | 1886 SerializeChoice (2,0,false); |
1884 // Deserialize logicalChannelConfig choice | 1887 |
1885 int sel; | 1888 // Serialize AntennaInfoDedicated sequence |
1886 bIterator = DeserializeChoice (2,false,&sel,bIterator); | 1889 // 1 optional parameter, not present. No extension marker. |
1887 | 1890 SerializeSequence (std::bitset<1> (0),false); |
1888 // Deserialize logicalChannelConfig defaultValue | 1891 |
1889 if (sel == 1) | 1892 // Serialize transmissionMode |
1890 { | 1893 // Assuming the value in the struct is the enum index |
1891 bIterator = DeserializeNull (bIterator); | 1894 SerializeEnum (8,pcdsc.antennaInfoUl.transmissionMode); |
1892 } | 1895 |
1893 | 1896 // Serialize ue-TransmitAntennaSelection choice |
1894 // Deserialize logicalChannelConfig explicitValue | 1897 SerializeChoice (2,0,false); |
1895 else if (sel == 0) | 1898 |
1896 { | 1899 // Serialize release |
1897 bIterator = DeserializeLogicalChannelConfig (&srbToAddMod.logicalC
hannelConfig,bIterator); | 1900 SerializeNull (); |
1898 } | 1901 } |
1899 } | 1902 if (pcdsc.haveSoundingRsUlConfigDedicated) |
1900 srbToAddModList->insert (srbToAddModList->end (),srbToAddMod); | 1903 { |
1901 } | 1904 // Serialize SoundingRS-UL-ConfigDedicated choice: |
1902 | 1905 switch (pcdsc.soundingRsUlConfigDedicated.type) |
1903 return bIterator; | 1906 { |
1904 } | 1907 case LteRrcSap::SoundingRsUlConfigDedicated::RESET: |
1905 | 1908 SerializeChoice (2,0,false); |
1906 Buffer::Iterator | 1909 SerializeNull (); |
1907 RrcAsn1Header::DeserializeDrbToAddModList (std::list<LteRrcSap::DrbToAddMod> *dr
bToAddModList, Buffer::Iterator bIterator) | 1910 break; |
1908 { | 1911 |
1909 int n; | 1912 case LteRrcSap::SoundingRsUlConfigDedicated::SETUP: |
1910 int val; | 1913 default: |
1911 bIterator = DeserializeSequenceOf (&n,MAX_DRB,1,bIterator); | 1914 // 2 options, selected: 1 (setup) |
1912 | 1915 SerializeChoice (2,1,false); |
1913 drbToAddModList->clear (); | 1916 |
1914 | 1917 // Serialize setup sequence |
1915 for (int i = 0; i < n; i++) | 1918 // 0 optional / default fields, no extension marker. |
1916 { | 1919 SerializeSequence (std::bitset<0> (),false); |
1917 LteRrcSap::DrbToAddMod drbToAddMod; | 1920 |
1918 | 1921 // Serialize srs-Bandwidth |
1919 std::bitset<5> optionalFields; | 1922 SerializeEnum (4,pcdsc.soundingRsUlConfigDedicated.srsBandwidth)
; |
1920 bIterator = DeserializeSequence (&optionalFields,true,bIterator); | 1923 |
1921 | 1924 // Serialize srs-HoppingBandwidth |
1922 if (optionalFields[4]) | 1925 SerializeEnum (4,0); |
1923 { | 1926 |
1924 // Deserialize epsBearerIdentity | 1927 // Serialize freqDomainPosition |
1925 bIterator = DeserializeInteger (&val,0,15,bIterator); | 1928 SerializeInteger (0,0,23); |
1926 drbToAddMod.epsBearerIdentity = val; | 1929 |
1927 } | 1930 // Serialize duration |
1928 | 1931 SerializeBoolean (false); |
1929 bIterator = DeserializeInteger (&val,1,32,bIterator); | 1932 |
1930 drbToAddMod.drbIdentity = val; | 1933 // Serialize srs-ConfigIndex |
1931 | 1934 SerializeInteger (pcdsc.soundingRsUlConfigDedicated.srsConfigInd
ex,0,1023); |
1932 if (optionalFields[3]) | 1935 |
1933 { | 1936 // Serialize transmissionComb |
1934 // Deserialize pdcp-Config | 1937 SerializeInteger (0,0,1); |
1935 // ... | 1938 |
1936 } | 1939 // Serialize cyclicShift |
1937 | 1940 SerializeEnum (8,0); |
1938 if (optionalFields[2]) | 1941 |
1939 { | 1942 break; |
1940 // Deserialize RLC-Config | 1943 } |
1941 int chosen; | 1944 ·············· |
1942 bIterator = DeserializeChoice (4,true,&chosen,bIterator); | 1945 } |
1943 | 1946 ······ |
1944 int sel; | 1947 |
1945 std::bitset<0> bitset0; | 1948 } |
1946 switch (chosen) | 1949 } |
1947 { | 1950 |
1948 case 0: | 1951 Buffer::Iterator |
1949 drbToAddMod.rlcConfig.choice = LteRrcSap::RlcConfig::AM; | 1952 RrcAsn1Header::DeserializeThresholdEutra (LteRrcSap::ThresholdEutra * threshol
dEutra, Buffer::Iterator bIterator) |
1950 | 1953 { |
1951 // Deserialize UL-AM-RLC | 1954 int thresholdEutraChoice, range; |
1952 bIterator = DeserializeSequence (&bitset0,false, bIterator); | 1955 bIterator = DeserializeChoice (2, false, &thresholdEutraChoice, bIterator); |
1953 bIterator = DeserializeEnum (64,&sel, bIterator); // t-PollRetrans
mit | 1956 |
1954 bIterator = DeserializeEnum (8,&sel, bIterator); // pollPDU | 1957 switch (thresholdEutraChoice) |
1955 bIterator = DeserializeEnum (16,&sel, bIterator); // pollByte | 1958 { |
1956 bIterator = DeserializeEnum (8,&sel, bIterator); // maxRetxThresho
ld | 1959 case 0: |
1957 | 1960 thresholdEutra->choice = LteRrcSap::ThresholdEutra::THRESHOLD_RSRP; |
1958 // Deserialize DL-AM-RLC | 1961 bIterator = DeserializeInteger (&range, 0, 97, bIterator); |
1959 bIterator = DeserializeSequence (&bitset0,false, bIterator); | 1962 thresholdEutra->range = range; |
1960 bIterator = DeserializeEnum (32,&sel, bIterator); // t-Reordering | 1963 break; |
1961 bIterator = DeserializeEnum (64,&sel, bIterator); // t-StatusProhi
bit | 1964 case 1: |
1962 break; | 1965 default: |
1963 | 1966 thresholdEutra->choice = LteRrcSap::ThresholdEutra::THRESHOLD_RSRQ; |
1964 case 1: | 1967 bIterator = DeserializeInteger (&range, 0, 34, bIterator); |
1965 drbToAddMod.rlcConfig.choice = LteRrcSap::RlcConfig::UM_BI_DIRECTI
ONAL; | 1968 thresholdEutra->range = range; |
1966 | 1969 } |
1967 // Deserialize UL-UM-RLC | 1970 |
1968 bIterator = DeserializeSequence (&bitset0,false, bIterator); | 1971 return bIterator; |
1969 bIterator = DeserializeEnum (2,&sel, bIterator); // sn-FieldLength | 1972 } |
1970 | 1973 |
1971 // Deserialize DL-UM-RLC | 1974 Buffer::Iterator |
1972 bIterator = DeserializeSequence (&bitset0,false, bIterator); | 1975 RrcAsn1Header::DeserializeQoffsetRange (int8_t * qOffsetRange, Buffer::Iterato
r bIterator) |
1973 bIterator = DeserializeEnum (2,&sel, bIterator); // sn-FieldLength | 1976 { |
1974 bIterator = DeserializeEnum (32,&sel, bIterator); // t-Reordering | 1977 int n; |
1975 break; | 1978 bIterator = DeserializeEnum (31, &n, bIterator); |
1976 | 1979 switch (n) |
1977 case 2: | 1980 { |
1978 drbToAddMod.rlcConfig.choice = LteRrcSap::RlcConfig::UM_UNI_DIRECT
IONAL_UL; | 1981 case 0: |
1979 | 1982 *qOffsetRange = -24; |
1980 // Deserialize UL-UM-RLC | 1983 break; |
1981 bIterator = DeserializeSequence (&bitset0,false, bIterator); | 1984 case 1: |
1982 bIterator = DeserializeEnum (2,&sel, bIterator); // sn-FieldLength | 1985 *qOffsetRange = -22; |
1983 break; | 1986 break; |
1984 | 1987 case 2: |
1985 case 3: | 1988 *qOffsetRange = -20; |
1986 drbToAddMod.rlcConfig.choice = LteRrcSap::RlcConfig::UM_UNI_DIRECT
IONAL_DL; | 1989 break; |
1987 | 1990 case 3: |
1988 // Deserialize DL-UM-RLC | 1991 *qOffsetRange = -18; |
1989 bIterator = DeserializeSequence (&bitset0,false, bIterator); | 1992 break; |
1990 bIterator = DeserializeEnum (2,&sel, bIterator); // sn-FieldLength | 1993 case 4: |
1991 bIterator = DeserializeEnum (32,&sel, bIterator); // t-Reordering | 1994 *qOffsetRange = -16; |
1992 break; | 1995 break; |
1993 } | 1996 case 5: |
1994 | 1997 *qOffsetRange = -14; |
1995 } | 1998 break; |
1996 | 1999 case 6: |
1997 if (optionalFields[1]) | 2000 *qOffsetRange = -12; |
1998 { | 2001 break; |
1999 bIterator = DeserializeInteger (&val,3,10,bIterator); | 2002 case 7: |
2000 drbToAddMod.logicalChannelIdentity = val; | 2003 *qOffsetRange = -10; |
2001 } | 2004 break; |
2002 | 2005 case 8: |
2003 if (optionalFields[0]) | 2006 *qOffsetRange = -8; |
2004 { | 2007 break; |
2005 bIterator = DeserializeLogicalChannelConfig (&drbToAddMod.logicalChann
elConfig,bIterator); | 2008 case 9: |
2006 } | 2009 *qOffsetRange = -6; |
2007 | 2010 break; |
2008 drbToAddModList->insert (drbToAddModList->end (),drbToAddMod); | 2011 case 10: |
2009 } | 2012 *qOffsetRange = -5; |
2010 return bIterator; | 2013 break; |
2011 } | 2014 case 11: |
2012 | 2015 *qOffsetRange = -4; |
2013 Buffer::Iterator | 2016 break; |
2014 RrcAsn1Header::DeserializeLogicalChannelConfig (LteRrcSap::LogicalChannelConfig
*logicalChannelConfig, Buffer::Iterator bIterator) | 2017 case 12: |
2015 { | 2018 *qOffsetRange = -3; |
2016 int n; | 2019 break; |
2017 | 2020 case 13: |
2018 // Deserialize LogicalChannelConfig sequence | 2021 *qOffsetRange = -2; |
2019 // 1 optional field, extension marker is present. | 2022 break; |
2020 std::bitset<1> bitset1; | 2023 case 14: |
2021 bIterator = DeserializeSequence (&bitset1,true,bIterator); | 2024 *qOffsetRange = -1; |
2022 | 2025 break; |
2023 if (bitset1[0]) | 2026 case 15: |
2024 { | 2027 *qOffsetRange = 0; |
2025 // Deserialize ul-SpecificParameters sequence | 2028 break; |
2026 bIterator = DeserializeSequence (&bitset1,false,bIterator); | 2029 case 16: |
2027 | 2030 *qOffsetRange = 1; |
2028 // Deserialize priority | 2031 break; |
2029 bIterator = DeserializeInteger (&n,1,16,bIterator); | 2032 case 17: |
2030 logicalChannelConfig->priority = n; | 2033 *qOffsetRange = 2; |
2031 | 2034 break; |
2032 // Deserialize prioritisedBitRate | 2035 case 18: |
2033 bIterator = DeserializeEnum (16,&n,bIterator); | 2036 *qOffsetRange = 3; |
2034 uint16_t prioritizedBitRateKbps; | 2037 break; |
2035 | 2038 case 19: |
2036 switch (n) | 2039 *qOffsetRange = 4; |
2037 { | 2040 break; |
2038 case 0: | 2041 case 20: |
2039 prioritizedBitRateKbps = 0; | 2042 *qOffsetRange = 5; |
2040 break; | 2043 break; |
2041 case 1: | 2044 case 21: |
2042 prioritizedBitRateKbps = 8; | 2045 *qOffsetRange = 6; |
2043 break; | 2046 break; |
2044 case 2: | 2047 case 22: |
2045 prioritizedBitRateKbps = 16; | 2048 *qOffsetRange = 8; |
2046 break; | 2049 break; |
2047 case 3: | 2050 case 23: |
2048 prioritizedBitRateKbps = 32; | 2051 *qOffsetRange = 10; |
2049 break; | 2052 break; |
2050 case 4: | 2053 case 24: |
2051 prioritizedBitRateKbps = 64; | 2054 *qOffsetRange = 12; |
2052 break; | 2055 break; |
2053 case 5: | 2056 case 25: |
2054 prioritizedBitRateKbps = 128; | 2057 *qOffsetRange = 14; |
2055 break; | 2058 break; |
2056 case 6: | 2059 case 26: |
2057 prioritizedBitRateKbps = 256; | 2060 *qOffsetRange = 16; |
2058 break; | 2061 break; |
2059 case 7: | 2062 case 27: |
2060 prioritizedBitRateKbps = 10000; | 2063 *qOffsetRange = 18; |
2061 break; | 2064 break; |
2062 default: | 2065 case 28: |
2063 prioritizedBitRateKbps = 10000; | 2066 *qOffsetRange = 20; |
2064 } | 2067 break; |
2065 logicalChannelConfig->prioritizedBitRateKbps = prioritizedBitRateKbps; | 2068 case 29: |
2066 | 2069 *qOffsetRange = 22; |
2067 // Deserialize bucketSizeDuration | 2070 break; |
2068 bIterator = DeserializeEnum (8,&n,bIterator); | 2071 case 30: |
2069 uint16_t bucketSizeDurationMs; | 2072 default: |
2070 switch (n) | 2073 *qOffsetRange = 24; |
2071 { | 2074 } |
2072 case 0: | 2075 return bIterator; |
2073 bucketSizeDurationMs = 50; | 2076 } |
2074 break; | 2077 |
2075 case 1: | 2078 Buffer::Iterator |
2076 bucketSizeDurationMs = 100; | 2079 RrcAsn1Header::DeserializeRadioResourceConfigDedicated (LteRrcSap::RadioResour
ceConfigDedicated *radioResourceConfigDedicated, Buffer::Iterator bIterator) |
2077 break; | 2080 { |
2078 case 2: | 2081 // Deserialize RadioResourceConfigDedicated sequence |
2079 bucketSizeDurationMs = 150; | 2082 std::bitset<6> optionalFieldsPresent = std::bitset<6> (); |
2080 break; | 2083 bIterator = DeserializeSequence (&optionalFieldsPresent,true,bIterator); |
2081 case 3: | 2084 |
2082 bucketSizeDurationMs = 300; | 2085 if (optionalFieldsPresent[5]) |
2083 break; | 2086 { |
2084 case 4: | 2087 // Deserialize srb-ToAddModList |
2085 bucketSizeDurationMs = 500; | 2088 bIterator = DeserializeSrbToAddModList (&(radioResourceConfigDedicated->
srbToAddModList),bIterator); |
2086 break; | 2089 } |
2087 case 5: | 2090 |
2088 bucketSizeDurationMs = 1000; | 2091 if (optionalFieldsPresent[4]) |
2089 break; | 2092 { |
2090 default: | 2093 // Deserialize drb-ToAddModList |
2091 bucketSizeDurationMs = 1000; | 2094 bIterator = DeserializeDrbToAddModList (&(radioResourceConfigDedicated->
drbToAddModList),bIterator); |
2092 } | 2095 } |
2093 logicalChannelConfig->bucketSizeDurationMs = bucketSizeDurationMs; | 2096 |
2094 | 2097 if (optionalFieldsPresent[3]) |
2095 if (bitset1[0]) | 2098 { |
2096 { | 2099 // Deserialize drb-ToReleaseList |
2097 // Deserialize logicalChannelGroup | 2100 int n; |
2098 bIterator = DeserializeInteger (&n,0,3,bIterator); | 2101 int val; |
2099 logicalChannelConfig->logicalChannelGroup = n; | 2102 bIterator = DeserializeSequenceOf (&n,MAX_DRB,1,bIterator); |
2100 } | 2103 for (int i = 0; i < n; i++) |
2101 } | 2104 { |
2102 return bIterator; | 2105 bIterator = DeserializeInteger (&val,1,32,bIterator); |
2103 } | 2106 radioResourceConfigDedicated->drbToReleaseList.push_back (val); |
2104 | 2107 } |
2105 Buffer::Iterator | 2108 } |
2106 RrcAsn1Header::DeserializePhysicalConfigDedicated (LteRrcSap::PhysicalConfigDedi
cated *physicalConfigDedicated, Buffer::Iterator bIterator) | 2109 |
2107 { | 2110 if (optionalFieldsPresent[2]) |
2108 std::bitset<10> optionalFieldPresent; | 2111 { |
2109 bIterator = DeserializeSequence (&optionalFieldPresent,true,bIterator); | 2112 // Deserialize mac-MainConfig |
2110 | 2113 // ... |
2111 physicalConfigDedicated->havePdschConfigDedicated = optionalFieldPresent[9]; | 2114 } |
2112 if (optionalFieldPresent[9]) | 2115 |
2113 { | 2116 if (optionalFieldsPresent[1]) |
2114 // Deserialize pdsch-ConfigDedicated | 2117 { |
2115 std::bitset<0> bitset0; | 2118 // Deserialize sps-Config |
2116 bIterator = DeserializeSequence (&bitset0,false,bIterator); | 2119 // ... |
2117 | 2120 } |
2118 int slct; | 2121 |
2119 | 2122 radioResourceConfigDedicated->havePhysicalConfigDedicated = optionalFieldsPr
esent[0]; |
2120 // Deserialize p-a | 2123 if (optionalFieldsPresent[0]) |
2121 bIterator = DeserializeEnum (8,&slct,bIterator); | 2124 { |
2122 physicalConfigDedicated->pdschConfigDedicated.pa = slct; | 2125 // Deserialize physicalConfigDedicated |
2123 | 2126 bIterator = DeserializePhysicalConfigDedicated (&radioResourceConfigDedi
cated->physicalConfigDedicated,bIterator); |
2124 bIterator = DeserializeNull (bIterator); | 2127 } |
2125 | 2128 |
2126 } | 2129 return bIterator; |
2127 if (optionalFieldPresent[8]) | 2130 } |
2128 { | 2131 |
2129 // Deserialize pucch-ConfigDedicated | 2132 Buffer::Iterator |
2130 // ... | 2133 RrcAsn1Header::DeserializeSrbToAddModList (std::list<LteRrcSap::SrbToAddMod> *
srbToAddModList, Buffer::Iterator bIterator) |
2131 } | 2134 { |
2132 if (optionalFieldPresent[7]) | 2135 int numElems; |
2133 { | 2136 bIterator = DeserializeSequenceOf (&numElems,2,1,bIterator); |
2134 // Deserialize pusch-ConfigDedicated | 2137 |
2135 // ... | 2138 srbToAddModList->clear (); |
2136 } | 2139 |
2137 if (optionalFieldPresent[6]) | 2140 // Deserialize SRB-ToAddMod elements |
2138 { | 2141 for (int i = 0; i < numElems; i++) |
2139 // Deserialize uplinkPowerControlDedicated | 2142 { |
2140 // ... | 2143 LteRrcSap::SrbToAddMod srbToAddMod; |
2141 } | 2144 // Deserialize SRB-ToAddMod sequence |
2142 if (optionalFieldPresent[5]) | 2145 // 2 optional fields, extension marker present |
2143 { | 2146 std::bitset<2> optionalFields; |
2144 // Deserialize tpc-PDCCH-ConfigPUCCH | 2147 bIterator = DeserializeSequence (&optionalFields,true,bIterator); |
2145 // ... | 2148 |
2146 } | 2149 // Deserialize srbIdentity |
2147 if (optionalFieldPresent[4]) | 2150 int n; |
2148 { | 2151 bIterator = DeserializeInteger (&n,1,2,bIterator); |
2149 // Deserialize tpc-PDCCH-ConfigPUSCH | 2152 srbToAddMod.srbIdentity = n; |
2150 // ... | 2153 |
2151 } | 2154 if (optionalFields[1]) |
2152 if (optionalFieldPresent[3]) | 2155 { |
2153 { | 2156 // Deserialize rlcConfig choice |
2154 // Deserialize cqi-ReportConfig | 2157 // ... |
2155 // ... | 2158 } |
2156 } | 2159 |
2157 physicalConfigDedicated->haveSoundingRsUlConfigDedicated = optionalFieldPresen
t[2]; | 2160 if (optionalFields[0]) |
2158 if (optionalFieldPresent[2]) | 2161 { |
2159 { | 2162 // Deserialize logicalChannelConfig choice |
2160 // Deserialize soundingRS-UL-ConfigDedicated | 2163 int sel; |
2161 int sel; | 2164 bIterator = DeserializeChoice (2,false,&sel,bIterator); |
2162 bIterator = DeserializeChoice (2,false,&sel,bIterator); | 2165 |
2163 | 2166 // Deserialize logicalChannelConfig defaultValue |
2164 if (sel == 0) | 2167 if (sel == 1) |
2165 { | 2168 { |
2166 physicalConfigDedicated->soundingRsUlConfigDedicated.type = LteRrcSap:
:SoundingRsUlConfigDedicated::RESET; | 2169 bIterator = DeserializeNull (bIterator); |
2167 | 2170 } |
2168 bIterator = DeserializeNull (bIterator); | 2171 |
2169 } | 2172 // Deserialize logicalChannelConfig explicitValue |
2170 | 2173 else if (sel == 0) |
2171 else if (sel == 1) | 2174 { |
2172 { | 2175 bIterator = DeserializeLogicalChannelConfig (&srbToAddMod.logica
lChannelConfig,bIterator); |
2173 physicalConfigDedicated->soundingRsUlConfigDedicated.type = LteRrcSap:
:SoundingRsUlConfigDedicated::SETUP; | 2176 } |
2174 | 2177 } |
2175 std::bitset<0> bitset0; | 2178 srbToAddModList->insert (srbToAddModList->end (),srbToAddMod); |
2176 bIterator = DeserializeSequence (&bitset0,false,bIterator); | 2179 } |
2177 | 2180 |
2178 int slct; | 2181 return bIterator; |
2179 | 2182 } |
2180 // Deserialize srs-Bandwidth | 2183 |
2181 bIterator = DeserializeEnum (4,&slct,bIterator); | 2184 Buffer::Iterator |
2182 physicalConfigDedicated->soundingRsUlConfigDedicated.srsBandwidth = sl
ct; | 2185 RrcAsn1Header::DeserializeDrbToAddModList (std::list<LteRrcSap::DrbToAddMod> *
drbToAddModList, Buffer::Iterator bIterator) |
2183 | 2186 { |
2184 // Deserialize srs-HoppingBandwidth | 2187 int n; |
2185 bIterator = DeserializeEnum (4,&slct,bIterator); | 2188 int val; |
2186 | 2189 bIterator = DeserializeSequenceOf (&n,MAX_DRB,1,bIterator); |
2187 // Deserialize freqDomainPosition | 2190 |
2188 bIterator = DeserializeInteger (&slct,0,23,bIterator); | 2191 drbToAddModList->clear (); |
2189 | 2192 |
2190 // Deserialize duration | 2193 for (int i = 0; i < n; i++) |
2191 bool duration; | 2194 { |
2192 bIterator = DeserializeBoolean (&duration,bIterator); | 2195 LteRrcSap::DrbToAddMod drbToAddMod; |
2193 | 2196 |
2194 // Deserialize srs-ConfigIndex | 2197 std::bitset<5> optionalFields; |
2195 bIterator = DeserializeInteger (&slct,0,1023,bIterator); | 2198 bIterator = DeserializeSequence (&optionalFields,true,bIterator); |
2196 physicalConfigDedicated->soundingRsUlConfigDedicated.srsConfigIndex =
slct; | 2199 |
2197 | 2200 if (optionalFields[4]) |
2198 // Deserialize transmissionComb | 2201 { |
2199 bIterator = DeserializeInteger (&slct,0,1,bIterator); | 2202 // Deserialize epsBearerIdentity |
2200 | 2203 bIterator = DeserializeInteger (&val,0,15,bIterator); |
2201 // Deserialize cyclicShift | 2204 drbToAddMod.epsBearerIdentity = val; |
2202 bIterator = DeserializeEnum (8,&slct,bIterator); | 2205 } |
2203 } | 2206 |
2204 } | 2207 bIterator = DeserializeInteger (&val,1,32,bIterator); |
2205 physicalConfigDedicated->haveAntennaInfoDedicated = optionalFieldPresent[1]; | 2208 drbToAddMod.drbIdentity = val; |
2206 if (optionalFieldPresent[1]) | 2209 |
2207 { | 2210 if (optionalFields[3]) |
2208 // Deserialize antennaInfo | 2211 { |
2209 int sel; | 2212 // Deserialize pdcp-Config |
2210 bIterator = DeserializeChoice (2,false,&sel,bIterator); | 2213 // ... |
2211 if (sel == 1) | 2214 } |
2212 { | 2215 |
2213 bIterator = DeserializeNull (bIterator); | 2216 if (optionalFields[2]) |
2214 } | 2217 { |
2215 else if (sel == 0) | 2218 // Deserialize RLC-Config |
2216 { | 2219 int chosen; |
2217 std::bitset<1> codebookSubsetRestrictionPresent; | 2220 bIterator = DeserializeChoice (4,true,&chosen,bIterator); |
2218 bIterator = DeserializeSequence (&codebookSubsetRestrictionPresent,fal
se,bIterator); | 2221 |
2219 | 2222 int sel; |
2220 int txmode; | 2223 std::bitset<0> bitset0; |
2221 bIterator = DeserializeEnum (8,&txmode,bIterator); | 2224 switch (chosen) |
2222 physicalConfigDedicated->antennaInfo.transmissionMode = txmode; | 2225 { |
2223 | 2226 case 0: |
2224 if (codebookSubsetRestrictionPresent[0]) | 2227 drbToAddMod.rlcConfig.choice = LteRrcSap::RlcConfig::AM; |
2225 { | 2228 |
2226 // Deserialize codebookSubsetRestriction | 2229 // Deserialize UL-AM-RLC |
2227 // ... | 2230 bIterator = DeserializeSequence (&bitset0,false, bIterator); |
2228 } | 2231 bIterator = DeserializeEnum (64,&sel, bIterator); // t-PollRetra
nsmit |
2229 | 2232 bIterator = DeserializeEnum (8,&sel, bIterator); // pollPDU |
2230 int txantennaselchosen; | 2233 bIterator = DeserializeEnum (16,&sel, bIterator); // pollByte |
2231 bIterator = DeserializeChoice (2,false,&txantennaselchosen,bIterator); | 2234 bIterator = DeserializeEnum (8,&sel, bIterator); // maxRetxThres
hold |
2232 if (txantennaselchosen == 0) | 2235 |
2233 { | 2236 // Deserialize DL-AM-RLC |
2234 // Deserialize ue-TransmitAntennaSelection release | 2237 bIterator = DeserializeSequence (&bitset0,false, bIterator); |
2235 bIterator = DeserializeNull (bIterator); | 2238 bIterator = DeserializeEnum (32,&sel, bIterator); // t-Reorderin
g |
2236 } | 2239 bIterator = DeserializeEnum (64,&sel, bIterator); // t-StatusPro
hibit |
2237 else if (txantennaselchosen == 1) | 2240 break; |
2238 { | 2241 |
2239 // Deserialize ue-TransmitAntennaSelection setup | 2242 case 1: |
2240 // ... | 2243 drbToAddMod.rlcConfig.choice = LteRrcSap::RlcConfig::UM_BI_DIREC
TIONAL; |
2241 } | 2244 |
2242 } | 2245 // Deserialize UL-UM-RLC |
2243 } | 2246 bIterator = DeserializeSequence (&bitset0,false, bIterator); |
2244 if (optionalFieldPresent[0]) | 2247 bIterator = DeserializeEnum (2,&sel, bIterator); // sn-FieldLeng
th |
2245 { | 2248 |
2246 // Deserialize schedulingRequestConfig | 2249 // Deserialize DL-UM-RLC |
2247 // ... | 2250 bIterator = DeserializeSequence (&bitset0,false, bIterator); |
2248 } | 2251 bIterator = DeserializeEnum (2,&sel, bIterator); // sn-FieldLeng
th |
2249 return bIterator; | 2252 bIterator = DeserializeEnum (32,&sel, bIterator); // t-Reorderin
g |
2250 } | 2253 break; |
2251 | 2254 |
2252 void | 2255 case 2: |
2253 RrcAsn1Header::Print (std::ostream &os) const | 2256 drbToAddMod.rlcConfig.choice = LteRrcSap::RlcConfig::UM_UNI_DIRE
CTIONAL_UL; |
2254 { | 2257 |
2255 NS_LOG_FUNCTION (this << &os); | 2258 // Deserialize UL-UM-RLC |
2256 NS_FATAL_ERROR ("RrcAsn1Header Print() function must also specify LteRrcSap::R
adioResourceConfigDedicated as a second argument"); | 2259 bIterator = DeserializeSequence (&bitset0,false, bIterator); |
2257 } | 2260 bIterator = DeserializeEnum (2,&sel, bIterator); // sn-FieldLeng
th |
2258 | 2261 break; |
2259 void | 2262 |
2260 RrcAsn1Header::Print (std::ostream &os, LteRrcSap::RadioResourceConfigDedicated
radioResourceConfigDedicated) const | 2263 case 3: |
2261 { | 2264 drbToAddMod.rlcConfig.choice = LteRrcSap::RlcConfig::UM_UNI_DIRE
CTIONAL_DL; |
2262 os << " srbToAddModList: " << std::endl; | 2265 |
2263 std::list<LteRrcSap::SrbToAddMod>::iterator it = radioResourceConfigDedicated.
srbToAddModList.begin (); | 2266 // Deserialize DL-UM-RLC |
2264 for (; it != radioResourceConfigDedicated.srbToAddModList.end (); it++) | 2267 bIterator = DeserializeSequence (&bitset0,false, bIterator); |
2265 { | 2268 bIterator = DeserializeEnum (2,&sel, bIterator); // sn-FieldLeng
th |
2266 os << " srbIdentity: " << (int)it->srbIdentity << std::endl; | 2269 bIterator = DeserializeEnum (32,&sel, bIterator); // t-Reorderin
g |
2267 os << " logicalChannelConfig: " << std::endl; | 2270 break; |
2268 os << " priority: " << (int)it->logicalChannelConfig.priority <<
std::endl; | 2271 } |
2269 os << " prioritizedBitRateKbps: " << (int)it->logicalChannelConfi
g.prioritizedBitRateKbps << std::endl; | 2272 |
2270 os << " bucketSizeDurationMs: " << (int)it->logicalChannelConfig.
bucketSizeDurationMs << std::endl; | 2273 } |
2271 os << " logicalChannelGroup: " << (int)it->logicalChannelConfig.l
ogicalChannelGroup << std::endl; | 2274 |
2272 } | 2275 if (optionalFields[1]) |
2273 os << std::endl; | 2276 { |
2274 | 2277 bIterator = DeserializeInteger (&val,3,10,bIterator); |
2275 os << " drbToAddModList: " << std::endl; | 2278 drbToAddMod.logicalChannelIdentity = val; |
2276 std::list<LteRrcSap::DrbToAddMod>::iterator it2 = radioResourceConfigDedicated
.drbToAddModList.begin (); | 2279 } |
2277 for (; it2 != radioResourceConfigDedicated.drbToAddModList.end (); it2++) | 2280 |
2278 { | 2281 if (optionalFields[0]) |
2279 os << " epsBearerIdentity: " << (int)it2->epsBearerIdentity << std::e
ndl; | 2282 { |
2280 os << " drbIdentity: " << (int)it2->drbIdentity << std::endl; | 2283 bIterator = DeserializeLogicalChannelConfig (&drbToAddMod.logicalCha
nnelConfig,bIterator); |
2281 os << " rlcConfig: " << it2->rlcConfig.choice << std::endl; | 2284 } |
2282 os << " logicalChannelIdentity: " << (int)it2->logicalChannelIdentity
<< std::endl; | 2285 |
2283 os << " logicalChannelConfig: " << std::endl; | 2286 drbToAddModList->insert (drbToAddModList->end (),drbToAddMod); |
2284 os << " priority: " << (int)it2->logicalChannelConfig.priority <<
std::endl; | 2287 } |
2285 os << " prioritizedBitRateKbps: " << (int)it2->logicalChannelConf
ig.prioritizedBitRateKbps << std::endl; | 2288 return bIterator; |
2286 os << " bucketSizeDurationMs: " << (int)it2->logicalChannelConfig
.bucketSizeDurationMs << std::endl; | 2289 } |
2287 os << " logicalChannelGroup: " << (int)it2->logicalChannelConfig.
logicalChannelGroup << std::endl; | 2290 |
2288 } | 2291 Buffer::Iterator |
2289 os << std::endl; | 2292 RrcAsn1Header::DeserializeLogicalChannelConfig (LteRrcSap::LogicalChannelConfi
g *logicalChannelConfig, Buffer::Iterator bIterator) |
2290 | 2293 { |
2291 os << " drbToReleaseList: "; | 2294 int n; |
2292 std::list<uint8_t>::iterator it3 = radioResourceConfigDedicated.drbToReleaseLi
st.begin (); | 2295 |
2293 for (; it3 != radioResourceConfigDedicated.drbToReleaseList.end (); it3++) | 2296 // Deserialize LogicalChannelConfig sequence |
2294 { | 2297 // 1 optional field, extension marker is present. |
2295 os << (int)*it3 << ", "; | 2298 std::bitset<1> bitset1; |
2296 } | 2299 bIterator = DeserializeSequence (&bitset1,true,bIterator); |
2297 os << std::endl; | 2300 |
2298 | 2301 if (bitset1[0]) |
2299 os << " havePhysicalConfigDedicated: " << radioResourceConfigDedicated.haveP
hysicalConfigDedicated << std::endl; | 2302 { |
2300 | 2303 // Deserialize ul-SpecificParameters sequence |
2301 if (radioResourceConfigDedicated.havePhysicalConfigDedicated) | 2304 bIterator = DeserializeSequence (&bitset1,false,bIterator); |
2302 { | 2305 |
2303 os << " physicalConfigDedicated: " << std::endl; | 2306 // Deserialize priority |
2304 | 2307 bIterator = DeserializeInteger (&n,1,16,bIterator); |
2305 os << " haveSoundingRsUlConfigDedicated: " << radioResourceConfigDedi
cated.physicalConfigDedicated.haveSoundingRsUlConfigDedicated << std::endl; | 2308 logicalChannelConfig->priority = n; |
2306 if (radioResourceConfigDedicated.physicalConfigDedicated.haveSoundingRsUlC
onfigDedicated) | 2309 |
2307 { | 2310 // Deserialize prioritisedBitRate |
2308 os << " soundingRsUlConfigDedicated: " << std::endl; | 2311 bIterator = DeserializeEnum (16,&n,bIterator); |
2309 os << " type: " << radioResourceConfigDedicated.physicalConfig
Dedicated.soundingRsUlConfigDedicated.type << std::endl; | 2312 uint16_t prioritizedBitRateKbps; |
2310 os << " srsBandwidth: " << (int)radioResourceConfigDedicated.p
hysicalConfigDedicated.soundingRsUlConfigDedicated.srsBandwidth << std::endl; | 2313 |
2311 os << " srsConfigIndex: " << (int)radioResourceConfigDedicated
.physicalConfigDedicated.soundingRsUlConfigDedicated.srsConfigIndex << std::endl
; | 2314 switch (n) |
2312 } | 2315 { |
2313 | 2316 case 0: |
2314 os << " haveAntennaInfoDedicated: " << radioResourceConfigDedicated.p
hysicalConfigDedicated.haveAntennaInfoDedicated << std::endl; | 2317 prioritizedBitRateKbps = 0; |
2315 if (radioResourceConfigDedicated.physicalConfigDedicated.haveAntennaInfoDe
dicated) | 2318 break; |
2316 { | 2319 case 1: |
2317 os << " antennaInfo Tx mode: " << (int)radioResourceConfigDedicat
ed.physicalConfigDedicated.antennaInfo.transmissionMode << std::endl; | 2320 prioritizedBitRateKbps = 8; |
2318 } | 2321 break; |
2319 } | 2322 case 2: |
2320 } | 2323 prioritizedBitRateKbps = 16; |
2321 | 2324 break; |
2322 Buffer::Iterator | 2325 case 3: |
2323 RrcAsn1Header::DeserializeSystemInformationBlockType1 (LteRrcSap::SystemInformat
ionBlockType1 *systemInformationBlockType1, Buffer::Iterator bIterator) | 2326 prioritizedBitRateKbps = 32; |
2324 { | 2327 break; |
2325 std::bitset<0> bitset0; | 2328 case 4: |
2326 int n; | 2329 prioritizedBitRateKbps = 64; |
2327 | 2330 break; |
2328 std::bitset<3> sysInfoBlkT1Opts; | 2331 case 5: |
2329 bIterator = DeserializeSequence (&sysInfoBlkT1Opts,false,bIterator); | 2332 prioritizedBitRateKbps = 128; |
2330 | 2333 break; |
2331 // Deserialize cellAccessRelatedInfo | 2334 case 6: |
2332 std::bitset<1> cellAccessRelatedInfoOpts; | 2335 prioritizedBitRateKbps = 256; |
2333 bIterator = DeserializeSequence (&cellAccessRelatedInfoOpts,false,bIterator); | 2336 break; |
2334 | 2337 case 7: |
2335 // Deserialize plmn-IdentityList | 2338 prioritizedBitRateKbps = 10000; |
2336 int numPlmnIdentityInfoElements; | 2339 break; |
2337 bIterator = DeserializeSequenceOf (&numPlmnIdentityInfoElements,6,1,bIterator)
; | 2340 default: |
2338 for (int i = 0; i < numPlmnIdentityInfoElements; i++) | 2341 prioritizedBitRateKbps = 10000; |
2339 { | 2342 } |
2340 bIterator = DeserializeSequence (&bitset0,false,bIterator); | 2343 logicalChannelConfig->prioritizedBitRateKbps = prioritizedBitRateKbps; |
2341 | 2344 |
2342 // plmn-Identity | 2345 // Deserialize bucketSizeDuration |
2343 bIterator = DeserializePlmnIdentity (&systemInformationBlockType1->cellAcc
essRelatedInfo.plmnIdentityInfo.plmnIdentity,bIterator); | 2346 bIterator = DeserializeEnum (8,&n,bIterator); |
2344 } | 2347 uint16_t bucketSizeDurationMs; |
2345 | 2348 switch (n) |
2346 // Deserialize trackingAreaCode | 2349 { |
2347 std::bitset<16> trackingAreaCode; | 2350 case 0: |
2348 bIterator = DeserializeBitstring (&trackingAreaCode,bIterator); | 2351 bucketSizeDurationMs = 50; |
2349 | 2352 break; |
2350 // Deserialize cellIdentity | 2353 case 1: |
2351 std::bitset<28> cellIdentity; | 2354 bucketSizeDurationMs = 100; |
2352 bIterator = DeserializeBitstring (&cellIdentity,bIterator); | 2355 break; |
2353 systemInformationBlockType1->cellAccessRelatedInfo.cellIdentity = cellIdentity
.to_ulong (); | 2356 case 2: |
2354 | 2357 bucketSizeDurationMs = 150; |
2355 // Deserialize cellBarred | 2358 break; |
2356 bIterator = DeserializeEnum (2,&n,bIterator); | 2359 case 3: |
2357 | 2360 bucketSizeDurationMs = 300; |
2358 // Deserialize intraFreqReselection | 2361 break; |
2359 bIterator = DeserializeEnum (2,&n,bIterator); | 2362 case 4: |
2360 | 2363 bucketSizeDurationMs = 500; |
2361 // Deserialize csg-Indication | 2364 break; |
2362 bIterator = DeserializeBoolean (&systemInformationBlockType1->cellAccessRelate
dInfo.csgIndication,bIterator); | 2365 case 5: |
2363 | 2366 bucketSizeDurationMs = 1000; |
2364 if (cellAccessRelatedInfoOpts[0]) | 2367 break; |
2365 { | 2368 default: |
2366 // Deserialize csg-Identity | 2369 bucketSizeDurationMs = 1000; |
2367 std::bitset<27> csgIdentity; | 2370 } |
2368 bIterator = DeserializeBitstring (&csgIdentity,bIterator); | 2371 logicalChannelConfig->bucketSizeDurationMs = bucketSizeDurationMs; |
2369 systemInformationBlockType1->cellAccessRelatedInfo.csgIdentity = csgIdenti
ty.to_ulong (); | 2372 |
2370 } | 2373 if (bitset1[0]) |
2371 | 2374 { |
2372 // Deserialize cellSelectionInfo | 2375 // Deserialize logicalChannelGroup |
2373 std::bitset<1> qRxLevMinOffsetPresent; | 2376 bIterator = DeserializeInteger (&n,0,3,bIterator); |
2374 bIterator = DeserializeSequence (&qRxLevMinOffsetPresent,false,bIterator); | 2377 logicalChannelConfig->logicalChannelGroup = n; |
2375 bIterator = DeserializeInteger (&n,-70,-22,bIterator); //q-RxLevMin | 2378 } |
2376 if (qRxLevMinOffsetPresent[0]) | 2379 } |
2377 { | 2380 return bIterator; |
2378 // Deserialize qRxLevMinOffset | 2381 } |
2379 // ... | 2382 |
2380 } | 2383 Buffer::Iterator |
2381 | 2384 RrcAsn1Header::DeserializePhysicalConfigDedicated (LteRrcSap::PhysicalConfigDe
dicated *physicalConfigDedicated, Buffer::Iterator bIterator) |
2382 if (sysInfoBlkT1Opts[2]) | 2385 { |
2383 { | 2386 std::bitset<10> optionalFieldPresent; |
2384 // Deserialize p-Max | 2387 bIterator = DeserializeSequence (&optionalFieldPresent,true,bIterator); |
2385 // ... | 2388 |
2386 } | 2389 physicalConfigDedicated->havePdschConfigDedicated = optionalFieldPresent[9]; |
2387 | 2390 if (optionalFieldPresent[9]) |
2388 // freqBandIndicator | 2391 { |
2389 bIterator = DeserializeInteger (&n,1,64,bIterator); | 2392 // Deserialize pdsch-ConfigDedicated |
2390 | 2393 std::bitset<0> bitset0; |
2391 // schedulingInfoList | 2394 bIterator = DeserializeSequence (&bitset0,false,bIterator); |
2392 int numSchedulingInfo; | 2395 |
2393 bIterator = DeserializeSequenceOf (&numSchedulingInfo,MAX_SI_MESSAGE,1,bIterat
or); | 2396 int slct; |
2394 for (int i = 0; i < numSchedulingInfo; i++) | 2397 |
2395 { | 2398 // Deserialize p-a |
2396 bIterator = DeserializeSequence (&bitset0,false,bIterator); | 2399 bIterator = DeserializeEnum (8,&slct,bIterator); |
2397 bIterator = DeserializeEnum (7,&n,bIterator); // si-Periodicity | 2400 physicalConfigDedicated->pdschConfigDedicated.pa = slct; |
2398 int numSibType; | 2401 |
2399 bIterator = DeserializeSequenceOf (&numSibType,MAX_SIB - 1,0, bIterator);
// sib-MappingInfo | 2402 bIterator = DeserializeNull (bIterator); |
2400 for (int j = 0; j < numSibType; j++) | 2403 |
2401 { | 2404 } |
2402 bIterator = DeserializeEnum (16,&n,bIterator); // SIB-Type | 2405 if (optionalFieldPresent[8]) |
2403 } | 2406 { |
2404 } | 2407 // Deserialize pucch-ConfigDedicated |
2405 | 2408 // ... |
2406 if (sysInfoBlkT1Opts[1]) | 2409 } |
2407 { | 2410 if (optionalFieldPresent[7]) |
2408 // tdd-Config | 2411 { |
2409 // ... | 2412 // Deserialize pusch-ConfigDedicated |
2410 } | 2413 // ... |
2411 | 2414 } |
2412 // si-WindowLength | 2415 if (optionalFieldPresent[6]) |
2413 bIterator = DeserializeEnum (7,&n,bIterator); | 2416 { |
2414 | 2417 // Deserialize uplinkPowerControlDedicated |
2415 // systemInfoValueTag | 2418 // ... |
2416 bIterator = DeserializeInteger (&n,0,31,bIterator); | 2419 } |
2417 | 2420 if (optionalFieldPresent[5]) |
2418 if (sysInfoBlkT1Opts[0]) | 2421 { |
2419 { | 2422 // Deserialize tpc-PDCCH-ConfigPUCCH |
2420 // Deserialize nonCriticalExtension | 2423 // ... |
2421 // ... | 2424 } |
2422 } | 2425 if (optionalFieldPresent[4]) |
2423 return bIterator; | 2426 { |
2424 } | 2427 // Deserialize tpc-PDCCH-ConfigPUSCH |
2425 | 2428 // ... |
2426 Buffer::Iterator | 2429 } |
2427 RrcAsn1Header::DeserializeSystemInformationBlockType2 (LteRrcSap::SystemInformat
ionBlockType2 *systemInformationBlockType2, Buffer::Iterator bIterator) | 2430 if (optionalFieldPresent[3]) |
2428 { | 2431 { |
2429 std::bitset<0> bitset0; | 2432 // Deserialize cqi-ReportConfig |
2430 int n; | 2433 // ... |
2431 | 2434 } |
2432 std::bitset<2> sysInfoBlkT2Opts; | 2435 physicalConfigDedicated->haveSoundingRsUlConfigDedicated = optionalFieldPres
ent[2]; |
2433 bIterator = DeserializeSequence (&sysInfoBlkT2Opts,true,bIterator); | 2436 if (optionalFieldPresent[2]) |
2434 if (sysInfoBlkT2Opts[1]) | 2437 { |
2435 { | 2438 // Deserialize soundingRS-UL-ConfigDedicated |
2436 // Deserialize ac-BarringInfo | 2439 int sel; |
2437 // ... | 2440 bIterator = DeserializeChoice (2,false,&sel,bIterator); |
2438 } | 2441 |
2439 | 2442 if (sel == 0) |
2440 // Deserialize radioResourceConfigCommon | 2443 { |
2441 bIterator = DeserializeRadioResourceConfigCommonSib (&systemInformationBlockTy
pe2->radioResourceConfigCommon, bIterator); | 2444 physicalConfigDedicated->soundingRsUlConfigDedicated.type = LteRrcSa
p::SoundingRsUlConfigDedicated::RESET; |
2442 | 2445 |
2443 // Deserialize ue-TimersAndConstants | 2446 bIterator = DeserializeNull (bIterator); |
2444 bIterator = DeserializeSequence (&bitset0,true,bIterator); | 2447 } |
2445 bIterator = DeserializeEnum (8,&n,bIterator); // t300 | 2448 |
2446 bIterator = DeserializeEnum (8,&n,bIterator); // t301 | 2449 else if (sel == 1) |
2447 bIterator = DeserializeEnum (7,&n,bIterator); // t310 | 2450 { |
2448 bIterator = DeserializeEnum (8,&n,bIterator); // n310 | 2451 physicalConfigDedicated->soundingRsUlConfigDedicated.type = LteRrcSa
p::SoundingRsUlConfigDedicated::SETUP; |
2449 bIterator = DeserializeEnum (7,&n,bIterator); // t311 | 2452 |
2450 bIterator = DeserializeEnum (8,&n,bIterator); // n311 | 2453 std::bitset<0> bitset0; |
2451 | 2454 bIterator = DeserializeSequence (&bitset0,false,bIterator); |
2452 // Deserialize freqInfo | 2455 |
2453 std::bitset<2> freqInfoOpts; | 2456 int slct; |
2454 bIterator = DeserializeSequence (&freqInfoOpts,false,bIterator); | 2457 |
2455 if (freqInfoOpts[1]) | 2458 // Deserialize srs-Bandwidth |
2456 { | 2459 bIterator = DeserializeEnum (4,&slct,bIterator); |
2457 // Deserialize ul-CarrierFreq | 2460 physicalConfigDedicated->soundingRsUlConfigDedicated.srsBandwidth =
slct; |
2458 bIterator = DeserializeInteger (&n, 0, MAX_EARFCN, bIterator); | 2461 |
2459 systemInformationBlockType2->freqInfo.ulCarrierFreq = n; | 2462 // Deserialize srs-HoppingBandwidth |
2460 } | 2463 bIterator = DeserializeEnum (4,&slct,bIterator); |
2461 if (freqInfoOpts[0]) | 2464 |
2462 { | 2465 // Deserialize freqDomainPosition |
2463 // Deserialize ul-Bandwidth | 2466 bIterator = DeserializeInteger (&slct,0,23,bIterator); |
2464 bIterator = DeserializeEnum (6, &n, bIterator); | 2467 |
2465 switch (n) | 2468 // Deserialize duration |
2466 { | 2469 bool duration; |
2467 case 0: | 2470 bIterator = DeserializeBoolean (&duration,bIterator); |
2468 systemInformationBlockType2->freqInfo.ulBandwidth = 6; | 2471 |
2469 break; | 2472 // Deserialize srs-ConfigIndex |
2470 case 1: | 2473 bIterator = DeserializeInteger (&slct,0,1023,bIterator); |
2471 systemInformationBlockType2->freqInfo.ulBandwidth = 15; | 2474 physicalConfigDedicated->soundingRsUlConfigDedicated.srsConfigIndex
= slct; |
2472 break; | 2475 |
2473 case 2: | 2476 // Deserialize transmissionComb |
2474 systemInformationBlockType2->freqInfo.ulBandwidth = 25; | 2477 bIterator = DeserializeInteger (&slct,0,1,bIterator); |
2475 break; | 2478 |
2476 case 3: | 2479 // Deserialize cyclicShift |
2477 systemInformationBlockType2->freqInfo.ulBandwidth = 50; | 2480 bIterator = DeserializeEnum (8,&slct,bIterator); |
2478 break; | 2481 } |
2479 case 4: | 2482 } |
2480 systemInformationBlockType2->freqInfo.ulBandwidth = 75; | 2483 physicalConfigDedicated->haveAntennaInfoDedicated = optionalFieldPresent[1]; |
2481 break; | 2484 if (optionalFieldPresent[1]) |
2482 case 5: | 2485 { |
2483 systemInformationBlockType2->freqInfo.ulBandwidth = 100; | 2486 // Deserialize antennaInfo |
2484 break; | 2487 int sel; |
2485 default: | 2488 bIterator = DeserializeChoice (2,false,&sel,bIterator); |
2486 systemInformationBlockType2->freqInfo.ulBandwidth = 6; | 2489 if (sel == 1) |
2487 } | 2490 { |
2488 } | 2491 bIterator = DeserializeNull (bIterator); |
2489 | 2492 } |
2490 // additionalSpectrumEmission | 2493 else if (sel == 0) |
2491 bIterator = DeserializeInteger (&n,1,32,bIterator); | 2494 { |
2492 | 2495 std::bitset<1> codebookSubsetRestrictionPresent; |
2493 if (sysInfoBlkT2Opts[0]) | 2496 bIterator = DeserializeSequence (&codebookSubsetRestrictionPresent,f
alse,bIterator); |
2494 { | 2497 |
2495 // Deserialize mbsfn-SubframeConfigList | 2498 int txmode; |
2496 // ... | 2499 bIterator = DeserializeEnum (8,&txmode,bIterator); |
2497 } | 2500 physicalConfigDedicated->antennaInfo.transmissionMode = txmode; |
2498 | 2501 |
2499 // Deserialize timeAlignmentTimerCommon | 2502 if (codebookSubsetRestrictionPresent[0]) |
2500 bIterator = DeserializeEnum (8,&n,bIterator); | 2503 { |
2501 | 2504 // Deserialize codebookSubsetRestriction |
2502 return bIterator; | 2505 // ... |
2503 } | 2506 } |
2504 | 2507 |
2505 | 2508 int txantennaselchosen; |
2506 Buffer::Iterator | 2509 bIterator = DeserializeChoice (2,false,&txantennaselchosen,bIterator
); |
2507 RrcAsn1Header::DeserializeRadioResourceConfigCommon (LteRrcSap::RadioResourceCon
figCommon * radioResourceConfigCommon, Buffer::Iterator bIterator) | 2510 if (txantennaselchosen == 0) |
2508 { | 2511 { |
2509 std::bitset<0> bitset0; | 2512 // Deserialize ue-TransmitAntennaSelection release |
2510 int n; | 2513 bIterator = DeserializeNull (bIterator); |
2511 | 2514 } |
2512 std::bitset<9> rrCfgCommOptions; | 2515 else if (txantennaselchosen == 1) |
2513 bIterator = DeserializeSequence (&rrCfgCommOptions,true,bIterator); | 2516 { |
2514 | 2517 // Deserialize ue-TransmitAntennaSelection setup |
2515 // rach-ConfigCommon | 2518 // ... |
2516 if (rrCfgCommOptions[8]) | 2519 } |
2517 { | 2520 } |
2518 bIterator = DeserializeRachConfigCommon (&radioResourceConfigCommon->rachC
onfigCommon, bIterator); | 2521 } |
2519 } | 2522 if (optionalFieldPresent[0]) |
2520 | 2523 { |
2521 // prach-Config | 2524 // Deserialize schedulingRequestConfig |
2522 std::bitset<1> prachConfigInfoPresent; | 2525 // ... |
2523 bIterator = DeserializeSequence (&prachConfigInfoPresent,false,bIterator); | 2526 } |
2524 | 2527 return bIterator; |
2525 // prach-Config -> rootSequenceIndex | 2528 } |
2526 bIterator = DeserializeInteger (&n,0,1023,bIterator); | 2529 |
2527 | 2530 void |
2528 // prach-Config -> prach-ConfigInfo | 2531 RrcAsn1Header::Print (std::ostream &os) const |
2529 if (prachConfigInfoPresent[0]) | 2532 { |
2530 { | 2533 NS_LOG_FUNCTION (this << &os); |
2531 // ... | 2534 NS_FATAL_ERROR ("RrcAsn1Header Print() function must also specify LteRrcSap:
:RadioResourceConfigDedicated as a second argument"); |
2532 } | 2535 } |
2533 | 2536 |
2534 // pdsch-ConfigCommon | 2537 Buffer::Iterator |
2535 if (rrCfgCommOptions[7]) | 2538 RrcAsn1Header::DeserializeNonCriticalExtensionConfig (LteRrcSap::NonCriticalEx
tensionConfiguration *nonCriticalExtension, Buffer::Iterator bIterator) |
2536 { | 2539 { |
2537 // ... | 2540 NS_LOG_FUNCTION (this); |
2538 } | 2541 std::bitset<2> nonCriticalExtension_v890; |
2539 | 2542 bIterator = DeserializeSequence (&nonCriticalExtension_v890, false,bIterator
); |
2540 // pusch-ConfigCommon | 2543 ···· |
2541 bIterator = DeserializeSequence (&bitset0,false,bIterator); | 2544 if (nonCriticalExtension_v890[0]) |
2542 | 2545 { |
2543 // pusch-ConfigCommon -> pusch-ConfigBasic | 2546 // Continue to analyze future Release optional fields |
2544 bIterator = DeserializeSequence (&bitset0,false,bIterator); | 2547 std::bitset<3> nonCriticalExtension_v920; |
2545 | 2548 bIterator = DeserializeSequence (&nonCriticalExtension_v920, false, bIte
rator); |
2546 // pusch-ConfigCommon -> pusch-ConfigBasic -> n-SB | 2549 if (nonCriticalExtension_v920[0]) |
2547 bIterator = DeserializeInteger (&n,1,4,bIterator); | 2550 { |
2548 | 2551 // Continue to deserialize futere Release optional fields |
2549 // pusch-ConfigCommon -> pusch-ConfigBasic -> hoppingMode | 2552 std::bitset<3> nonCriticalExtension_v1020; |
2550 bIterator = DeserializeEnum (2,&n,bIterator); | 2553 bIterator = DeserializeSequence (&nonCriticalExtension_v1020, false,
bIterator); |
2551 | 2554 int numElems; |
2552 // pusch-ConfigCommon -> pusch-ConfigBasic -> pusch-HoppingOffset | 2555 bIterator = DeserializeSequenceOf (&numElems,MAX_SCELL_CONF,1,bItera
tor); |
2553 bIterator = DeserializeInteger (&n,0,98,bIterator); | 2556 nonCriticalExtension->sCellsToAddModList.clear (); |
2554 | 2557 // Deserialize SCellToAddMod |
2555 // pusch-ConfigCommon -> pusch-ConfigBasic -> enable64QAM | 2558 for (int i = 0; i < numElems; i++) |
2556 bool enable64QAM; | 2559 { |
2557 bIterator = DeserializeBoolean (&enable64QAM,bIterator); | 2560 std::bitset<4> sCellToAddMod_r10; |
2558 | 2561 bIterator = DeserializeSequence (&sCellToAddMod_r10, false, bIte
rator);· |
2559 // ul-ReferenceSignalsPUSCH | 2562 ················ |
2560 bIterator = DeserializeSequence (&bitset0,false,bIterator); | 2563 LteRrcSap::SCellToAddMod sctam; |
2561 | 2564 // Deserialize sCellIndex |
2562 // groupHoppingEnabled | 2565 int n; |
2563 bool dummyBool; | 2566 bIterator = DeserializeInteger (&n,1,2,bIterator); |
2564 bIterator = DeserializeBoolean (&dummyBool,bIterator); | 2567 sctam.sCellIndex = n; |
2565 | 2568 // Deserialize CellIdentification |
2566 // groupAssignmentPUSCH | 2569 bIterator = DeserializeCellIdentification (&sctam.cellIdentifica
tion, bIterator); |
2567 bIterator = DeserializeInteger (&n,0,29,bIterator); | 2570 |
2568 | 2571 // Deserialize RadioResourceConfigCommonSCell |
2569 // sequenceHoppingEnabled | 2572 bIterator = DeserializeRadioResourceConfigCommonSCell (&sctam.ra
dioResourceConfigCommonSCell, bIterator); |
2570 bIterator = DeserializeBoolean (&dummyBool,bIterator); | 2573 if (sCellToAddMod_r10[0]) |
2571 | 2574 { |
2572 // cyclicShift | 2575 //Deserialize RadioResourceConfigDedicatedSCell |
2573 bIterator = DeserializeInteger (&n,0,7,bIterator); | 2576 bIterator = DeserializeRadioResourceConfigDedicatedSCell (&s
ctam.radioResourceConfigDedicateSCell, bIterator); |
2574 | 2577 } |
2575 // phich-Config | 2578 |
2576 if (rrCfgCommOptions[6]) | 2579 nonCriticalExtension->sCellsToAddModList.insert (nonCriticalExte
nsion->sCellsToAddModList.end (), sctam); |
2577 { | 2580 } |
2578 // ... | 2581 } |
2579 } | 2582 } |
2580 | 2583 |
2581 // pucch-ConfigCommon | 2584 return bIterator; |
2582 if (rrCfgCommOptions[5]) | 2585 } |
2583 { | 2586 |
2584 // ... | 2587 Buffer::Iterator· |
2585 } | 2588 RrcAsn1Header::DeserializeCellIdentification (LteRrcSap::CellIdentification *c
i, Buffer::Iterator bIterator) |
2586 | 2589 { |
2587 // soundingRS-UL-ConfigCommon | 2590 NS_LOG_FUNCTION (this); |
2588 if (rrCfgCommOptions[4]) | 2591 std::bitset<2> cellIdentification_r10; |
2589 { | 2592 bIterator = DeserializeSequence (&cellIdentification_r10,false,bIterator); |
2590 // ... | 2593 int n1; |
2591 } | 2594 bIterator = DeserializeInteger (&n1,1,2,bIterator); |
2592 | 2595 ci->physCellId = n1; |
2593 // uplinkPowerControlCommon | 2596 int n2; |
2594 if (rrCfgCommOptions[3]) | 2597 bIterator = DeserializeInteger (&n2,1,2,bIterator); |
2595 { | 2598 ci->dlCarrierFreq = n2; |
2596 // ... | 2599 |
2597 } | 2600 return bIterator; |
2598 | 2601 } |
2599 // antennaInfoCommon | 2602 |
2600 if (rrCfgCommOptions[2]) | 2603 Buffer::Iterator· |
2601 { | 2604 RrcAsn1Header::DeserializeRadioResourceConfigCommonSCell (LteRrcSap::RadioReso
urceConfigCommonSCell *rrccsc, Buffer::Iterator bIterator) |
2602 // ... | 2605 { |
2603 } | 2606 NS_LOG_FUNCTION (this); |
2604 | 2607 std::bitset<2> radioResourceConfigCommonSCell_r10; |
2605 // p-Max | 2608 bIterator = DeserializeSequence (&radioResourceConfigCommonSCell_r10,false,b
Iterator); |
2606 if (rrCfgCommOptions[1]) | 2609 rrccsc->haveNonUlConfiguration = radioResourceConfigCommonSCell_r10[1]; |
2607 { | 2610 rrccsc->haveUlConfiguration = radioResourceConfigCommonSCell_r10[0]; |
2608 // ... | 2611 ···· |
2609 } | 2612 if (rrccsc->haveNonUlConfiguration) |
2610 | 2613 { |
2611 // tdd-Config | 2614 std::bitset<5> nonUlConfiguration_r10; |
2612 if (rrCfgCommOptions[0]) | 2615 bIterator = DeserializeSequence (&nonUlConfiguration_r10,false,bIterator
); |
2613 { | 2616 int n; |
2614 // ... | 2617 bIterator = DeserializeInteger (&n,6,100,bIterator); |
2615 } | 2618 rrccsc->nonUlConfiguration.dlBandwidth = n; |
2616 | 2619 |
2617 // ul-CyclicPrefixLength | 2620 std::bitset<1> antennaInfoCommon_r10; |
2618 bIterator = DeserializeEnum (2,&n,bIterator); | 2621 bIterator = DeserializeSequence (&antennaInfoCommon_r10,false,bIterator)
; |
2619 | 2622 bIterator = DeserializeInteger (&n,0,65536,bIterator); |
2620 return bIterator; | 2623 rrccsc->nonUlConfiguration.antennaInfoCommon.antennaPortsCount = n; |
2621 } | 2624 |
2622 | 2625 std::bitset<2> pdschConfigCommon_r10; |
2623 Buffer::Iterator | 2626 bIterator = DeserializeSequence (&pdschConfigCommon_r10,false,bIterator)
; |
2624 RrcAsn1Header::DeserializeRachConfigCommon (LteRrcSap::RachConfigCommon * rachCo
nfigCommon, Buffer::Iterator bIterator) | 2627 bIterator = DeserializeInteger (&n,-60,50,bIterator); |
2625 { | 2628 rrccsc->nonUlConfiguration.pdschConfigCommon.referenceSignalPower = n; |
2626 std::bitset<0> bitset0; | 2629 bIterator = DeserializeInteger (&n,0,3,bIterator); |
2627 int n; | 2630 rrccsc->nonUlConfiguration.pdschConfigCommon.pb = n; |
2628 | 2631 } |
2629 bIterator = DeserializeSequence (&bitset0,true,bIterator); | 2632 if (rrccsc->haveUlConfiguration) |
2630 | 2633 { |
2631 // preambleInfo | 2634 std::bitset<7> UlConfiguration_r10; |
2632 std::bitset<1> preamblesGroupAConfigPresent; | 2635 bIterator = DeserializeSequence (&UlConfiguration_r10,true,bIterator); |
2633 bIterator = DeserializeSequence (&preamblesGroupAConfigPresent,false,bIterator
); | 2636 ········ |
2634 | 2637 std::bitset<3> FreqInfo_r10; |
2635 // numberOfRA-Preambles | 2638 bIterator = DeserializeSequence (&FreqInfo_r10,false,bIterator); |
2636 bIterator = DeserializeEnum (16,&n,bIterator); | 2639 int n; |
2637 switch (n) | 2640 bIterator = DeserializeInteger (&n,0,65536,bIterator); |
2638 { | 2641 rrccsc->ulConfiguration.ulFreqInfo.ulCarrierFreq = n; |
2639 case 0: | 2642 bIterator = DeserializeInteger (&n,6,100,bIterator); |
2640 rachConfigCommon->preambleInfo.numberOfRaPreambles = 4; | 2643 rrccsc->ulConfiguration.ulFreqInfo.ulBandwidth = n; |
2641 break; | 2644 |
2642 case 1: | 2645 std::bitset<2> UlPowerControlCommonSCell_r10; |
2643 rachConfigCommon->preambleInfo.numberOfRaPreambles = 8; | 2646 bIterator = DeserializeSequence (&UlPowerControlCommonSCell_r10,false,bI
terator); |
2644 break; | 2647 bIterator = DeserializeInteger (&n,0,65536,bIterator); |
2645 case 2: | 2648 rrccsc->ulConfiguration.ulPowerControlCommonSCell.alpha = n; |
2646 rachConfigCommon->preambleInfo.numberOfRaPreambles = 12; | 2649 ········· |
2647 break; | 2650 std::bitset<1> prachConfigSCell_r10; |
2648 case 3: | 2651 bIterator = DeserializeSequence (&prachConfigSCell_r10,false,bIterator); |
2649 rachConfigCommon->preambleInfo.numberOfRaPreambles = 16; | 2652 bIterator = DeserializeInteger (&n,0,65536,bIterator); |
2650 break; | 2653 rrccsc->ulConfiguration.prachConfigSCell.index = n; |
2651 case 4: | 2654 }···· |
2652 rachConfigCommon->preambleInfo.numberOfRaPreambles = 20; | 2655 ···· |
2653 break; | 2656 return bIterator; |
2654 case 5: | 2657 } |
2655 rachConfigCommon->preambleInfo.numberOfRaPreambles = 24; | 2658 |
2656 break; | 2659 Buffer::Iterator· |
2657 case 6: | 2660 RrcAsn1Header::DeserializeRadioResourceConfigDedicatedSCell (LteRrcSap::RadioR
esourceConfigDedicatedSCell *rrcdsc, Buffer::Iterator bIterator) |
2658 rachConfigCommon->preambleInfo.numberOfRaPreambles = 28; | 2661 { |
2659 break; | 2662 NS_LOG_FUNCTION (this); |
2660 case 7: | 2663 std::bitset<1> RadioResourceConfigDedicatedSCell_r10; |
2661 rachConfigCommon->preambleInfo.numberOfRaPreambles = 32; | 2664 bIterator = DeserializeSequence (&RadioResourceConfigDedicatedSCell_r10,fals
e,bIterator); |
2662 break; | 2665 DeserializePhysicalConfigDedicatedSCell (&rrcdsc->physicalConfigDedicatedSCe
ll, bIterator); |
2663 case 8: | 2666 |
2664 rachConfigCommon->preambleInfo.numberOfRaPreambles = 36; | 2667 return bIterator; |
2665 break; | 2668 } |
2666 case 9: | 2669 |
2667 rachConfigCommon->preambleInfo.numberOfRaPreambles = 40; | 2670 Buffer::Iterator· |
2668 break; | 2671 RrcAsn1Header::DeserializePhysicalConfigDedicatedSCell (LteRrcSap::PhysicalCon
figDedicatedSCell *pcdsc, Buffer::Iterator bIterator) |
2669 case 10: | 2672 { |
2670 rachConfigCommon->preambleInfo.numberOfRaPreambles = 44; | 2673 NS_LOG_FUNCTION (this); |
2671 break; | 2674 std::bitset<2> pcdscOpt; |
2672 case 11: | 2675 bIterator = DeserializeSequence (&pcdscOpt,true,bIterator); |
2673 rachConfigCommon->preambleInfo.numberOfRaPreambles = 48; | 2676 pcdsc->haveNonUlConfiguration = pcdscOpt[1]; |
2674 break; | 2677 pcdsc->haveUlConfiguration = pcdscOpt[0];···· |
2675 case 12: | 2678 if (pcdsc->haveNonUlConfiguration) |
2676 rachConfigCommon->preambleInfo.numberOfRaPreambles = 52; | 2679 { |
2677 break; | 2680 std::bitset<4> nulOpt; |
2678 case 13: | 2681 bIterator = DeserializeSequence (&nulOpt,false,bIterator); |
2679 rachConfigCommon->preambleInfo.numberOfRaPreambles = 56; | 2682 pcdsc->haveAntennaInfoDedicated = nulOpt[3];·· |
2680 break; | 2683 pcdsc->havePdschConfigDedicated = nulOpt[0];·· |
2681 case 14: | 2684 |
2682 rachConfigCommon->preambleInfo.numberOfRaPreambles = 60; | 2685 if (pcdsc->haveAntennaInfoDedicated) |
2683 break; | 2686 { |
2684 case 15: | 2687 // Deserialize antennaInfo |
2685 rachConfigCommon->preambleInfo.numberOfRaPreambles = 64; | 2688 int sel; |
2686 break; | 2689 bIterator = DeserializeChoice (2,false,&sel,bIterator); |
2687 default: | 2690 if (sel == 1) |
2688 rachConfigCommon->preambleInfo.numberOfRaPreambles = 0; | 2691 { |
2689 } | 2692 bIterator = DeserializeNull (bIterator); |
2690 | 2693 } |
2691 rachConfigCommon->preambleInfo.numberOfRaPreambles = n; | 2694 else if (sel == 0) |
2692 | 2695 { |
2693 if (preamblesGroupAConfigPresent[0]) | 2696 std::bitset<1> codebookSubsetRestrictionPresent; |
2694 { | 2697 bIterator = DeserializeSequence (&codebookSubsetRestrictionPres
ent,false,bIterator); |
2695 // Deserialize preamblesGroupAConfig | 2698 |
2696 // ... | 2699 int txmode; |
2697 } | 2700 bIterator = DeserializeEnum (8,&txmode,bIterator); |
2698 | 2701 pcdsc->antennaInfo.transmissionMode = txmode; |
2699 // powerRampingParameters | 2702 |
2700 bIterator = DeserializeSequence (&bitset0,false,bIterator); | 2703 if (codebookSubsetRestrictionPresent[0]) |
2701 bIterator = DeserializeEnum (4,&n,bIterator); // powerRampingStep | 2704 { |
2702 bIterator = DeserializeEnum (16,&n,bIterator); // preambleInitialReceivedTarge
tPower | 2705 // Deserialize codebookSubsetRestriction |
2703 | 2706 // ... |
2704 // ra-SupervisionInfo | 2707 } |
2705 bIterator = DeserializeSequence (&bitset0,false,bIterator); | 2708 |
2706 bIterator = DeserializeEnum (11,&n,bIterator); // preambleTransMax | 2709 int txantennaselchosen; |
2707 switch (n) | 2710 bIterator = DeserializeChoice (2,false,&txantennaselchosen,bIte
rator); |
2708 { | 2711 if (txantennaselchosen == 0) |
2709 case 0: | 2712 { |
2710 rachConfigCommon->raSupervisionInfo.preambleTransMax = 3; | 2713 // Deserialize ue-TransmitAntennaSelection release |
2711 break; | 2714 bIterator = DeserializeNull (bIterator); |
2712 case 1: | 2715 } |
2713 rachConfigCommon->raSupervisionInfo.preambleTransMax = 4; | 2716 else if (txantennaselchosen == 1) |
2714 break; | 2717 { |
2715 case 2: | 2718 // Deserialize ue-TransmitAntennaSelection setup |
2716 rachConfigCommon->raSupervisionInfo.preambleTransMax = 5; | 2719 // ... |
2717 break; | 2720 } |
2718 case 3: | 2721 } |
2719 rachConfigCommon->raSupervisionInfo.preambleTransMax = 6; | 2722 } |
2720 break; | 2723 if (pcdsc->havePdschConfigDedicated) |
2721 case 4: | 2724 { |
2722 rachConfigCommon->raSupervisionInfo.preambleTransMax = 7; | 2725 // Deserialize pdsch-ConfigDedicated |
2723 break; | 2726 std::bitset<0> bitset0; |
2724 case 5: | 2727 bIterator = DeserializeSequence (&bitset0,false,bIterator); |
2725 rachConfigCommon->raSupervisionInfo.preambleTransMax = 8; | 2728 |
2726 break; | 2729 int slct; |
2727 case 6: | 2730 |
2728 rachConfigCommon->raSupervisionInfo.preambleTransMax = 10; | 2731 // Deserialize p-a |
2729 break; | 2732 bIterator = DeserializeEnum (8,&slct,bIterator); |
2730 case 7: | 2733 pcdsc->pdschConfigDedicated.pa = slct; |
2731 rachConfigCommon->raSupervisionInfo.preambleTransMax = 20; | 2734 |
2732 break; | 2735 bIterator = DeserializeNull (bIterator); |
2733 case 8: | 2736 } |
2734 rachConfigCommon->raSupervisionInfo.preambleTransMax = 50; | 2737 ········ |
2735 break; | 2738 } |
2736 case 9: | 2739 if (pcdsc->haveUlConfiguration) |
2737 rachConfigCommon->raSupervisionInfo.preambleTransMax = 100; | 2740 { |
2738 break; | 2741 std::bitset<7> ulOpt; |
2739 case 10: | 2742 bIterator = DeserializeSequence (&ulOpt,false,bIterator); |
2740 rachConfigCommon->raSupervisionInfo.preambleTransMax = 200; | 2743 pcdsc->haveAntennaInfoUlDedicated = ulOpt[6]; |
2741 break; | 2744 pcdsc->haveSoundingRsUlConfigDedicated = ulOpt[2]; |
2742 default: | 2745 ········· |
2743 rachConfigCommon->raSupervisionInfo.preambleTransMax = 0; | 2746 if (pcdsc->haveAntennaInfoUlDedicated) |
2744 } | 2747 { |
2745 | 2748 // Deserialize antennaInfo |
2746 // ra-ResponseWindowSize | 2749 int sel; |
2747 bIterator = DeserializeEnum (8,&n,bIterator); | 2750 bIterator = DeserializeChoice (2,false,&sel,bIterator); |
2748 switch (n) | 2751 if (sel == 1) |
2749 { | 2752 { |
2750 case 0: | 2753 bIterator = DeserializeNull (bIterator); |
2751 rachConfigCommon->raSupervisionInfo.raResponseWindowSize = 2; | 2754 } |
2752 break; | 2755 else if (sel == 0) |
2753 case 1: | 2756 { |
2754 rachConfigCommon->raSupervisionInfo.raResponseWindowSize = 3; | 2757 std::bitset<1> codebookSubsetRestrictionPresent; |
2755 break; | 2758 bIterator = DeserializeSequence (&codebookSubsetRestrictionPres
ent,false,bIterator); |
2756 case 2: | 2759 |
2757 rachConfigCommon->raSupervisionInfo.raResponseWindowSize = 4; | 2760 int txmode; |
2758 break; | 2761 bIterator = DeserializeEnum (8,&txmode,bIterator); |
2759 case 3: | 2762 pcdsc->antennaInfo.transmissionMode = txmode; |
2760 rachConfigCommon->raSupervisionInfo.raResponseWindowSize = 5; | 2763 |
2761 break; | 2764 if (codebookSubsetRestrictionPresent[0]) |
2762 case 4: | 2765 { |
2763 rachConfigCommon->raSupervisionInfo.raResponseWindowSize = 6; | 2766 // Deserialize codebookSubsetRestriction |
2764 break; | 2767 // ... |
2765 case 5: | 2768 } |
2766 rachConfigCommon->raSupervisionInfo.raResponseWindowSize = 7; | 2769 |
2767 break; | 2770 int txantennaselchosen; |
2768 case 6: | 2771 bIterator = DeserializeChoice (2,false,&txantennaselchosen,bIte
rator); |
2769 rachConfigCommon->raSupervisionInfo.raResponseWindowSize = 8; | 2772 if (txantennaselchosen == 0) |
2770 break; | 2773 { |
2771 case 7: | 2774 // Deserialize ue-TransmitAntennaSelection release |
2772 rachConfigCommon->raSupervisionInfo.raResponseWindowSize = 10; | 2775 bIterator = DeserializeNull (bIterator); |
2773 break; | 2776 } |
2774 default: | 2777 else if (txantennaselchosen == 1) |
2775 rachConfigCommon->raSupervisionInfo.raResponseWindowSize = 0; | 2778 { |
2776 } | 2779 // Deserialize ue-TransmitAntennaSelection setup |
2777 | 2780 // ... |
2778 bIterator = DeserializeEnum (8,&n,bIterator); // mac-ContentionResolutionTimer | 2781 } |
2779 bIterator = DeserializeInteger (&n,1,8,bIterator); //maxHARQ-Msg3Tx | 2782 } |
2780 return bIterator; | 2783 } |
2781 } | 2784 if (pcdsc->haveSoundingRsUlConfigDedicated) |
2782 | 2785 { |
2783 Buffer::Iterator | 2786 // Deserialize soundingRS-UL-ConfigDedicated |
2784 RrcAsn1Header::DeserializeRadioResourceConfigCommonSib (LteRrcSap::RadioResource
ConfigCommonSib * radioResourceConfigCommonSib, Buffer::Iterator bIterator) | 2787 int sel; |
2785 { | 2788 bIterator = DeserializeChoice (2,false,&sel,bIterator); |
2786 std::bitset<0> bitset0; | 2789 |
2787 int n; | 2790 if (sel == 0) |
2788 | 2791 { |
2789 bIterator = DeserializeSequence (&bitset0,true,bIterator); | 2792 pcdsc->soundingRsUlConfigDedicated.type = LteRrcSap::SoundingRs
UlConfigDedicated::RESET; |
2790 | 2793 |
2791 // rach-ConfigCommon | 2794 bIterator = DeserializeNull (bIterator); |
2792 bIterator = DeserializeRachConfigCommon (&radioResourceConfigCommonSib->rachCo
nfigCommon, bIterator); | 2795 } |
2793 | 2796 |
2794 // bcch-Config· | 2797 else if (sel == 1) |
2795 bIterator = DeserializeSequence (&bitset0,false,bIterator); | 2798 { |
2796 bIterator = DeserializeEnum (4,&n,bIterator); // modificationPeriodCoeff | 2799 pcdsc->soundingRsUlConfigDedicated.type = LteRrcSap::SoundingRs
UlConfigDedicated::SETUP; |
2797 | 2800 |
2798 // pcch-Config· | 2801 std::bitset<0> bitset0; |
2799 bIterator = DeserializeSequence (&bitset0,false,bIterator); | 2802 bIterator = DeserializeSequence (&bitset0,false,bIterator); |
2800 bIterator = DeserializeEnum (4,&n,bIterator); // defaultPagingCycle | 2803 |
2801 bIterator = DeserializeEnum (8,&n,bIterator); // nB | 2804 int slct; |
2802 | 2805 |
2803 // prach-Config· | 2806 // Deserialize srs-Bandwidth |
2804 std::bitset<1> prachConfigInfoPresent; | 2807 bIterator = DeserializeEnum (4,&slct,bIterator); |
2805 bIterator = DeserializeSequence (&prachConfigInfoPresent,false,bIterator); | 2808 pcdsc->soundingRsUlConfigDedicated.srsBandwidth = slct; |
2806 // prach-Config -> rootSequenceIndex | 2809 |
2807 bIterator = DeserializeInteger (&n,0,1023,bIterator); | 2810 // Deserialize srs-HoppingBandwidth |
2808 // prach-Config -> prach-ConfigInfo | 2811 bIterator = DeserializeEnum (4,&slct,bIterator); |
2809 if (prachConfigInfoPresent[0]) | 2812 |
2810 { | 2813 // Deserialize freqDomainPosition |
2811 // ... | 2814 bIterator = DeserializeInteger (&slct,0,23,bIterator); |
2812 } | 2815 |
2813 | 2816 // Deserialize duration |
2814 // pdsch-ConfigCommon· | 2817 bool duration; |
2815 bIterator = DeserializeSequence (&bitset0,false,bIterator); | 2818 bIterator = DeserializeBoolean (&duration,bIterator); |
2816 bIterator = DeserializeInteger (&n,-60,50,bIterator); // referenceSignalPower | 2819 |
2817 bIterator = DeserializeInteger (&n,0,3,bIterator); // p-b | 2820 // Deserialize srs-ConfigIndex |
2818 | 2821 bIterator = DeserializeInteger (&slct,0,1023,bIterator); |
2819 // pusch-ConfigCommon | 2822 pcdsc->soundingRsUlConfigDedicated.srsConfigIndex = slct; |
2820 bIterator = DeserializeSequence (&bitset0,false,bIterator); | 2823 |
2821 | 2824 // Deserialize transmissionComb |
2822 // pusch-ConfigCommon -> pusch-ConfigBasic | 2825 bIterator = DeserializeInteger (&slct,0,1,bIterator); |
2823 bIterator = DeserializeSequence (&bitset0,false,bIterator); | 2826 |
2824 | 2827 // Deserialize cyclicShift |
2825 // pusch-ConfigCommon -> pusch-ConfigBasic -> n-SB | 2828 bIterator = DeserializeEnum (8,&slct,bIterator); |
2826 bIterator = DeserializeInteger (&n,1,4,bIterator); | 2829 } |
2827 | 2830 } |
2828 // pusch-ConfigCommon -> pusch-ConfigBasic -> hoppingMode | 2831 |
2829 bIterator = DeserializeEnum (2,&n,bIterator); | 2832 |
2830 | 2833 } |
2831 // pusch-ConfigCommon -> pusch-ConfigBasic -> pusch-HoppingOffset | 2834 |
2832 bIterator = DeserializeInteger (&n,0,98,bIterator); | 2835 return bIterator; |
2833 | 2836 } |
2834 // pusch-ConfigCommon -> pusch-ConfigBasic -> enable64QAM | 2837 |
2835 bool dummyBoolean; | 2838 void |
2836 bIterator = DeserializeBoolean (&dummyBoolean,bIterator); | 2839 RrcAsn1Header::Print (std::ostream &os, LteRrcSap::RadioResourceConfigDedicate
d radioResourceConfigDedicated) const |
2837 | 2840 { |
2838 // ul-ReferenceSignalsPUSCH· | 2841 os << " srbToAddModList: " << std::endl; |
2839 bIterator = DeserializeSequence (&bitset0,false,bIterator); | 2842 std::list<LteRrcSap::SrbToAddMod>::iterator it = radioResourceConfigDedicate
d.srbToAddModList.begin (); |
2840 | 2843 for (; it != radioResourceConfigDedicated.srbToAddModList.end (); it++) |
2841 // groupHoppingEnabled· | 2844 { |
2842 bIterator = DeserializeBoolean (&dummyBoolean,bIterator); | 2845 os << " srbIdentity: " << (int)it->srbIdentity << std::endl; |
2843 | 2846 os << " logicalChannelConfig: " << std::endl; |
2844 // groupAssignmentPUSCH· | 2847 os << " priority: " << (int)it->logicalChannelConfig.priority <
< std::endl; |
2845 bIterator = DeserializeInteger (&n,0,29,bIterator); | 2848 os << " prioritizedBitRateKbps: " << (int)it->logicalChannelCon
fig.prioritizedBitRateKbps << std::endl; |
2846 | 2849 os << " bucketSizeDurationMs: " << (int)it->logicalChannelConfi
g.bucketSizeDurationMs << std::endl; |
2847 // sequenceHoppingEnabled· | 2850 os << " logicalChannelGroup: " << (int)it->logicalChannelConfig
.logicalChannelGroup << std::endl; |
2848 bIterator = DeserializeBoolean (&dummyBoolean,bIterator); | 2851 } |
2849 | 2852 os << std::endl; |
2850 // cyclicShift· | 2853 |
2851 bIterator = DeserializeInteger (&n,0,7,bIterator); | 2854 os << " drbToAddModList: " << std::endl; |
2852 | 2855 std::list<LteRrcSap::DrbToAddMod>::iterator it2 = radioResourceConfigDedicat
ed.drbToAddModList.begin (); |
2853 // pucch-ConfigCommon· | 2856 for (; it2 != radioResourceConfigDedicated.drbToAddModList.end (); it2++) |
2854 bIterator = DeserializeEnum (3,&n,bIterator); // deltaPUCCH-Shift· | 2857 { |
2855 bIterator = DeserializeInteger (&n,0,98,bIterator); // nRB-CQI· | 2858 os << " epsBearerIdentity: " << (int)it2->epsBearerIdentity << std:
:endl; |
2856 bIterator = DeserializeInteger (&n,0,7,bIterator); // nCS-AN· | 2859 os << " drbIdentity: " << (int)it2->drbIdentity << std::endl; |
2857 bIterator = DeserializeInteger (&n,0,2047,bIterator); // n1PUCCH-AN· | 2860 os << " rlcConfig: " << it2->rlcConfig.choice << std::endl; |
2858 | 2861 os << " logicalChannelIdentity: " << (int)it2->logicalChannelIdenti
ty << std::endl; |
2859 // soundingRS-UL-ConfigCommon | 2862 os << " logicalChannelConfig: " << std::endl; |
2860 int choice; | 2863 os << " priority: " << (int)it2->logicalChannelConfig.priority
<< std::endl; |
2861 bIterator = DeserializeChoice (2,false,&choice,bIterator); | 2864 os << " prioritizedBitRateKbps: " << (int)it2->logicalChannelCo
nfig.prioritizedBitRateKbps << std::endl; |
2862 if (choice == 0) | 2865 os << " bucketSizeDurationMs: " << (int)it2->logicalChannelConf
ig.bucketSizeDurationMs << std::endl; |
2863 { | 2866 os << " logicalChannelGroup: " << (int)it2->logicalChannelConfi
g.logicalChannelGroup << std::endl; |
2864 bIterator = DeserializeNull (bIterator); // release | 2867 } |
2865 } | 2868 os << std::endl; |
2866 if (choice == 1) | 2869 |
2867 { | 2870 os << " drbToReleaseList: "; |
2868 // setup | 2871 std::list<uint8_t>::iterator it3 = radioResourceConfigDedicated.drbToRelease
List.begin (); |
2869 // ... | 2872 for (; it3 != radioResourceConfigDedicated.drbToReleaseList.end (); it3++) |
2870 } | 2873 { |
2871 | 2874 os << (int)*it3 << ", "; |
2872 // uplinkPowerControlCommon· | 2875 } |
2873 bIterator = DeserializeSequence (&bitset0,false,bIterator); | 2876 os << std::endl; |
2874 bIterator = DeserializeInteger (&n,-126,24,bIterator); // p0-NominalPUSCH | 2877 |
2875 bIterator = DeserializeEnum (8,&n,bIterator); // alpha· | 2878 os << " havePhysicalConfigDedicated: " << radioResourceConfigDedicated.hav
ePhysicalConfigDedicated << std::endl; |
2876 bIterator = DeserializeInteger (&n,-127,-96,bIterator); // p0-NominalPUCCH· | 2879 |
2877 //deltaFList-PUCCH· | 2880 if (radioResourceConfigDedicated.havePhysicalConfigDedicated) |
2878 bIterator = DeserializeSequence (&bitset0,false,bIterator); | 2881 { |
2879 bIterator = DeserializeEnum (3,&n,bIterator); // deltaF-PUCCH-Format1· | 2882 os << " physicalConfigDedicated: " << std::endl; |
2880 bIterator = DeserializeEnum (3,&n,bIterator); // deltaF-PUCCH-Format1b· | 2883 |
2881 bIterator = DeserializeEnum (4,&n,bIterator); // deltaF-PUCCH-Format2· | 2884 os << " haveSoundingRsUlConfigDedicated: " << radioResourceConfigDe
dicated.physicalConfigDedicated.haveSoundingRsUlConfigDedicated << std::endl; |
2882 bIterator = DeserializeEnum (3,&n,bIterator); // deltaF-PUCCH-Format2a· | 2885 if (radioResourceConfigDedicated.physicalConfigDedicated.haveSoundingRsU
lConfigDedicated) |
2883 bIterator = DeserializeEnum (3,&n,bIterator); // deltaF-PUCCH-Format2b | 2886 { |
2884 bIterator = DeserializeInteger (&n,-1,6,bIterator); // deltaPreambleMsg3· | 2887 os << " soundingRsUlConfigDedicated: " << std::endl; |
| 2888 os << " type: " << radioResourceConfigDedicated.physicalConf
igDedicated.soundingRsUlConfigDedicated.type << std::endl; |
| 2889 os << " srsBandwidth: " << (int)radioResourceConfigDedicated
.physicalConfigDedicated.soundingRsUlConfigDedicated.srsBandwidth << std::endl; |
| 2890 os << " srsConfigIndex: " << (int)radioResourceConfigDedicat
ed.physicalConfigDedicated.soundingRsUlConfigDedicated.srsConfigIndex << std::en
dl; |
| 2891 } |
| 2892 |
| 2893 os << " haveAntennaInfoDedicated: " << radioResourceConfigDedicated
.physicalConfigDedicated.haveAntennaInfoDedicated << std::endl; |
| 2894 if (radioResourceConfigDedicated.physicalConfigDedicated.haveAntennaInfo
Dedicated) |
| 2895 { |
| 2896 os << " antennaInfo Tx mode: " << (int)radioResourceConfigDedic
ated.physicalConfigDedicated.antennaInfo.transmissionMode << std::endl; |
| 2897 } |
| 2898 } |
| 2899 } |
| 2900 |
| 2901 Buffer::Iterator |
| 2902 RrcAsn1Header::DeserializeSystemInformationBlockType1 (LteRrcSap::SystemInform
ationBlockType1 *systemInformationBlockType1, Buffer::Iterator bIterator) |
| 2903 { |
| 2904 std::bitset<0> bitset0; |
| 2905 int n; |
| 2906 |
| 2907 std::bitset<3> sysInfoBlkT1Opts; |
| 2908 bIterator = DeserializeSequence (&sysInfoBlkT1Opts,false,bIterator); |
| 2909 |
| 2910 // Deserialize cellAccessRelatedInfo |
| 2911 std::bitset<1> cellAccessRelatedInfoOpts; |
| 2912 bIterator = DeserializeSequence (&cellAccessRelatedInfoOpts,false,bIterator)
; |
| 2913 |
| 2914 // Deserialize plmn-IdentityList |
| 2915 int numPlmnIdentityInfoElements; |
| 2916 bIterator = DeserializeSequenceOf (&numPlmnIdentityInfoElements,6,1,bIterato
r); |
| 2917 for (int i = 0; i < numPlmnIdentityInfoElements; i++) |
| 2918 { |
| 2919 bIterator = DeserializeSequence (&bitset0,false,bIterator); |
| 2920 |
| 2921 // plmn-Identity |
| 2922 bIterator = DeserializePlmnIdentity (&systemInformationBlockType1->cellA
ccessRelatedInfo.plmnIdentityInfo.plmnIdentity,bIterator); |
| 2923 } |
| 2924 |
| 2925 // Deserialize trackingAreaCode |
| 2926 std::bitset<16> trackingAreaCode; |
| 2927 bIterator = DeserializeBitstring (&trackingAreaCode,bIterator); |
| 2928 |
| 2929 // Deserialize cellIdentity |
| 2930 std::bitset<28> cellIdentity; |
| 2931 bIterator = DeserializeBitstring (&cellIdentity,bIterator); |
| 2932 systemInformationBlockType1->cellAccessRelatedInfo.cellIdentity = cellIdenti
ty.to_ulong (); |
| 2933 |
| 2934 // Deserialize cellBarred |
| 2935 bIterator = DeserializeEnum (2,&n,bIterator); |
| 2936 |
| 2937 // Deserialize intraFreqReselection |
| 2938 bIterator = DeserializeEnum (2,&n,bIterator); |
| 2939 |
| 2940 // Deserialize csg-Indication |
| 2941 bIterator = DeserializeBoolean (&systemInformationBlockType1->cellAccessRela
tedInfo.csgIndication,bIterator); |
| 2942 |
| 2943 if (cellAccessRelatedInfoOpts[0]) |
| 2944 { |
| 2945 // Deserialize csg-Identity |
| 2946 std::bitset<27> csgIdentity; |
| 2947 bIterator = DeserializeBitstring (&csgIdentity,bIterator); |
| 2948 systemInformationBlockType1->cellAccessRelatedInfo.csgIdentity = csgIden
tity.to_ulong (); |
| 2949 } |
| 2950 |
| 2951 // Deserialize cellSelectionInfo |
| 2952 std::bitset<1> qRxLevMinOffsetPresent; |
| 2953 bIterator = DeserializeSequence (&qRxLevMinOffsetPresent,false,bIterator); |
| 2954 bIterator = DeserializeInteger (&n,-70,-22,bIterator); //q-RxLevMin |
| 2955 if (qRxLevMinOffsetPresent[0]) |
| 2956 { |
| 2957 // Deserialize qRxLevMinOffset |
| 2958 // ... |
| 2959 } |
| 2960 |
| 2961 if (sysInfoBlkT1Opts[2]) |
| 2962 { |
| 2963 // Deserialize p-Max |
| 2964 // ... |
| 2965 } |
| 2966 |
| 2967 // freqBandIndicator |
| 2968 bIterator = DeserializeInteger (&n,1,64,bIterator); |
| 2969 |
| 2970 // schedulingInfoList |
| 2971 int numSchedulingInfo; |
| 2972 bIterator = DeserializeSequenceOf (&numSchedulingInfo,MAX_SI_MESSAGE,1,bIter
ator); |
| 2973 for (int i = 0; i < numSchedulingInfo; i++) |
| 2974 { |
| 2975 bIterator = DeserializeSequence (&bitset0,false,bIterator); |
| 2976 bIterator = DeserializeEnum (7,&n,bIterator); // si-Periodicity |
| 2977 int numSibType; |
| 2978 bIterator = DeserializeSequenceOf (&numSibType,MAX_SIB - 1,0, bIterator)
; // sib-MappingInfo |
| 2979 for (int j = 0; j < numSibType; j++) |
| 2980 { |
| 2981 bIterator = DeserializeEnum (16,&n,bIterator); // SIB-Type |
| 2982 } |
| 2983 } |
| 2984 |
| 2985 if (sysInfoBlkT1Opts[1]) |
| 2986 { |
| 2987 // tdd-Config |
| 2988 // ... |
| 2989 } |
| 2990 |
| 2991 // si-WindowLength |
| 2992 bIterator = DeserializeEnum (7,&n,bIterator); |
| 2993 |
| 2994 // systemInfoValueTag |
| 2995 bIterator = DeserializeInteger (&n,0,31,bIterator); |
| 2996 |
| 2997 if (sysInfoBlkT1Opts[0]) |
| 2998 { |
| 2999 // Deserialize nonCriticalExtension |
| 3000 // ... |
| 3001 } |
| 3002 return bIterator; |
| 3003 } |
| 3004 |
| 3005 Buffer::Iterator |
| 3006 RrcAsn1Header::DeserializeSystemInformationBlockType2 (LteRrcSap::SystemInform
ationBlockType2 *systemInformationBlockType2, Buffer::Iterator bIterator) |
| 3007 { |
| 3008 std::bitset<0> bitset0; |
| 3009 int n; |
| 3010 |
| 3011 std::bitset<2> sysInfoBlkT2Opts; |
| 3012 bIterator = DeserializeSequence (&sysInfoBlkT2Opts,true,bIterator); |
| 3013 if (sysInfoBlkT2Opts[1]) |
| 3014 { |
| 3015 // Deserialize ac-BarringInfo |
| 3016 // ... |
| 3017 } |
| 3018 |
| 3019 // Deserialize radioResourceConfigCommon |
| 3020 bIterator = DeserializeRadioResourceConfigCommonSib (&systemInformationBlock
Type2->radioResourceConfigCommon, bIterator); |
| 3021 |
| 3022 // Deserialize ue-TimersAndConstants |
| 3023 bIterator = DeserializeSequence (&bitset0,true,bIterator); |
| 3024 bIterator = DeserializeEnum (8,&n,bIterator); // t300 |
| 3025 bIterator = DeserializeEnum (8,&n,bIterator); // t301 |
| 3026 bIterator = DeserializeEnum (7,&n,bIterator); // t310 |
| 3027 bIterator = DeserializeEnum (8,&n,bIterator); // n310 |
| 3028 bIterator = DeserializeEnum (7,&n,bIterator); // t311 |
| 3029 bIterator = DeserializeEnum (8,&n,bIterator); // n311 |
| 3030 |
| 3031 // Deserialize freqInfo |
| 3032 std::bitset<2> freqInfoOpts; |
| 3033 bIterator = DeserializeSequence (&freqInfoOpts,false,bIterator); |
| 3034 if (freqInfoOpts[1]) |
| 3035 { |
| 3036 // Deserialize ul-CarrierFreq |
| 3037 bIterator = DeserializeInteger (&n, 0, MAX_EARFCN, bIterator); |
| 3038 systemInformationBlockType2->freqInfo.ulCarrierFreq = n; |
| 3039 } |
| 3040 if (freqInfoOpts[0]) |
| 3041 { |
| 3042 // Deserialize ul-Bandwidth |
| 3043 bIterator = DeserializeEnum (6, &n, bIterator); |
| 3044 switch (n) |
| 3045 { |
| 3046 case 0: |
| 3047 systemInformationBlockType2->freqInfo.ulBandwidth = 6; |
| 3048 break; |
| 3049 case 1: |
| 3050 systemInformationBlockType2->freqInfo.ulBandwidth = 15; |
| 3051 break; |
| 3052 case 2: |
| 3053 systemInformationBlockType2->freqInfo.ulBandwidth = 25; |
| 3054 break; |
| 3055 case 3: |
| 3056 systemInformationBlockType2->freqInfo.ulBandwidth = 50; |
| 3057 break; |
| 3058 case 4: |
| 3059 systemInformationBlockType2->freqInfo.ulBandwidth = 75; |
| 3060 break; |
| 3061 case 5: |
| 3062 systemInformationBlockType2->freqInfo.ulBandwidth = 100; |
| 3063 break; |
| 3064 default: |
| 3065 systemInformationBlockType2->freqInfo.ulBandwidth = 6; |
| 3066 } |
| 3067 } |
| 3068 |
| 3069 // additionalSpectrumEmission |
| 3070 bIterator = DeserializeInteger (&n,1,32,bIterator); |
| 3071 |
| 3072 if (sysInfoBlkT2Opts[0]) |
| 3073 { |
| 3074 // Deserialize mbsfn-SubframeConfigList |
| 3075 // ... |
| 3076 } |
| 3077 |
| 3078 // Deserialize timeAlignmentTimerCommon |
| 3079 bIterator = DeserializeEnum (8,&n,bIterator); |
| 3080 |
| 3081 return bIterator; |
| 3082 } |
| 3083 |
| 3084 |
| 3085 Buffer::Iterator |
| 3086 RrcAsn1Header::DeserializeRadioResourceConfigCommon (LteRrcSap::RadioResourceC
onfigCommon * radioResourceConfigCommon, Buffer::Iterator bIterator) |
| 3087 { |
| 3088 std::bitset<0> bitset0; |
| 3089 int n; |
| 3090 |
| 3091 std::bitset<9> rrCfgCommOptions; |
| 3092 bIterator = DeserializeSequence (&rrCfgCommOptions,true,bIterator); |
| 3093 |
| 3094 // rach-ConfigCommon |
| 3095 if (rrCfgCommOptions[8]) |
| 3096 { |
| 3097 bIterator = DeserializeRachConfigCommon (&radioResourceConfigCommon->rac
hConfigCommon, bIterator); |
| 3098 } |
| 3099 |
| 3100 // prach-Config |
| 3101 std::bitset<1> prachConfigInfoPresent; |
| 3102 bIterator = DeserializeSequence (&prachConfigInfoPresent,false,bIterator); |
| 3103 |
| 3104 // prach-Config -> rootSequenceIndex |
| 3105 bIterator = DeserializeInteger (&n,0,1023,bIterator); |
| 3106 |
| 3107 // prach-Config -> prach-ConfigInfo |
| 3108 if (prachConfigInfoPresent[0]) |
| 3109 { |
| 3110 // ... |
| 3111 } |
| 3112 |
| 3113 // pdsch-ConfigCommon |
| 3114 if (rrCfgCommOptions[7]) |
| 3115 { |
| 3116 // ... |
| 3117 } |
| 3118 |
| 3119 // pusch-ConfigCommon |
| 3120 bIterator = DeserializeSequence (&bitset0,false,bIterator); |
| 3121 |
| 3122 // pusch-ConfigCommon -> pusch-ConfigBasic |
| 3123 bIterator = DeserializeSequence (&bitset0,false,bIterator); |
| 3124 |
| 3125 // pusch-ConfigCommon -> pusch-ConfigBasic -> n-SB |
| 3126 bIterator = DeserializeInteger (&n,1,4,bIterator); |
| 3127 |
| 3128 // pusch-ConfigCommon -> pusch-ConfigBasic -> hoppingMode |
| 3129 bIterator = DeserializeEnum (2,&n,bIterator); |
| 3130 |
| 3131 // pusch-ConfigCommon -> pusch-ConfigBasic -> pusch-HoppingOffset |
| 3132 bIterator = DeserializeInteger (&n,0,98,bIterator); |
| 3133 |
| 3134 // pusch-ConfigCommon -> pusch-ConfigBasic -> enable64QAM |
| 3135 bool enable64QAM; |
| 3136 bIterator = DeserializeBoolean (&enable64QAM,bIterator); |
| 3137 |
| 3138 // ul-ReferenceSignalsPUSCH |
| 3139 bIterator = DeserializeSequence (&bitset0,false,bIterator); |
| 3140 |
| 3141 // groupHoppingEnabled |
| 3142 bool dummyBool; |
| 3143 bIterator = DeserializeBoolean (&dummyBool,bIterator); |
| 3144 |
| 3145 // groupAssignmentPUSCH |
| 3146 bIterator = DeserializeInteger (&n,0,29,bIterator); |
| 3147 |
| 3148 // sequenceHoppingEnabled |
| 3149 bIterator = DeserializeBoolean (&dummyBool,bIterator); |
| 3150 |
| 3151 // cyclicShift |
| 3152 bIterator = DeserializeInteger (&n,0,7,bIterator); |
| 3153 |
| 3154 // phich-Config |
| 3155 if (rrCfgCommOptions[6]) |
| 3156 { |
| 3157 // ... |
| 3158 } |
| 3159 |
| 3160 // pucch-ConfigCommon |
| 3161 if (rrCfgCommOptions[5]) |
| 3162 { |
| 3163 // ... |
| 3164 } |
| 3165 |
| 3166 // soundingRS-UL-ConfigCommon |
| 3167 if (rrCfgCommOptions[4]) |
| 3168 { |
| 3169 // ... |
| 3170 } |
| 3171 |
| 3172 // uplinkPowerControlCommon |
| 3173 if (rrCfgCommOptions[3]) |
| 3174 { |
| 3175 // ... |
| 3176 } |
| 3177 |
| 3178 // antennaInfoCommon |
| 3179 if (rrCfgCommOptions[2]) |
| 3180 { |
| 3181 // ... |
| 3182 } |
| 3183 |
| 3184 // p-Max |
| 3185 if (rrCfgCommOptions[1]) |
| 3186 { |
| 3187 // ... |
| 3188 } |
| 3189 |
| 3190 // tdd-Config |
| 3191 if (rrCfgCommOptions[0]) |
| 3192 { |
| 3193 // ... |
| 3194 } |
| 3195 |
| 3196 // ul-CyclicPrefixLength |
| 3197 bIterator = DeserializeEnum (2,&n,bIterator); |
| 3198 |
| 3199 return bIterator; |
| 3200 } |
| 3201 |
| 3202 Buffer::Iterator |
| 3203 RrcAsn1Header::DeserializeRachConfigCommon (LteRrcSap::RachConfigCommon * rach
ConfigCommon, Buffer::Iterator bIterator) |
| 3204 { |
| 3205 std::bitset<0> bitset0; |
| 3206 int n; |
| 3207 |
| 3208 bIterator = DeserializeSequence (&bitset0,true,bIterator); |
| 3209 |
| 3210 // preambleInfo |
| 3211 std::bitset<1> preamblesGroupAConfigPresent; |
| 3212 bIterator = DeserializeSequence (&preamblesGroupAConfigPresent,false,bIterat
or); |
| 3213 |
| 3214 // numberOfRA-Preambles |
| 3215 bIterator = DeserializeEnum (16,&n,bIterator); |
| 3216 switch (n) |
| 3217 { |
| 3218 case 0: |
| 3219 rachConfigCommon->preambleInfo.numberOfRaPreambles = 4; |
| 3220 break; |
| 3221 case 1: |
| 3222 rachConfigCommon->preambleInfo.numberOfRaPreambles = 8; |
| 3223 break; |
| 3224 case 2: |
| 3225 rachConfigCommon->preambleInfo.numberOfRaPreambles = 12; |
| 3226 break; |
| 3227 case 3: |
| 3228 rachConfigCommon->preambleInfo.numberOfRaPreambles = 16; |
| 3229 break; |
| 3230 case 4: |
| 3231 rachConfigCommon->preambleInfo.numberOfRaPreambles = 20; |
| 3232 break; |
| 3233 case 5: |
| 3234 rachConfigCommon->preambleInfo.numberOfRaPreambles = 24; |
| 3235 break; |
| 3236 case 6: |
| 3237 rachConfigCommon->preambleInfo.numberOfRaPreambles = 28; |
| 3238 break; |
| 3239 case 7: |
| 3240 rachConfigCommon->preambleInfo.numberOfRaPreambles = 32; |
| 3241 break; |
| 3242 case 8: |
| 3243 rachConfigCommon->preambleInfo.numberOfRaPreambles = 36; |
| 3244 break; |
| 3245 case 9: |
| 3246 rachConfigCommon->preambleInfo.numberOfRaPreambles = 40; |
| 3247 break; |
| 3248 case 10: |
| 3249 rachConfigCommon->preambleInfo.numberOfRaPreambles = 44; |
| 3250 break; |
| 3251 case 11: |
| 3252 rachConfigCommon->preambleInfo.numberOfRaPreambles = 48; |
| 3253 break; |
| 3254 case 12: |
| 3255 rachConfigCommon->preambleInfo.numberOfRaPreambles = 52; |
| 3256 break; |
| 3257 case 13: |
| 3258 rachConfigCommon->preambleInfo.numberOfRaPreambles = 56; |
| 3259 break; |
| 3260 case 14: |
| 3261 rachConfigCommon->preambleInfo.numberOfRaPreambles = 60; |
| 3262 break; |
| 3263 case 15: |
| 3264 rachConfigCommon->preambleInfo.numberOfRaPreambles = 64; |
| 3265 break; |
| 3266 default: |
| 3267 rachConfigCommon->preambleInfo.numberOfRaPreambles = 0; |
| 3268 } |
| 3269 |
| 3270 rachConfigCommon->preambleInfo.numberOfRaPreambles = n; |
| 3271 |
| 3272 if (preamblesGroupAConfigPresent[0]) |
| 3273 { |
| 3274 // Deserialize preamblesGroupAConfig |
| 3275 // ... |
| 3276 } |
| 3277 |
| 3278 // powerRampingParameters |
| 3279 bIterator = DeserializeSequence (&bitset0,false,bIterator); |
| 3280 bIterator = DeserializeEnum (4,&n,bIterator); // powerRampingStep |
| 3281 bIterator = DeserializeEnum (16,&n,bIterator); // preambleInitialReceivedTar
getPower |
| 3282 |
| 3283 // ra-SupervisionInfo |
| 3284 bIterator = DeserializeSequence (&bitset0,false,bIterator); |
| 3285 bIterator = DeserializeEnum (11,&n,bIterator); // preambleTransMax |
| 3286 switch (n) |
| 3287 { |
| 3288 case 0: |
| 3289 rachConfigCommon->raSupervisionInfo.preambleTransMax = 3; |
| 3290 break; |
| 3291 case 1: |
| 3292 rachConfigCommon->raSupervisionInfo.preambleTransMax = 4; |
| 3293 break; |
| 3294 case 2: |
| 3295 rachConfigCommon->raSupervisionInfo.preambleTransMax = 5; |
| 3296 break; |
| 3297 case 3: |
| 3298 rachConfigCommon->raSupervisionInfo.preambleTransMax = 6; |
| 3299 break; |
| 3300 case 4: |
| 3301 rachConfigCommon->raSupervisionInfo.preambleTransMax = 7; |
| 3302 break; |
| 3303 case 5: |
| 3304 rachConfigCommon->raSupervisionInfo.preambleTransMax = 8; |
| 3305 break; |
| 3306 case 6: |
| 3307 rachConfigCommon->raSupervisionInfo.preambleTransMax = 10; |
| 3308 break; |
| 3309 case 7: |
| 3310 rachConfigCommon->raSupervisionInfo.preambleTransMax = 20; |
| 3311 break; |
| 3312 case 8: |
| 3313 rachConfigCommon->raSupervisionInfo.preambleTransMax = 50; |
| 3314 break; |
| 3315 case 9: |
| 3316 rachConfigCommon->raSupervisionInfo.preambleTransMax = 100; |
| 3317 break; |
| 3318 case 10: |
| 3319 rachConfigCommon->raSupervisionInfo.preambleTransMax = 200; |
| 3320 break; |
| 3321 default: |
| 3322 rachConfigCommon->raSupervisionInfo.preambleTransMax = 0; |
| 3323 } |
| 3324 |
| 3325 // ra-ResponseWindowSize |
| 3326 bIterator = DeserializeEnum (8,&n,bIterator); |
| 3327 switch (n) |
| 3328 { |
| 3329 case 0: |
| 3330 rachConfigCommon->raSupervisionInfo.raResponseWindowSize = 2; |
| 3331 break; |
| 3332 case 1: |
| 3333 rachConfigCommon->raSupervisionInfo.raResponseWindowSize = 3; |
| 3334 break; |
| 3335 case 2: |
| 3336 rachConfigCommon->raSupervisionInfo.raResponseWindowSize = 4; |
| 3337 break; |
| 3338 case 3: |
| 3339 rachConfigCommon->raSupervisionInfo.raResponseWindowSize = 5; |
| 3340 break; |
| 3341 case 4: |
| 3342 rachConfigCommon->raSupervisionInfo.raResponseWindowSize = 6; |
| 3343 break; |
| 3344 case 5: |
| 3345 rachConfigCommon->raSupervisionInfo.raResponseWindowSize = 7; |
| 3346 break; |
| 3347 case 6: |
| 3348 rachConfigCommon->raSupervisionInfo.raResponseWindowSize = 8; |
| 3349 break; |
| 3350 case 7: |
| 3351 rachConfigCommon->raSupervisionInfo.raResponseWindowSize = 10; |
| 3352 break; |
| 3353 default: |
| 3354 rachConfigCommon->raSupervisionInfo.raResponseWindowSize = 0; |
| 3355 } |
| 3356 |
| 3357 bIterator = DeserializeEnum (8,&n,bIterator); // mac-ContentionResolutionTim
er |
| 3358 bIterator = DeserializeInteger (&n,1,8,bIterator); //maxHARQ-Msg3Tx |
| 3359 return bIterator; |
| 3360 } |
| 3361 |
| 3362 Buffer::Iterator |
| 3363 RrcAsn1Header::DeserializeRadioResourceConfigCommonSib (LteRrcSap::RadioResour
ceConfigCommonSib * radioResourceConfigCommonSib, Buffer::Iterator bIterator) |
| 3364 { |
| 3365 std::bitset<0> bitset0; |
| 3366 int n; |
| 3367 |
| 3368 bIterator = DeserializeSequence (&bitset0,true,bIterator); |
| 3369 |
| 3370 // rach-ConfigCommon |
| 3371 bIterator = DeserializeRachConfigCommon (&radioResourceConfigCommonSib->rach
ConfigCommon, bIterator); |
| 3372 |
| 3373 // bcch-Config· |
| 3374 bIterator = DeserializeSequence (&bitset0,false,bIterator); |
| 3375 bIterator = DeserializeEnum (4,&n,bIterator); // modificationPeriodCoeff |
| 3376 |
| 3377 // pcch-Config· |
| 3378 bIterator = DeserializeSequence (&bitset0,false,bIterator); |
| 3379 bIterator = DeserializeEnum (4,&n,bIterator); // defaultPagingCycle |
| 3380 bIterator = DeserializeEnum (8,&n,bIterator); // nB |
| 3381 |
| 3382 // prach-Config· |
| 3383 std::bitset<1> prachConfigInfoPresent; |
| 3384 bIterator = DeserializeSequence (&prachConfigInfoPresent,false,bIterator); |
| 3385 // prach-Config -> rootSequenceIndex |
| 3386 bIterator = DeserializeInteger (&n,0,1023,bIterator); |
| 3387 // prach-Config -> prach-ConfigInfo |
| 3388 if (prachConfigInfoPresent[0]) |
| 3389 { |
| 3390 // ... |
| 3391 } |
| 3392 |
| 3393 // pdsch-ConfigCommon· |
| 3394 bIterator = DeserializeSequence (&bitset0,false,bIterator); |
| 3395 bIterator = DeserializeInteger (&n,-60,50,bIterator); // referenceSignalPowe
r |
| 3396 bIterator = DeserializeInteger (&n,0,3,bIterator); // p-b |
| 3397 |
| 3398 // pusch-ConfigCommon |
| 3399 bIterator = DeserializeSequence (&bitset0,false,bIterator); |
| 3400 |
| 3401 // pusch-ConfigCommon -> pusch-ConfigBasic |
| 3402 bIterator = DeserializeSequence (&bitset0,false,bIterator); |
| 3403 |
| 3404 // pusch-ConfigCommon -> pusch-ConfigBasic -> n-SB |
| 3405 bIterator = DeserializeInteger (&n,1,4,bIterator); |
| 3406 |
| 3407 // pusch-ConfigCommon -> pusch-ConfigBasic -> hoppingMode |
| 3408 bIterator = DeserializeEnum (2,&n,bIterator); |
| 3409 |
| 3410 // pusch-ConfigCommon -> pusch-ConfigBasic -> pusch-HoppingOffset |
| 3411 bIterator = DeserializeInteger (&n,0,98,bIterator); |
| 3412 |
| 3413 // pusch-ConfigCommon -> pusch-ConfigBasic -> enable64QAM |
| 3414 bool dummyBoolean; |
| 3415 bIterator = DeserializeBoolean (&dummyBoolean,bIterator); |
| 3416 |
| 3417 // ul-ReferenceSignalsPUSCH· |
| 3418 bIterator = DeserializeSequence (&bitset0,false,bIterator); |
| 3419 |
| 3420 // groupHoppingEnabled· |
| 3421 bIterator = DeserializeBoolean (&dummyBoolean,bIterator); |
| 3422 |
| 3423 // groupAssignmentPUSCH· |
| 3424 bIterator = DeserializeInteger (&n,0,29,bIterator); |
| 3425 |
| 3426 // sequenceHoppingEnabled· |
| 3427 bIterator = DeserializeBoolean (&dummyBoolean,bIterator); |
| 3428 |
| 3429 // cyclicShift· |
| 3430 bIterator = DeserializeInteger (&n,0,7,bIterator); |
| 3431 |
| 3432 // pucch-ConfigCommon· |
| 3433 bIterator = DeserializeEnum (3,&n,bIterator); // deltaPUCCH-Shift· |
| 3434 bIterator = DeserializeInteger (&n,0,98,bIterator); // nRB-CQI· |
| 3435 bIterator = DeserializeInteger (&n,0,7,bIterator); // nCS-AN· |
| 3436 bIterator = DeserializeInteger (&n,0,2047,bIterator); // n1PUCCH-AN· |
| 3437 |
| 3438 // soundingRS-UL-ConfigCommon |
| 3439 int choice; |
| 3440 bIterator = DeserializeChoice (2,false,&choice,bIterator); |
| 3441 if (choice == 0) |
| 3442 { |
| 3443 bIterator = DeserializeNull (bIterator); // release |
| 3444 } |
| 3445 if (choice == 1) |
| 3446 { |
| 3447 // setup |
| 3448 // ... |
| 3449 } |
| 3450 |
| 3451 // uplinkPowerControlCommon· |
| 3452 bIterator = DeserializeSequence (&bitset0,false,bIterator); |
| 3453 bIterator = DeserializeInteger (&n,-126,24,bIterator); // p0-NominalPUSCH |
| 3454 bIterator = DeserializeEnum (8,&n,bIterator); // alpha· |
| 3455 bIterator = DeserializeInteger (&n,-127,-96,bIterator); // p0-NominalPUCCH· |
| 3456 //deltaFList-PUCCH· |
| 3457 bIterator = DeserializeSequence (&bitset0,false,bIterator); |
| 3458 bIterator = DeserializeEnum (3,&n,bIterator); // deltaF-PUCCH-Format1· |
| 3459 bIterator = DeserializeEnum (3,&n,bIterator); // deltaF-PUCCH-Format1b· |
| 3460 bIterator = DeserializeEnum (4,&n,bIterator); // deltaF-PUCCH-Format2· |
| 3461 bIterator = DeserializeEnum (3,&n,bIterator); // deltaF-PUCCH-Format2a· |
| 3462 bIterator = DeserializeEnum (3,&n,bIterator); // deltaF-PUCCH-Format2b |
| 3463 bIterator = DeserializeInteger (&n,-1,6,bIterator); // deltaPreambleMsg3· |
2885 · | 3464 · |
2886 // ul-CyclicPrefixLength | 3465 // ul-CyclicPrefixLength |
2887 bIterator = DeserializeEnum (2,&n,bIterator); | 3466 bIterator = DeserializeEnum (2,&n,bIterator); |
2888 | 3467 |
2889 return bIterator; | 3468 return bIterator; |
2890 } | 3469 } |
2891 | 3470 |
2892 Buffer::Iterator | 3471 Buffer::Iterator |
2893 RrcAsn1Header::DeserializeMeasResults (LteRrcSap::MeasResults *measResults, Buff
er::Iterator bIterator) | 3472 RrcAsn1Header::DeserializeMeasResults (LteRrcSap::MeasResults *measResults, Bu
ffer::Iterator bIterator) |
2894 { | 3473 { |
2895 int n; | 3474 int n; |
2896 std::bitset<0> b0; | 3475 std::bitset<0> b0; |
2897 std::bitset<1> measResultNeighCellsPresent; | 3476 std::bitset<1> measResultNeighCellsPresent; |
2898 bIterator = DeserializeSequence (&measResultNeighCellsPresent,true,bIterator); | 3477 bIterator = DeserializeSequence (&measResultNeighCellsPresent,true,bIterator
); |
2899 | 3478 |
2900 // Deserialize measId | 3479 // Deserialize measId |
2901 bIterator = DeserializeInteger (&n, 1, MAX_MEAS_ID, bIterator); | 3480 bIterator = DeserializeInteger (&n, 1, MAX_MEAS_ID, bIterator); |
2902 measResults->measId = n; | 3481 measResults->measId = n; |
2903 | 3482 |
2904 // Deserialize measResultServCell | 3483 // Deserialize measResultServCell |
2905 bIterator = DeserializeSequence (&b0,false,bIterator); | 3484 bIterator = DeserializeSequence (&b0,false,bIterator); |
2906 | 3485 |
2907 // Deserialize rsrpResult | 3486 // Deserialize rsrpResult |
2908 bIterator = DeserializeInteger (&n, 0, 97, bIterator); | 3487 bIterator = DeserializeInteger (&n, 0, 97, bIterator); |
2909 measResults->rsrpResult = n; | 3488 measResults->rsrpResult = n; |
2910 | 3489 |
2911 // Deserialize rsrqResult | 3490 // Deserialize rsrqResult |
2912 bIterator = DeserializeInteger (&n, 0, 34, bIterator); | 3491 bIterator = DeserializeInteger (&n, 0, 34, bIterator); |
2913 measResults->rsrqResult = n; | 3492 measResults->rsrqResult = n; |
2914 | 3493 |
2915 measResults->haveMeasResultNeighCells = measResultNeighCellsPresent[0]; | 3494 measResults->haveMeasResultNeighCells = measResultNeighCellsPresent[0]; |
2916 if ( measResults->haveMeasResultNeighCells) | 3495 if ( measResults->haveMeasResultNeighCells) |
2917 { | 3496 { |
2918 int measResultNeighCellsChoice; | 3497 int measResultNeighCellsChoice; |
2919 | 3498 |
2920 // Deserialize measResultNeighCells | 3499 // Deserialize measResultNeighCells |
2921 bIterator = DeserializeChoice (4,false,&measResultNeighCellsChoice,bIterat
or); | 3500 bIterator = DeserializeChoice (4,false,&measResultNeighCellsChoice,bIter
ator); |
2922 | 3501 |
2923 if (measResultNeighCellsChoice == 0) | 3502 if (measResultNeighCellsChoice == 0) |
2924 { | 3503 { |
2925 // Deserialize measResultListEUTRA | 3504 // Deserialize measResultListEUTRA |
2926 int numElems; | 3505 int numElems; |
2927 bIterator = DeserializeSequenceOf (&numElems,MAX_CELL_REPORT,1,bIterat
or); | 3506 bIterator = DeserializeSequenceOf (&numElems,MAX_CELL_REPORT,1,bIter
ator); |
2928 | 3507 |
2929 for (int i = 0; i < numElems; i++) | 3508 for (int i = 0; i < numElems; i++) |
2930 { | 3509 { |
2931 LteRrcSap::MeasResultEutra measResultEutra; | 3510 LteRrcSap::MeasResultEutra measResultEutra; |
2932 | 3511 |
2933 std::bitset<1> isCgiInfoPresent; | 3512 std::bitset<1> isCgiInfoPresent; |
2934 bIterator = DeserializeSequence (&isCgiInfoPresent,false,bIterator
); | 3513 bIterator = DeserializeSequence (&isCgiInfoPresent,false,bIterat
or); |
2935 | 3514 |
2936 // PhysCellId | 3515 // PhysCellId |
2937 bIterator = DeserializeInteger (&n,0,503,bIterator); | 3516 bIterator = DeserializeInteger (&n,0,503,bIterator); |
2938 measResultEutra.physCellId = n; | 3517 measResultEutra.physCellId = n; |
2939 | 3518 |
2940 measResultEutra.haveCgiInfo = isCgiInfoPresent[0]; | 3519 measResultEutra.haveCgiInfo = isCgiInfoPresent[0]; |
2941 if (isCgiInfoPresent[0]) | 3520 if (isCgiInfoPresent[0]) |
2942 { | 3521 { |
2943 std::bitset<1> havePlmnIdentityList; | 3522 std::bitset<1> havePlmnIdentityList; |
2944 bIterator = DeserializeSequence (&havePlmnIdentityList,false,b
Iterator); | 3523 bIterator = DeserializeSequence (&havePlmnIdentityList,false
,bIterator); |
2945 | 3524 |
2946 // Deserialize cellGlobalId | 3525 // Deserialize cellGlobalId |
2947 bIterator = DeserializeSequence (&b0,false,bIterator); | 3526 bIterator = DeserializeSequence (&b0,false,bIterator); |
2948 | 3527 |
2949 // Deserialize plmn-Identity | 3528 // Deserialize plmn-Identity |
2950 bIterator = DeserializePlmnIdentity (&measResultEutra.cgiInfo.
plmnIdentity,bIterator); | 3529 bIterator = DeserializePlmnIdentity (&measResultEutra.cgiInf
o.plmnIdentity,bIterator); |
2951 | 3530 |
2952 // Deserialize CellIdentity | 3531 // Deserialize CellIdentity |
2953 std::bitset<28> cellId; | 3532 std::bitset<28> cellId; |
2954 bIterator = DeserializeBitstring (&cellId,bIterator); | 3533 bIterator = DeserializeBitstring (&cellId,bIterator); |
2955 measResultEutra.cgiInfo.cellIdentity = cellId.to_ulong (); | 3534 measResultEutra.cgiInfo.cellIdentity = cellId.to_ulong (); |
2956 | 3535 |
2957 // Deserialize trackingAreaCode | 3536 // Deserialize trackingAreaCode |
2958 std::bitset<16> trArCo; | 3537 std::bitset<16> trArCo; |
2959 bIterator = DeserializeBitstring (&trArCo,bIterator); | 3538 bIterator = DeserializeBitstring (&trArCo,bIterator); |
2960 measResultEutra.cgiInfo.trackingAreaCode = trArCo.to_ulong (); | 3539 measResultEutra.cgiInfo.trackingAreaCode = trArCo.to_ulong (
); |
2961 | 3540 |
2962 // Deserialize plmn-IdentityList | 3541 // Deserialize plmn-IdentityList |
2963 if (havePlmnIdentityList[0]) | 3542 if (havePlmnIdentityList[0]) |
2964 { | 3543 { |
2965 int numPlmnElems; | 3544 int numPlmnElems; |
2966 bIterator = DeserializeSequenceOf (&numPlmnElems, 5, 1, bI
terator); | 3545 bIterator = DeserializeSequenceOf (&numPlmnElems, 5, 1,
bIterator); |
2967 | 3546 |
2968 for ( int j = 0; j < numPlmnElems; j++) | 3547 for ( int j = 0; j < numPlmnElems; j++) |
2969 { | 3548 { |
2970 uint32_t plmnId; | 3549 uint32_t plmnId; |
2971 bIterator = DeserializePlmnIdentity (&plmnId,bIterator
); | 3550 bIterator = DeserializePlmnIdentity (&plmnId,bIterat
or); |
2972 measResultEutra.cgiInfo.plmnIdentityList.push_back (pl
mnId); | 3551 measResultEutra.cgiInfo.plmnIdentityList.push_back (
plmnId); |
2973 } | 3552 } |
2974 } | 3553 } |
2975 } | 3554 } |
2976 | 3555 |
2977 // Deserialize measResult | 3556 // Deserialize measResult |
2978 std::bitset<2> measResultOpts; | 3557 std::bitset<2> measResultOpts; |
2979 bIterator = DeserializeSequence (&measResultOpts, true, bIterator)
; | 3558 bIterator = DeserializeSequence (&measResultOpts, true, bIterato
r); |
2980 | 3559 |
2981 measResultEutra.haveRsrpResult = measResultOpts[1]; | 3560 measResultEutra.haveRsrpResult = measResultOpts[1]; |
2982 if (measResultOpts[1]) | 3561 if (measResultOpts[1]) |
2983 { | 3562 { |
2984 // Deserialize rsrpResult | 3563 // Deserialize rsrpResult |
2985 bIterator = DeserializeInteger (&n,0,97,bIterator); | 3564 bIterator = DeserializeInteger (&n,0,97,bIterator); |
2986 measResultEutra.rsrpResult = n; | 3565 measResultEutra.rsrpResult = n; |
2987 } | 3566 } |
2988 | 3567 |
2989 measResultEutra.haveRsrqResult = measResultOpts[0]; | 3568 measResultEutra.haveRsrqResult = measResultOpts[0]; |
2990 if (measResultOpts[0]) | 3569 if (measResultOpts[0]) |
2991 { | 3570 { |
2992 // Deserialize rsrqResult | 3571 // Deserialize rsrqResult |
2993 bIterator = DeserializeInteger (&n,0,34,bIterator); | 3572 bIterator = DeserializeInteger (&n,0,34,bIterator); |
2994 measResultEutra.rsrqResult = n; | 3573 measResultEutra.rsrqResult = n; |
2995 } | 3574 } |
2996 | 3575 |
2997 measResults->measResultListEutra.push_back (measResultEutra); | 3576 measResults->measResultListEutra.push_back (measResultEutra); |
2998 } | 3577 } |
2999 } | 3578 } |
3000 | 3579 |
3001 if (measResultNeighCellsChoice == 1) | 3580 if (measResultNeighCellsChoice == 1) |
3002 { | 3581 { |
3003 // Deserialize measResultListUTRA | 3582 // Deserialize measResultListUTRA |
3004 // ... | 3583 // ... |
3005 } | 3584 } |
3006 | 3585 |
3007 if (measResultNeighCellsChoice == 2) | 3586 if (measResultNeighCellsChoice == 2) |
3008 { | 3587 { |
3009 // Deserialize measResultListGERAN | 3588 // Deserialize measResultListGERAN |
3010 // ... | 3589 // ... |
3011 } | 3590 } |
3012 if (measResultNeighCellsChoice == 3) | 3591 if (measResultNeighCellsChoice == 3) |
3013 { | 3592 { |
3014 // Deserialize measResultsCDMA2000 | 3593 // Deserialize measResultsCDMA2000 |
3015 // ... | 3594 // ... |
3016 } | 3595 } |
3017 } | 3596 } |
3018 | 3597 |
3019 return bIterator; | 3598 return bIterator; |
3020 } | 3599 } |
3021 | 3600 |
3022 Buffer::Iterator | 3601 Buffer::Iterator |
3023 RrcAsn1Header::DeserializePlmnIdentity (uint32_t *plmnId, Buffer::Iterator bIter
ator) | 3602 RrcAsn1Header::DeserializePlmnIdentity (uint32_t *plmnId, Buffer::Iterator bIt
erator) |
3024 { | 3603 { |
3025 int n; | 3604 int n; |
3026 std::bitset<1> isMccPresent; | 3605 std::bitset<1> isMccPresent; |
3027 bIterator = DeserializeSequence (&isMccPresent,false,bIterator); | 3606 bIterator = DeserializeSequence (&isMccPresent,false,bIterator); |
3028 | 3607 |
3029 if (isMccPresent[0]) | 3608 if (isMccPresent[0]) |
3030 { | 3609 { |
3031 // Deserialize mcc | 3610 // Deserialize mcc |
3032 // ... | 3611 // ... |
3033 } | 3612 } |
3034 | 3613 |
3035 // Deserialize mnc | 3614 // Deserialize mnc |
3036 int mncDigits; | 3615 int mncDigits; |
3037 int mnc = 0; | 3616 int mnc = 0; |
3038 bIterator = DeserializeSequenceOf (&mncDigits,3,2,bIterator); | 3617 bIterator = DeserializeSequenceOf (&mncDigits,3,2,bIterator); |
3039 | 3618 |
3040 for (int j = mncDigits - 1; j >= 0; j--) | 3619 for (int j = mncDigits - 1; j >= 0; j--) |
3041 { | 3620 { |
3042 bIterator = DeserializeInteger (&n,0,9,bIterator); | 3621 bIterator = DeserializeInteger (&n,0,9,bIterator); |
3043 mnc += n * pow (10,j); | 3622 mnc += n * pow (10,j); |
3044 } | 3623 } |
3045 | 3624 |
3046 *plmnId = mnc; | 3625 *plmnId = mnc; |
3047 | 3626 |
3048 // cellReservedForOperatorUse | 3627 // cellReservedForOperatorUse |
3049 bIterator = DeserializeEnum (2,&n,bIterator); | 3628 bIterator = DeserializeEnum (2,&n,bIterator); |
3050 return bIterator; | 3629 return bIterator; |
3051 } | 3630 } |
3052 | 3631 |
3053 Buffer::Iterator | 3632 Buffer::Iterator |
3054 RrcAsn1Header::DeserializeMeasConfig (LteRrcSap::MeasConfig * measConfig, Buffer
::Iterator bIterator) | 3633 RrcAsn1Header::DeserializeMeasConfig (LteRrcSap::MeasConfig * measConfig, Buff
er::Iterator bIterator) |
3055 { | 3634 { |
3056 std::bitset<0> bitset0; | 3635 std::bitset<0> bitset0; |
3057 std::bitset<2> bitset2; | 3636 std::bitset<2> bitset2; |
3058 std::bitset<11> bitset11; | 3637 std::bitset<11> bitset11; |
3059 int n; | 3638 int n; |
3060 | 3639 |
3061 // measConfig | 3640 // measConfig |
3062 bIterator = DeserializeSequence (&bitset11,true,bIterator); | 3641 bIterator = DeserializeSequence (&bitset11,true,bIterator); |
3063 | 3642 |
3064 if (bitset11[10]) | 3643 if (bitset11[10]) |
3065 { | 3644 { |
3066 // measObjectToRemoveList | 3645 // measObjectToRemoveList |
3067 int measObjectToRemoveListElems; | 3646 int measObjectToRemoveListElems; |
3068 bIterator = DeserializeSequenceOf (&measObjectToRemoveListElems, MAX_OBJEC
T_ID, 1, bIterator); | 3647 bIterator = DeserializeSequenceOf (&measObjectToRemoveListElems, MAX_OBJ
ECT_ID, 1, bIterator); |
3069 | 3648 |
3070 for (int i = 0; i < measObjectToRemoveListElems; i++) | 3649 for (int i = 0; i < measObjectToRemoveListElems; i++) |
3071 { | 3650 { |
3072 bIterator = DeserializeInteger (&n, 1, MAX_OBJECT_ID, bIterator); | 3651 bIterator = DeserializeInteger (&n, 1, MAX_OBJECT_ID, bIterator); |
3073 measConfig->measObjectToRemoveList.push_back (n); | 3652 measConfig->measObjectToRemoveList.push_back (n); |
3074 } | 3653 } |
3075 } | 3654 } |
3076 | 3655 |
3077 if (bitset11[9]) | 3656 if (bitset11[9]) |
3078 { | 3657 { |
3079 // measObjectToAddModList | 3658 // measObjectToAddModList |
3080 int measObjectToAddModListElems; | 3659 int measObjectToAddModListElems; |
3081 bIterator = DeserializeSequenceOf (&measObjectToAddModListElems, MAX_OBJEC
T_ID, 1, bIterator); | 3660 bIterator = DeserializeSequenceOf (&measObjectToAddModListElems, MAX_OBJ
ECT_ID, 1, bIterator); |
3082 | 3661 |
3083 for (int i = 0; i < measObjectToAddModListElems; i++) | 3662 for (int i = 0; i < measObjectToAddModListElems; i++) |
3084 { | 3663 { |
3085 LteRrcSap::MeasObjectToAddMod elem; | 3664 LteRrcSap::MeasObjectToAddMod elem; |
3086 | 3665 |
3087 bIterator = DeserializeSequence (&bitset0, false, bIterator); | 3666 bIterator = DeserializeSequence (&bitset0, false, bIterator); |
3088 | 3667 |
3089 bIterator = DeserializeInteger (&n, 1, MAX_OBJECT_ID, bIterator); | 3668 bIterator = DeserializeInteger (&n, 1, MAX_OBJECT_ID, bIterator); |
3090 elem.measObjectId = n; | 3669 elem.measObjectId = n; |
3091 | 3670 |
3092 int measObjectChoice; | 3671 int measObjectChoice; |
3093 bIterator = DeserializeChoice (4, true, &measObjectChoice, bIterator); | 3672 bIterator = DeserializeChoice (4, true, &measObjectChoice, bIterator
); |
3094 | 3673 |
3095 switch (measObjectChoice) | 3674 switch (measObjectChoice) |
3096 { | 3675 { |
3097 case 1: | 3676 case 1: |
3098 // Deserialize measObjectUTRA | 3677 // Deserialize measObjectUTRA |
3099 // ... | 3678 // ... |
3100 break; | 3679 break; |
3101 | 3680 |
3102 case 2: | 3681 case 2: |
3103 // Deserialize measObjectGERAN | 3682 // Deserialize measObjectGERAN |
3104 // ... | 3683 // ... |
3105 break; | 3684 break; |
3106 | 3685 |
3107 case 3: | 3686 case 3: |
3108 // Deserialize measObjectCDMA2000 | 3687 // Deserialize measObjectCDMA2000 |
3109 // ... | 3688 // ... |
3110 break; | 3689 break; |
3111 | 3690 |
3112 case 0: | 3691 case 0: |
3113 default: | 3692 default: |
3114 // Deserialize measObjectEUTRA | 3693 // Deserialize measObjectEUTRA |
3115 std::bitset<5> measObjectEutraOpts; | 3694 std::bitset<5> measObjectEutraOpts; |
3116 bIterator = DeserializeSequence (&measObjectEutraOpts, true, bIter
ator); | 3695 bIterator = DeserializeSequence (&measObjectEutraOpts, true, bIt
erator); |
3117 | 3696 |
3118 // carrierFreq | 3697 // carrierFreq |
3119 bIterator = DeserializeInteger (&n, 0, MAX_EARFCN, bIterator); | 3698 bIterator = DeserializeInteger (&n, 0, MAX_EARFCN, bIterator); |
3120 elem.measObjectEutra.carrierFreq = n; | 3699 elem.measObjectEutra.carrierFreq = n; |
3121 | 3700 |
3122 // allowedMeasBandwidth | 3701 // allowedMeasBandwidth |
3123 bIterator = DeserializeEnum (6, &n, bIterator); | 3702 bIterator = DeserializeEnum (6, &n, bIterator); |
3124 switch (n) | 3703 switch (n) |
3125 { | 3704 { |
3126 case 0: | 3705 case 0: |
3127 elem.measObjectEutra.allowedMeasBandwidth = 6; | 3706 elem.measObjectEutra.allowedMeasBandwidth = 6; |
3128 break; | 3707 break; |
3129 case 1: | 3708 case 1: |
3130 elem.measObjectEutra.allowedMeasBandwidth = 15; | 3709 elem.measObjectEutra.allowedMeasBandwidth = 15; |
3131 break; | 3710 break; |
3132 case 2: | 3711 case 2: |
3133 elem.measObjectEutra.allowedMeasBandwidth = 25; | 3712 elem.measObjectEutra.allowedMeasBandwidth = 25; |
3134 break; | 3713 break; |
3135 case 3: | 3714 case 3: |
3136 elem.measObjectEutra.allowedMeasBandwidth = 50; | 3715 elem.measObjectEutra.allowedMeasBandwidth = 50; |
3137 break; | 3716 break; |
3138 case 4: | 3717 case 4: |
3139 elem.measObjectEutra.allowedMeasBandwidth = 75; | 3718 elem.measObjectEutra.allowedMeasBandwidth = 75; |
3140 break; | 3719 break; |
3141 case 5: | 3720 case 5: |
3142 default: | 3721 default: |
3143 elem.measObjectEutra.allowedMeasBandwidth = 100; | 3722 elem.measObjectEutra.allowedMeasBandwidth = 100; |
3144 break; | 3723 break; |
3145 } | 3724 } |
3146 | 3725 |
3147 // presenceAntennaPort1 | 3726 // presenceAntennaPort1 |
3148 bIterator = DeserializeBoolean (&elem.measObjectEutra.presenceAnte
nnaPort1, bIterator); | 3727 bIterator = DeserializeBoolean (&elem.measObjectEutra.presenceAn
tennaPort1, bIterator); |
3149 | 3728 |
3150 // neighCellConfig | 3729 // neighCellConfig |
3151 bIterator = DeserializeBitstring (&bitset2, bIterator); | 3730 bIterator = DeserializeBitstring (&bitset2, bIterator); |
3152 elem.measObjectEutra.neighCellConfig = bitset2.to_ulong (); | 3731 elem.measObjectEutra.neighCellConfig = bitset2.to_ulong (); |
3153 | 3732 |
3154 // offsetFreq | 3733 // offsetFreq |
3155 bIterator = DeserializeQoffsetRange (&elem.measObjectEutra.offsetF
req, bIterator); | 3734 bIterator = DeserializeQoffsetRange (&elem.measObjectEutra.offse
tFreq, bIterator); |
3156 | 3735 |
3157 if (measObjectEutraOpts[4]) | 3736 if (measObjectEutraOpts[4]) |
3158 { | 3737 { |
3159 // cellsToRemoveList | 3738 // cellsToRemoveList |
3160 int numElems; | 3739 int numElems; |
3161 bIterator = DeserializeSequenceOf (&numElems, MAX_CELL_MEAS, 1
, bIterator); | 3740 bIterator = DeserializeSequenceOf (&numElems, MAX_CELL_MEAS,
1, bIterator); |
3162 | 3741 |
3163 for (int i = 0; i < numElems; i++) | 3742 for (int i = 0; i < numElems; i++) |
3164 { | 3743 { |
3165 bIterator = DeserializeInteger (&n, 1, MAX_CELL_MEAS, bIte
rator); | 3744 bIterator = DeserializeInteger (&n, 1, MAX_CELL_MEAS, bI
terator); |
3166 elem.measObjectEutra.cellsToRemoveList.push_back (n); | 3745 elem.measObjectEutra.cellsToRemoveList.push_back (n); |
3167 } | 3746 } |
3168 } | 3747 } |
3169 | 3748 |
3170 if (measObjectEutraOpts[3]) | 3749 if (measObjectEutraOpts[3]) |
3171 { | 3750 { |
3172 // cellsToAddModList | 3751 // cellsToAddModList |
3173 int numElems; | 3752 int numElems; |
3174 bIterator = DeserializeSequenceOf (&numElems, MAX_CELL_MEAS, 1
, bIterator); | 3753 bIterator = DeserializeSequenceOf (&numElems, MAX_CELL_MEAS,
1, bIterator); |
3175 | 3754 |
3176 for (int i = 0; i < numElems; i++) | 3755 for (int i = 0; i < numElems; i++) |
3177 { | 3756 { |
3178 LteRrcSap::CellsToAddMod cellsToAddMod; | 3757 LteRrcSap::CellsToAddMod cellsToAddMod; |
3179 | 3758 |
3180 bIterator = DeserializeSequence (&bitset0, false, bIterato
r); | 3759 bIterator = DeserializeSequence (&bitset0, false, bItera
tor); |
3181 | 3760 |
3182 // cellIndex | 3761 // cellIndex |
3183 bIterator = DeserializeInteger (&n, 1, MAX_CELL_MEAS, bIte
rator); | 3762 bIterator = DeserializeInteger (&n, 1, MAX_CELL_MEAS, bI
terator); |
3184 cellsToAddMod.cellIndex = n; | 3763 cellsToAddMod.cellIndex = n; |
3185 | 3764 |
3186 // PhysCellId | 3765 // PhysCellId |
3187 bIterator = DeserializeInteger (&n, 0, 503, bIterator); | 3766 bIterator = DeserializeInteger (&n, 0, 503, bIterator); |
3188 cellsToAddMod.physCellId = n; | 3767 cellsToAddMod.physCellId = n; |
3189 | 3768 |
3190 // cellIndividualOffset | 3769 // cellIndividualOffset |
3191 bIterator = DeserializeQoffsetRange ( &cellsToAddMod.cellI
ndividualOffset, bIterator); | 3770 bIterator = DeserializeQoffsetRange ( &cellsToAddMod.cel
lIndividualOffset, bIterator); |
3192 | 3771 |
3193 elem.measObjectEutra.cellsToAddModList.push_back (cellsToA
ddMod); | 3772 elem.measObjectEutra.cellsToAddModList.push_back (cellsT
oAddMod); |
3194 } | 3773 } |
3195 } | 3774 } |
3196 | 3775 |
3197 if (measObjectEutraOpts[2]) | 3776 if (measObjectEutraOpts[2]) |
3198 { | 3777 { |
3199 // blackCellsToRemoveList | 3778 // blackCellsToRemoveList |
3200 int numElems; | 3779 int numElems; |
3201 bIterator = DeserializeSequenceOf (&numElems, MAX_CELL_MEAS, 1
, bIterator); | 3780 bIterator = DeserializeSequenceOf (&numElems, MAX_CELL_MEAS,
1, bIterator); |
3202 | 3781 |
3203 for (int i = 0; i < numElems; i++) | 3782 for (int i = 0; i < numElems; i++) |
3204 { | 3783 { |
3205 bIterator = DeserializeInteger (&n, 1, MAX_CELL_MEAS, bIte
rator); | 3784 bIterator = DeserializeInteger (&n, 1, MAX_CELL_MEAS, bI
terator); |
3206 elem.measObjectEutra.blackCellsToRemoveList.push_back (n); | 3785 elem.measObjectEutra.blackCellsToRemoveList.push_back (n
); |
3207 } | 3786 } |
3208 } | 3787 } |
3209 | 3788 |
3210 | 3789 |
3211 if (measObjectEutraOpts[1]) | 3790 if (measObjectEutraOpts[1]) |
3212 { | 3791 { |
3213 // blackCellsToAddModList | 3792 // blackCellsToAddModList |
3214 int numElems; | 3793 int numElems; |
3215 bIterator = DeserializeSequenceOf (&numElems, MAX_CELL_MEAS, 1
, bIterator); | 3794 bIterator = DeserializeSequenceOf (&numElems, MAX_CELL_MEAS,
1, bIterator); |
3216 | 3795 |
3217 for (int i = 0; i < numElems; i++) | 3796 for (int i = 0; i < numElems; i++) |
3218 { | 3797 { |
3219 LteRrcSap::BlackCellsToAddMod blackCellsToAddMod; | 3798 LteRrcSap::BlackCellsToAddMod blackCellsToAddMod; |
3220 bIterator = DeserializeSequence (&bitset0, false, bIterato
r); | 3799 bIterator = DeserializeSequence (&bitset0, false, bItera
tor); |
3221 | 3800 |
3222 bIterator = DeserializeInteger (&n, 1, MAX_CELL_MEAS, bIte
rator); | 3801 bIterator = DeserializeInteger (&n, 1, MAX_CELL_MEAS, bI
terator); |
3223 blackCellsToAddMod.cellIndex = n; | 3802 blackCellsToAddMod.cellIndex = n; |
3224 | 3803 |
3225 // PhysCellIdRange | 3804 // PhysCellIdRange |
3226 std::bitset<1> isRangePresent; | 3805 std::bitset<1> isRangePresent; |
3227 bIterator = DeserializeSequence (&isRangePresent, false, b
Iterator); | 3806 bIterator = DeserializeSequence (&isRangePresent, false,
bIterator); |
3228 | 3807 |
3229 // start | 3808 // start |
3230 bIterator = DeserializeInteger (&n, 0, 503, bIterator); | 3809 bIterator = DeserializeInteger (&n, 0, 503, bIterator); |
3231 blackCellsToAddMod.physCellIdRange.start = n; | 3810 blackCellsToAddMod.physCellIdRange.start = n; |
3232 | 3811 |
3233 blackCellsToAddMod.physCellIdRange.haveRange = isRangePres
ent[0]; | 3812 blackCellsToAddMod.physCellIdRange.haveRange = isRangePr
esent[0]; |
3234 // initialize range to silence compiler warning | 3813 // initialize range to silence compiler warning |
3235 blackCellsToAddMod.physCellIdRange.range = 0; | 3814 blackCellsToAddMod.physCellIdRange.range = 0; |
3236 if (blackCellsToAddMod.physCellIdRange.haveRange) | 3815 if (blackCellsToAddMod.physCellIdRange.haveRange) |
3237 { | 3816 { |
3238 // range | 3817 // range |
3239 bIterator = DeserializeEnum (16, &n, bIterator); | 3818 bIterator = DeserializeEnum (16, &n, bIterator); |
3240 switch (n) | 3819 switch (n) |
3241 { | 3820 { |
3242 case 0: | 3821 case 0: |
3243 blackCellsToAddMod.physCellIdRange.range = 4; | 3822 blackCellsToAddMod.physCellIdRange.range = 4; |
3244 break; | 3823 break; |
3245 case 1: | 3824 case 1: |
3246 blackCellsToAddMod.physCellIdRange.range = 8; | 3825 blackCellsToAddMod.physCellIdRange.range = 8; |
3247 break; | 3826 break; |
3248 case 2: | 3827 case 2: |
3249 blackCellsToAddMod.physCellIdRange.range = 12; | 3828 blackCellsToAddMod.physCellIdRange.range = 12; |
3250 break; | 3829 break; |
3251 case 3: | 3830 case 3: |
3252 blackCellsToAddMod.physCellIdRange.range = 16; | 3831 blackCellsToAddMod.physCellIdRange.range = 16; |
3253 break; | 3832 break; |
3254 case 4: | 3833 case 4: |
3255 blackCellsToAddMod.physCellIdRange.range = 24; | 3834 blackCellsToAddMod.physCellIdRange.range = 24; |
3256 break; | 3835 break; |
3257 case 5: | 3836 case 5: |
3258 blackCellsToAddMod.physCellIdRange.range = 32; | 3837 blackCellsToAddMod.physCellIdRange.range = 32; |
3259 break; | 3838 break; |
3260 case 6: | 3839 case 6: |
3261 blackCellsToAddMod.physCellIdRange.range = 48; | 3840 blackCellsToAddMod.physCellIdRange.range = 48; |
3262 break; | 3841 break; |
3263 case 7: | 3842 case 7: |
3264 blackCellsToAddMod.physCellIdRange.range = 64; | 3843 blackCellsToAddMod.physCellIdRange.range = 64; |
3265 break; | 3844 break; |
3266 case 8: | 3845 case 8: |
3267 blackCellsToAddMod.physCellIdRange.range = 84; | 3846 blackCellsToAddMod.physCellIdRange.range = 84; |
3268 break; | 3847 break; |
3269 case 9: | 3848 case 9: |
3270 blackCellsToAddMod.physCellIdRange.range = 96; | 3849 blackCellsToAddMod.physCellIdRange.range = 96; |
3271 break; | 3850 break; |
3272 case 10: | 3851 case 10: |
3273 blackCellsToAddMod.physCellIdRange.range = 128; | 3852 blackCellsToAddMod.physCellIdRange.range = 128; |
3274 break; | 3853 break; |
3275 case 11: | 3854 case 11: |
3276 blackCellsToAddMod.physCellIdRange.range = 168; | 3855 blackCellsToAddMod.physCellIdRange.range = 168; |
3277 break; | 3856 break; |
3278 case 12: | 3857 case 12: |
3279 blackCellsToAddMod.physCellIdRange.range = 252; | 3858 blackCellsToAddMod.physCellIdRange.range = 252; |
3280 break; | 3859 break; |
3281 case 13: | 3860 case 13: |
3282 blackCellsToAddMod.physCellIdRange.range = 504; | 3861 blackCellsToAddMod.physCellIdRange.range = 504; |
3283 break; | 3862 break; |
3284 default: | 3863 default: |
3285 blackCellsToAddMod.physCellIdRange.range = 0; | 3864 blackCellsToAddMod.physCellIdRange.range = 0; |
3286 } | 3865 } |
3287 } | 3866 } |
3288 | 3867 |
3289 elem.measObjectEutra.blackCellsToAddModList.push_back (bla
ckCellsToAddMod); | 3868 elem.measObjectEutra.blackCellsToAddModList.push_back (b
lackCellsToAddMod); |
3290 } | 3869 } |
3291 } | 3870 } |
3292 | 3871 |
3293 elem.measObjectEutra.haveCellForWhichToReportCGI = measObjectEutra
Opts[0]; | 3872 elem.measObjectEutra.haveCellForWhichToReportCGI = measObjectEut
raOpts[0]; |
3294 if (measObjectEutraOpts[0]) | 3873 if (measObjectEutraOpts[0]) |
3295 { | 3874 { |
3296 // cellForWhichToReportCGI | 3875 // cellForWhichToReportCGI |
3297 bIterator = DeserializeInteger (&n, 0, 503, bIterator); | 3876 bIterator = DeserializeInteger (&n, 0, 503, bIterator); |
3298 elem.measObjectEutra.cellForWhichToReportCGI = n; | 3877 elem.measObjectEutra.cellForWhichToReportCGI = n; |
3299 } | 3878 } |
3300 } | 3879 } |
3301 measConfig->measObjectToAddModList.push_back (elem); | 3880 measConfig->measObjectToAddModList.push_back (elem); |
3302 } | 3881 } |
3303 } | 3882 } |
3304 | 3883 |
3305 if (bitset11[8]) | 3884 if (bitset11[8]) |
3306 { | 3885 { |
3307 // reportConfigToRemoveList | 3886 // reportConfigToRemoveList |
3308 int reportConfigToRemoveListElems; | 3887 int reportConfigToRemoveListElems; |
3309 bIterator = DeserializeSequenceOf (&reportConfigToRemoveListElems, MAX_REP
ORT_CONFIG_ID, 1, bIterator); | 3888 bIterator = DeserializeSequenceOf (&reportConfigToRemoveListElems, MAX_R
EPORT_CONFIG_ID, 1, bIterator); |
3310 | 3889 |
3311 for (int i = 0; i < reportConfigToRemoveListElems; i++) | 3890 for (int i = 0; i < reportConfigToRemoveListElems; i++) |
3312 { | 3891 { |
3313 bIterator = DeserializeInteger (&n, 1, MAX_REPORT_CONFIG_ID, bIterator
); | 3892 bIterator = DeserializeInteger (&n, 1, MAX_REPORT_CONFIG_ID, bIterat
or); |
3314 measConfig->reportConfigToRemoveList.push_back (n); | 3893 measConfig->reportConfigToRemoveList.push_back (n); |
3315 } | 3894 } |
3316 } | 3895 } |
3317 | 3896 |
3318 if (bitset11[7]) | 3897 if (bitset11[7]) |
3319 { | 3898 { |
3320 // reportConfigToAddModList | 3899 // reportConfigToAddModList |
3321 int reportConfigToAddModListElems; | 3900 int reportConfigToAddModListElems; |
3322 bIterator = DeserializeSequenceOf (&reportConfigToAddModListElems, MAX_REP
ORT_CONFIG_ID, 1, bIterator); | 3901 bIterator = DeserializeSequenceOf (&reportConfigToAddModListElems, MAX_R
EPORT_CONFIG_ID, 1, bIterator); |
3323 | 3902 |
3324 for (int i = 0; i < reportConfigToAddModListElems; i++) | 3903 for (int i = 0; i < reportConfigToAddModListElems; i++) |
3325 { | 3904 { |
3326 LteRrcSap::ReportConfigToAddMod elem; | 3905 LteRrcSap::ReportConfigToAddMod elem; |
3327 | 3906 |
3328 bIterator = DeserializeSequence (&bitset0, false, bIterator); | 3907 bIterator = DeserializeSequence (&bitset0, false, bIterator); |
3329 bIterator = DeserializeInteger (&n, 1, MAX_REPORT_CONFIG_ID, bIterator
); | 3908 bIterator = DeserializeInteger (&n, 1, MAX_REPORT_CONFIG_ID, bIterat
or); |
3330 elem.reportConfigId = n; | 3909 elem.reportConfigId = n; |
3331 | 3910 |
3332 // Deserialize reportConfig | 3911 // Deserialize reportConfig |
3333 int reportConfigChoice; | 3912 int reportConfigChoice; |
3334 bIterator = DeserializeChoice (2, false, &reportConfigChoice, bIterato
r); | 3913 bIterator = DeserializeChoice (2, false, &reportConfigChoice, bItera
tor); |
3335 | 3914 |
3336 if (reportConfigChoice == 0) | 3915 if (reportConfigChoice == 0) |
3337 { | 3916 { |
3338 // reportConfigEUTRA | 3917 // reportConfigEUTRA |
3339 bIterator = DeserializeSequence (&bitset0, true, bIterator); | 3918 bIterator = DeserializeSequence (&bitset0, true, bIterator); |
3340 | 3919 |
3341 // triggerType | 3920 // triggerType |
3342 int triggerTypeChoice; | 3921 int triggerTypeChoice; |
3343 bIterator = DeserializeChoice (2, false, &triggerTypeChoice, bIter
ator); | 3922 bIterator = DeserializeChoice (2, false, &triggerTypeChoice, bIt
erator); |
3344 | 3923 |
3345 if (triggerTypeChoice == 0) | 3924 if (triggerTypeChoice == 0) |
3346 { | 3925 { |
3347 // event | 3926 // event |
3348 elem.reportConfigEutra.triggerType = LteRrcSap::ReportConfigEu
tra::EVENT; | 3927 elem.reportConfigEutra.triggerType = LteRrcSap::ReportConfig
Eutra::EVENT; |
3349 bIterator = DeserializeSequence (&bitset0, false, bIterator); | 3928 bIterator = DeserializeSequence (&bitset0, false, bIterator)
; |
3350 | 3929 |
3351 // eventId | 3930 // eventId |
3352 int eventIdChoice; | 3931 int eventIdChoice; |
3353 bIterator = DeserializeChoice (5, true, &eventIdChoice, bItera
tor); | 3932 bIterator = DeserializeChoice (5, true, &eventIdChoice, bIte
rator); |
3354 | 3933 |
3355 switch (eventIdChoice) | 3934 switch (eventIdChoice) |
3356 { | 3935 { |
3357 case 0: | 3936 case 0: |
3358 elem.reportConfigEutra.eventId = LteRrcSap::ReportConfigEu
tra::EVENT_A1; | 3937 elem.reportConfigEutra.eventId = LteRrcSap::ReportConfig
Eutra::EVENT_A1; |
3359 bIterator = DeserializeSequence (&bitset0, false, bIterato
r); | 3938 bIterator = DeserializeSequence (&bitset0, false, bItera
tor); |
3360 bIterator = DeserializeThresholdEutra (&elem.reportConfigE
utra.threshold1, bIterator); | 3939 bIterator = DeserializeThresholdEutra (&elem.reportConfi
gEutra.threshold1, bIterator); |
3361 break; | 3940 break; |
3362 | 3941 |
3363 case 1: | 3942 case 1: |
3364 elem.reportConfigEutra.eventId = LteRrcSap::ReportConfigEu
tra::EVENT_A2; | 3943 elem.reportConfigEutra.eventId = LteRrcSap::ReportConfig
Eutra::EVENT_A2; |
3365 bIterator = DeserializeSequence (&bitset0, false, bIterato
r); | 3944 bIterator = DeserializeSequence (&bitset0, false, bItera
tor); |
3366 bIterator = DeserializeThresholdEutra (&elem.reportConfigE
utra.threshold1, bIterator); | 3945 bIterator = DeserializeThresholdEutra (&elem.reportConfi
gEutra.threshold1, bIterator); |
3367 break; | 3946 break; |
3368 | 3947 |
3369 case 2: | 3948 case 2: |
3370 elem.reportConfigEutra.eventId = LteRrcSap::ReportConfigEu
tra::EVENT_A3; | 3949 elem.reportConfigEutra.eventId = LteRrcSap::ReportConfig
Eutra::EVENT_A3; |
3371 bIterator = DeserializeSequence (&bitset0, false, bIterato
r); | 3950 bIterator = DeserializeSequence (&bitset0, false, bItera
tor); |
3372 bIterator = DeserializeInteger (&n, -30, 30, bIterator); | 3951 bIterator = DeserializeInteger (&n, -30, 30, bIterator); |
3373 elem.reportConfigEutra.a3Offset = n; | 3952 elem.reportConfigEutra.a3Offset = n; |
3374 bIterator = DeserializeBoolean (&elem.reportConfigEutra.re
portOnLeave, bIterator); | 3953 bIterator = DeserializeBoolean (&elem.reportConfigEutra.
reportOnLeave, bIterator); |
3375 break; | 3954 break; |
3376 | 3955 |
3377 case 3: | 3956 case 3: |
3378 elem.reportConfigEutra.eventId = LteRrcSap::ReportConfigEu
tra::EVENT_A4; | 3957 elem.reportConfigEutra.eventId = LteRrcSap::ReportConfig
Eutra::EVENT_A4; |
3379 bIterator = DeserializeSequence (&bitset0, false, bIterato
r); | 3958 bIterator = DeserializeSequence (&bitset0, false, bItera
tor); |
3380 bIterator = DeserializeThresholdEutra (&elem.reportConfigE
utra.threshold1, bIterator); | 3959 bIterator = DeserializeThresholdEutra (&elem.reportConfi
gEutra.threshold1, bIterator); |
3381 break; | 3960 break; |
3382 | 3961 |
3383 case 4: | 3962 case 4: |
3384 default: | 3963 default: |
3385 elem.reportConfigEutra.eventId = LteRrcSap::ReportConfigEu
tra::EVENT_A5; | 3964 elem.reportConfigEutra.eventId = LteRrcSap::ReportConfig
Eutra::EVENT_A5; |
3386 bIterator = DeserializeSequence (&bitset0, false, bIterato
r); | 3965 bIterator = DeserializeSequence (&bitset0, false, bItera
tor); |
3387 bIterator = DeserializeThresholdEutra (&elem.reportConfigE
utra.threshold1, bIterator); | 3966 bIterator = DeserializeThresholdEutra (&elem.reportConfi
gEutra.threshold1, bIterator); |
3388 bIterator = DeserializeThresholdEutra (&elem.reportConfigE
utra.threshold2, bIterator); | 3967 bIterator = DeserializeThresholdEutra (&elem.reportConfi
gEutra.threshold2, bIterator); |
3389 } | 3968 } |
3390 | 3969 |
3391 bIterator = DeserializeInteger (&n, 0, 30, bIterator); | 3970 bIterator = DeserializeInteger (&n, 0, 30, bIterator); |
3392 elem.reportConfigEutra.hysteresis = n; | 3971 elem.reportConfigEutra.hysteresis = n; |
3393 | 3972 |
3394 bIterator = DeserializeEnum (16, &n, bIterator); | 3973 bIterator = DeserializeEnum (16, &n, bIterator); |
3395 switch (n) | 3974 switch (n) |
3396 { | 3975 { |
3397 case 0: | 3976 case 0: |
3398 elem.reportConfigEutra.timeToTrigger = 0; | 3977 elem.reportConfigEutra.timeToTrigger = 0; |
3399 break; | 3978 break; |
3400 case 1: | 3979 case 1: |
3401 elem.reportConfigEutra.timeToTrigger = 40; | 3980 elem.reportConfigEutra.timeToTrigger = 40; |
3402 break; | 3981 break; |
3403 case 2: | 3982 case 2: |
3404 elem.reportConfigEutra.timeToTrigger = 64; | 3983 elem.reportConfigEutra.timeToTrigger = 64; |
3405 break; | 3984 break; |
3406 case 3: | 3985 case 3: |
3407 elem.reportConfigEutra.timeToTrigger = 80; | 3986 elem.reportConfigEutra.timeToTrigger = 80; |
3408 break; | 3987 break; |
3409 case 4: | 3988 case 4: |
3410 elem.reportConfigEutra.timeToTrigger = 100; | 3989 elem.reportConfigEutra.timeToTrigger = 100; |
3411 break; | 3990 break; |
3412 case 5: | 3991 case 5: |
3413 elem.reportConfigEutra.timeToTrigger = 128; | 3992 elem.reportConfigEutra.timeToTrigger = 128; |
3414 break; | 3993 break; |
3415 case 6: | 3994 case 6: |
3416 elem.reportConfigEutra.timeToTrigger = 160; | 3995 elem.reportConfigEutra.timeToTrigger = 160; |
3417 break; | 3996 break; |
3418 case 7: | 3997 case 7: |
3419 elem.reportConfigEutra.timeToTrigger = 256; | 3998 elem.reportConfigEutra.timeToTrigger = 256; |
3420 break; | 3999 break; |
3421 case 8: | 4000 case 8: |
3422 elem.reportConfigEutra.timeToTrigger = 320; | 4001 elem.reportConfigEutra.timeToTrigger = 320; |
3423 break; | 4002 break; |
3424 case 9: | 4003 case 9: |
3425 elem.reportConfigEutra.timeToTrigger = 480; | 4004 elem.reportConfigEutra.timeToTrigger = 480; |
3426 break; | 4005 break; |
3427 case 10: | 4006 case 10: |
3428 elem.reportConfigEutra.timeToTrigger = 512; | 4007 elem.reportConfigEutra.timeToTrigger = 512; |
3429 break; | 4008 break; |
3430 case 11: | 4009 case 11: |
3431 elem.reportConfigEutra.timeToTrigger = 640; | 4010 elem.reportConfigEutra.timeToTrigger = 640; |
3432 break; | 4011 break; |
3433 case 12: | 4012 case 12: |
3434 elem.reportConfigEutra.timeToTrigger = 1024; | 4013 elem.reportConfigEutra.timeToTrigger = 1024; |
3435 break; | 4014 break; |
3436 case 13: | 4015 case 13: |
3437 elem.reportConfigEutra.timeToTrigger = 1280; | 4016 elem.reportConfigEutra.timeToTrigger = 1280; |
3438 break; | 4017 break; |
3439 case 14: | 4018 case 14: |
3440 elem.reportConfigEutra.timeToTrigger = 2560; | 4019 elem.reportConfigEutra.timeToTrigger = 2560; |
3441 break; | 4020 break; |
3442 case 15: | 4021 case 15: |
3443 default: | 4022 default: |
3444 elem.reportConfigEutra.timeToTrigger = 5120; | 4023 elem.reportConfigEutra.timeToTrigger = 5120; |
3445 break; | 4024 break; |
3446 } | 4025 } |
3447 } | 4026 } |
3448 | 4027 |
3449 if (triggerTypeChoice == 1) | 4028 if (triggerTypeChoice == 1) |
3450 { | 4029 { |
3451 // periodical | 4030 // periodical |
3452 elem.reportConfigEutra.triggerType = LteRrcSap::ReportConfigEu
tra::PERIODICAL; | 4031 elem.reportConfigEutra.triggerType = LteRrcSap::ReportConfig
Eutra::PERIODICAL; |
3453 | 4032 |
3454 bIterator = DeserializeSequence (&bitset0, false, bIterator); | 4033 bIterator = DeserializeSequence (&bitset0, false, bIterator)
; |
3455 bIterator = DeserializeEnum (2, &n, bIterator); | 4034 bIterator = DeserializeEnum (2, &n, bIterator); |
3456 if (n == 0) | 4035 if (n == 0) |
3457 { | 4036 { |
3458 elem.reportConfigEutra.purpose = LteRrcSap::ReportConfigEu
tra::REPORT_STRONGEST_CELLS; | 4037 elem.reportConfigEutra.purpose = LteRrcSap::ReportConfig
Eutra::REPORT_STRONGEST_CELLS; |
3459 } | 4038 } |
3460 else | 4039 else |
3461 { | 4040 { |
3462 elem.reportConfigEutra.purpose = LteRrcSap::ReportConfigEu
tra::REPORT_CGI; | 4041 elem.reportConfigEutra.purpose = LteRrcSap::ReportConfig
Eutra::REPORT_CGI; |
3463 } | 4042 } |
3464 } | 4043 } |
3465 | 4044 |
3466 // triggerQuantity | 4045 // triggerQuantity |
3467 bIterator = DeserializeEnum (2, &n, bIterator); | 4046 bIterator = DeserializeEnum (2, &n, bIterator); |
3468 if (n == 0) | 4047 if (n == 0) |
3469 { | 4048 { |
3470 elem.reportConfigEutra.triggerQuantity = LteRrcSap::ReportConf
igEutra::RSRP; | 4049 elem.reportConfigEutra.triggerQuantity = LteRrcSap::ReportCo
nfigEutra::RSRP; |
3471 } | 4050 } |
3472 else | 4051 else |
3473 { | 4052 { |
3474 elem.reportConfigEutra.triggerQuantity = LteRrcSap::ReportConf
igEutra::RSRQ; | 4053 elem.reportConfigEutra.triggerQuantity = LteRrcSap::ReportCo
nfigEutra::RSRQ; |
3475 } | 4054 } |
3476 | 4055 |
3477 // reportQuantity | 4056 // reportQuantity |
3478 bIterator = DeserializeEnum (2, &n, bIterator); | 4057 bIterator = DeserializeEnum (2, &n, bIterator); |
3479 if (n == 0) | 4058 if (n == 0) |
3480 { | 4059 { |
3481 elem.reportConfigEutra.reportQuantity = LteRrcSap::ReportConfi
gEutra::SAME_AS_TRIGGER_QUANTITY; | 4060 elem.reportConfigEutra.reportQuantity = LteRrcSap::ReportCon
figEutra::SAME_AS_TRIGGER_QUANTITY; |
3482 } | 4061 } |
3483 else | 4062 else |
3484 { | 4063 { |
3485 elem.reportConfigEutra.reportQuantity = LteRrcSap::ReportConfi
gEutra::BOTH; | 4064 elem.reportConfigEutra.reportQuantity = LteRrcSap::ReportCon
figEutra::BOTH; |
3486 } | 4065 } |
3487 | 4066 |
3488 // maxReportCells | 4067 // maxReportCells |
3489 bIterator = DeserializeInteger (&n, 1, MAX_CELL_REPORT, bIterator)
; | 4068 bIterator = DeserializeInteger (&n, 1, MAX_CELL_REPORT, bIterato
r); |
3490 elem.reportConfigEutra.maxReportCells = n; | 4069 elem.reportConfigEutra.maxReportCells = n; |
3491 | 4070 |
3492 // reportInterval | 4071 // reportInterval |
3493 bIterator = DeserializeEnum (16, &n, bIterator); | 4072 bIterator = DeserializeEnum (16, &n, bIterator); |
3494 switch (n) | 4073 switch (n) |
3495 { | 4074 { |
3496 case 0: | 4075 case 0: |
3497 elem.reportConfigEutra.reportInterval = LteRrcSap::ReportConfi
gEutra::MS120; | 4076 elem.reportConfigEutra.reportInterval = LteRrcSap::ReportCon
figEutra::MS120; |
3498 break; | 4077 break; |
3499 case 1: | 4078 case 1: |
3500 elem.reportConfigEutra.reportInterval = LteRrcSap::ReportConfi
gEutra::MS240; | 4079 elem.reportConfigEutra.reportInterval = LteRrcSap::ReportCon
figEutra::MS240; |
3501 break; | 4080 break; |
3502 case 2: | 4081 case 2: |
3503 elem.reportConfigEutra.reportInterval = LteRrcSap::ReportConfi
gEutra::MS480; | 4082 elem.reportConfigEutra.reportInterval = LteRrcSap::ReportCon
figEutra::MS480; |
3504 break; | 4083 break; |
3505 case 3: | 4084 case 3: |
3506 elem.reportConfigEutra.reportInterval = LteRrcSap::ReportConfi
gEutra::MS640; | 4085 elem.reportConfigEutra.reportInterval = LteRrcSap::ReportCon
figEutra::MS640; |
3507 break; | 4086 break; |
3508 case 4: | 4087 case 4: |
3509 elem.reportConfigEutra.reportInterval = LteRrcSap::ReportConfi
gEutra::MS1024; | 4088 elem.reportConfigEutra.reportInterval = LteRrcSap::ReportCon
figEutra::MS1024; |
3510 break; | 4089 break; |
3511 case 5: | 4090 case 5: |
3512 elem.reportConfigEutra.reportInterval = LteRrcSap::ReportConfi
gEutra::MS2048; | 4091 elem.reportConfigEutra.reportInterval = LteRrcSap::ReportCon
figEutra::MS2048; |
3513 break; | 4092 break; |
3514 case 6: | 4093 case 6: |
3515 elem.reportConfigEutra.reportInterval = LteRrcSap::ReportConfi
gEutra::MS5120; | 4094 elem.reportConfigEutra.reportInterval = LteRrcSap::ReportCon
figEutra::MS5120; |
3516 break; | 4095 break; |
3517 case 7: | 4096 case 7: |
3518 elem.reportConfigEutra.reportInterval = LteRrcSap::ReportConfi
gEutra::MS10240; | 4097 elem.reportConfigEutra.reportInterval = LteRrcSap::ReportCon
figEutra::MS10240; |
3519 break; | 4098 break; |
3520 case 8: | 4099 case 8: |
3521 elem.reportConfigEutra.reportInterval = LteRrcSap::ReportConfi
gEutra::MIN1; | 4100 elem.reportConfigEutra.reportInterval = LteRrcSap::ReportCon
figEutra::MIN1; |
3522 break; | 4101 break; |
3523 case 9: | 4102 case 9: |
3524 elem.reportConfigEutra.reportInterval = LteRrcSap::ReportConfi
gEutra::MIN6; | 4103 elem.reportConfigEutra.reportInterval = LteRrcSap::ReportCon
figEutra::MIN6; |
3525 break; | 4104 break; |
3526 case 10: | 4105 case 10: |
3527 elem.reportConfigEutra.reportInterval = LteRrcSap::ReportConfi
gEutra::MIN12; | 4106 elem.reportConfigEutra.reportInterval = LteRrcSap::ReportCon
figEutra::MIN12; |
3528 break; | 4107 break; |
3529 case 11: | 4108 case 11: |
3530 elem.reportConfigEutra.reportInterval = LteRrcSap::ReportConfi
gEutra::MIN30; | 4109 elem.reportConfigEutra.reportInterval = LteRrcSap::ReportCon
figEutra::MIN30; |
3531 break; | 4110 break; |
3532 case 12: | 4111 case 12: |
3533 elem.reportConfigEutra.reportInterval = LteRrcSap::ReportConfi
gEutra::MIN60; | 4112 elem.reportConfigEutra.reportInterval = LteRrcSap::ReportCon
figEutra::MIN60; |
3534 break; | 4113 break; |
3535 case 13: | 4114 case 13: |
3536 elem.reportConfigEutra.reportInterval = LteRrcSap::ReportConfi
gEutra::SPARE3; | 4115 elem.reportConfigEutra.reportInterval = LteRrcSap::ReportCon
figEutra::SPARE3; |
3537 break; | 4116 break; |
3538 case 14: | 4117 case 14: |
3539 elem.reportConfigEutra.reportInterval = LteRrcSap::ReportConfi
gEutra::SPARE2; | 4118 elem.reportConfigEutra.reportInterval = LteRrcSap::ReportCon
figEutra::SPARE2; |
3540 break; | 4119 break; |
3541 case 15: | 4120 case 15: |
3542 default: | 4121 default: |
3543 elem.reportConfigEutra.reportInterval = LteRrcSap::ReportConfi
gEutra::SPARE1; | 4122 elem.reportConfigEutra.reportInterval = LteRrcSap::ReportCon
figEutra::SPARE1; |
3544 } | 4123 } |
3545 | 4124 |
3546 // reportAmount | 4125 // reportAmount |
3547 bIterator = DeserializeEnum (8, &n, bIterator); | 4126 bIterator = DeserializeEnum (8, &n, bIterator); |
3548 switch (n) | 4127 switch (n) |
3549 { | 4128 { |
3550 case 0: | 4129 case 0: |
3551 elem.reportConfigEutra.reportAmount = 1; | 4130 elem.reportConfigEutra.reportAmount = 1; |
3552 break; | 4131 break; |
3553 case 1: | 4132 case 1: |
3554 elem.reportConfigEutra.reportAmount = 2; | 4133 elem.reportConfigEutra.reportAmount = 2; |
3555 break; | 4134 break; |
3556 case 2: | 4135 case 2: |
3557 elem.reportConfigEutra.reportAmount = 4; | 4136 elem.reportConfigEutra.reportAmount = 4; |
3558 break; | 4137 break; |
3559 case 3: | 4138 case 3: |
3560 elem.reportConfigEutra.reportAmount = 8; | 4139 elem.reportConfigEutra.reportAmount = 8; |
3561 break; | 4140 break; |
3562 case 4: | 4141 case 4: |
3563 elem.reportConfigEutra.reportAmount = 16; | 4142 elem.reportConfigEutra.reportAmount = 16; |
3564 break; | 4143 break; |
3565 case 5: | 4144 case 5: |
3566 elem.reportConfigEutra.reportAmount = 32; | 4145 elem.reportConfigEutra.reportAmount = 32; |
3567 break; | 4146 break; |
3568 case 6: | 4147 case 6: |
3569 elem.reportConfigEutra.reportAmount = 64; | 4148 elem.reportConfigEutra.reportAmount = 64; |
3570 break; | 4149 break; |
3571 default: | 4150 default: |
3572 elem.reportConfigEutra.reportAmount = 0; | 4151 elem.reportConfigEutra.reportAmount = 0; |
3573 } | 4152 } |
3574 } | 4153 } |
3575 | 4154 |
3576 if (reportConfigChoice == 1) | 4155 if (reportConfigChoice == 1) |
3577 { | 4156 { |
3578 // ReportConfigInterRAT | 4157 // ReportConfigInterRAT |
3579 // ... | 4158 // ... |
3580 } | 4159 } |
3581 | 4160 |
3582 measConfig->reportConfigToAddModList.push_back (elem); | 4161 measConfig->reportConfigToAddModList.push_back (elem); |
3583 } | 4162 } |
3584 } | 4163 } |
3585 | 4164 |
3586 if (bitset11[6]) | 4165 if (bitset11[6]) |
3587 { | 4166 { |
3588 // measIdToRemoveList | 4167 // measIdToRemoveList |
3589 int measIdToRemoveListElems; | 4168 int measIdToRemoveListElems; |
3590 bIterator = DeserializeSequenceOf (&measIdToRemoveListElems, MAX_MEAS_ID,
1, bIterator); | 4169 bIterator = DeserializeSequenceOf (&measIdToRemoveListElems, MAX_MEAS_ID
, 1, bIterator); |
3591 | 4170 |
3592 for (int i = 0; i < measIdToRemoveListElems; i++) | 4171 for (int i = 0; i < measIdToRemoveListElems; i++) |
3593 { | 4172 { |
3594 bIterator = DeserializeInteger (&n, 1, MAX_MEAS_ID, bIterator); | 4173 bIterator = DeserializeInteger (&n, 1, MAX_MEAS_ID, bIterator); |
3595 measConfig->measIdToRemoveList.push_back (n); | 4174 measConfig->measIdToRemoveList.push_back (n); |
3596 } | 4175 } |
3597 } | 4176 } |
3598 | 4177 |
3599 if (bitset11[5]) | 4178 if (bitset11[5]) |
3600 { | 4179 { |
3601 // measIdToAddModList | 4180 // measIdToAddModList |
3602 int measIdToAddModListElems; | 4181 int measIdToAddModListElems; |
3603 bIterator = DeserializeSequenceOf (&measIdToAddModListElems, MAX_MEAS_ID,
1, bIterator); | 4182 bIterator = DeserializeSequenceOf (&measIdToAddModListElems, MAX_MEAS_ID
, 1, bIterator); |
3604 | 4183 |
3605 for (int i = 0; i < measIdToAddModListElems; i++) | 4184 for (int i = 0; i < measIdToAddModListElems; i++) |
3606 { | 4185 { |
3607 LteRrcSap::MeasIdToAddMod elem; | 4186 LteRrcSap::MeasIdToAddMod elem; |
3608 | 4187 |
3609 bIterator = DeserializeSequence (&bitset0, false, bIterator); | 4188 bIterator = DeserializeSequence (&bitset0, false, bIterator); |
3610 | 4189 |
3611 bIterator = DeserializeInteger (&n, 1, MAX_MEAS_ID, bIterator); | 4190 bIterator = DeserializeInteger (&n, 1, MAX_MEAS_ID, bIterator); |
3612 elem.measId = n; | 4191 elem.measId = n; |
3613 | 4192 |
3614 bIterator = DeserializeInteger (&n, 1, MAX_OBJECT_ID, bIterator); | 4193 bIterator = DeserializeInteger (&n, 1, MAX_OBJECT_ID, bIterator); |
3615 elem.measObjectId = n; | 4194 elem.measObjectId = n; |
3616 | 4195 |
3617 bIterator = DeserializeInteger (&n, 1, MAX_REPORT_CONFIG_ID, bIterator
); | 4196 bIterator = DeserializeInteger (&n, 1, MAX_REPORT_CONFIG_ID, bIterat
or); |
3618 elem.reportConfigId = n; | 4197 elem.reportConfigId = n; |
3619 | 4198 |
3620 measConfig->measIdToAddModList.push_back (elem); | 4199 measConfig->measIdToAddModList.push_back (elem); |
3621 } | 4200 } |
3622 } | 4201 } |
3623 | 4202 |
3624 measConfig->haveQuantityConfig = bitset11[4]; | 4203 measConfig->haveQuantityConfig = bitset11[4]; |
3625 if (measConfig->haveQuantityConfig) | 4204 if (measConfig->haveQuantityConfig) |
3626 { | 4205 { |
3627 // quantityConfig | 4206 // quantityConfig |
3628 std::bitset<4> quantityConfigOpts; | 4207 std::bitset<4> quantityConfigOpts; |
3629 bIterator = DeserializeSequence (&quantityConfigOpts, true, bIterator); | 4208 bIterator = DeserializeSequence (&quantityConfigOpts, true, bIterator); |
3630 | 4209 |
3631 if (quantityConfigOpts[3]) | 4210 if (quantityConfigOpts[3]) |
3632 { | 4211 { |
3633 // quantityConfigEUTRA | 4212 // quantityConfigEUTRA |
3634 bIterator = DeserializeSequence (&bitset0,false,bIterator); | 4213 bIterator = DeserializeSequence (&bitset0,false,bIterator); |
3635 bIterator = DeserializeEnum (16, &n, bIterator); | 4214 bIterator = DeserializeEnum (16, &n, bIterator); |
3636 switch (n) | 4215 switch (n) |
3637 { | 4216 { |
3638 case 0: | 4217 case 0: |
3639 measConfig->quantityConfig.filterCoefficientRSRP = 0; | 4218 measConfig->quantityConfig.filterCoefficientRSRP = 0; |
3640 break; | 4219 break; |
3641 case 1: | 4220 case 1: |
3642 measConfig->quantityConfig.filterCoefficientRSRP = 1; | 4221 measConfig->quantityConfig.filterCoefficientRSRP = 1; |
3643 break; | 4222 break; |
3644 case 2: | 4223 case 2: |
3645 measConfig->quantityConfig.filterCoefficientRSRP = 2; | 4224 measConfig->quantityConfig.filterCoefficientRSRP = 2; |
3646 break; | 4225 break; |
3647 case 3: | 4226 case 3: |
3648 measConfig->quantityConfig.filterCoefficientRSRP = 3; | 4227 measConfig->quantityConfig.filterCoefficientRSRP = 3; |
3649 break; | 4228 break; |
3650 case 4: | 4229 case 4: |
3651 measConfig->quantityConfig.filterCoefficientRSRP = 4; | 4230 measConfig->quantityConfig.filterCoefficientRSRP = 4; |
3652 break; | 4231 break; |
3653 case 5: | 4232 case 5: |
3654 measConfig->quantityConfig.filterCoefficientRSRP = 5; | 4233 measConfig->quantityConfig.filterCoefficientRSRP = 5; |
3655 break; | 4234 break; |
3656 case 6: | 4235 case 6: |
3657 measConfig->quantityConfig.filterCoefficientRSRP = 6; | 4236 measConfig->quantityConfig.filterCoefficientRSRP = 6; |
3658 break; | 4237 break; |
3659 case 7: | 4238 case 7: |
3660 measConfig->quantityConfig.filterCoefficientRSRP = 7; | 4239 measConfig->quantityConfig.filterCoefficientRSRP = 7; |
3661 break; | 4240 break; |
3662 case 8: | 4241 case 8: |
3663 measConfig->quantityConfig.filterCoefficientRSRP = 8; | 4242 measConfig->quantityConfig.filterCoefficientRSRP = 8; |
3664 break; | 4243 break; |
3665 case 9: | 4244 case 9: |
3666 measConfig->quantityConfig.filterCoefficientRSRP = 9; | 4245 measConfig->quantityConfig.filterCoefficientRSRP = 9; |
3667 break; | 4246 break; |
3668 case 10: | 4247 case 10: |
3669 measConfig->quantityConfig.filterCoefficientRSRP = 11; | 4248 measConfig->quantityConfig.filterCoefficientRSRP = 11; |
3670 break; | 4249 break; |
3671 case 11: | 4250 case 11: |
3672 measConfig->quantityConfig.filterCoefficientRSRP = 13; | 4251 measConfig->quantityConfig.filterCoefficientRSRP = 13; |
3673 break; | 4252 break; |
3674 case 12: | 4253 case 12: |
3675 measConfig->quantityConfig.filterCoefficientRSRP = 15; | 4254 measConfig->quantityConfig.filterCoefficientRSRP = 15; |
3676 break; | 4255 break; |
3677 case 13: | 4256 case 13: |
3678 measConfig->quantityConfig.filterCoefficientRSRP = 17; | 4257 measConfig->quantityConfig.filterCoefficientRSRP = 17; |
3679 break; | 4258 break; |
3680 case 14: | 4259 case 14: |
3681 measConfig->quantityConfig.filterCoefficientRSRP = 19; | 4260 measConfig->quantityConfig.filterCoefficientRSRP = 19; |
3682 break; | 4261 break; |
3683 case 15: | 4262 case 15: |
3684 measConfig->quantityConfig.filterCoefficientRSRP = 0; | 4263 measConfig->quantityConfig.filterCoefficientRSRP = 0; |
3685 break; | 4264 break; |
3686 default: | 4265 default: |
3687 measConfig->quantityConfig.filterCoefficientRSRP = 4; | 4266 measConfig->quantityConfig.filterCoefficientRSRP = 4; |
3688 } | 4267 } |
3689 bIterator = DeserializeEnum (16, &n, bIterator); | 4268 bIterator = DeserializeEnum (16, &n, bIterator); |
3690 switch (n) | 4269 switch (n) |
3691 { | 4270 { |
3692 case 0: | 4271 case 0: |
3693 measConfig->quantityConfig.filterCoefficientRSRQ = 0; | 4272 measConfig->quantityConfig.filterCoefficientRSRQ = 0; |
3694 break; | 4273 break; |
3695 case 1: | 4274 case 1: |
3696 measConfig->quantityConfig.filterCoefficientRSRQ = 1; | 4275 measConfig->quantityConfig.filterCoefficientRSRQ = 1; |
3697 break; | 4276 break; |
3698 case 2: | 4277 case 2: |
3699 measConfig->quantityConfig.filterCoefficientRSRQ = 2; | 4278 measConfig->quantityConfig.filterCoefficientRSRQ = 2; |
3700 break; | 4279 break; |
3701 case 3: | 4280 case 3: |
3702 measConfig->quantityConfig.filterCoefficientRSRQ = 3; | 4281 measConfig->quantityConfig.filterCoefficientRSRQ = 3; |
3703 break; | 4282 break; |
3704 case 4: | 4283 case 4: |
3705 measConfig->quantityConfig.filterCoefficientRSRQ = 4; | 4284 measConfig->quantityConfig.filterCoefficientRSRQ = 4; |
3706 break; | 4285 break; |
3707 case 5: | 4286 case 5: |
3708 measConfig->quantityConfig.filterCoefficientRSRQ = 5; | 4287 measConfig->quantityConfig.filterCoefficientRSRQ = 5; |
3709 break; | 4288 break; |
3710 case 6: | 4289 case 6: |
3711 measConfig->quantityConfig.filterCoefficientRSRQ = 6; | 4290 measConfig->quantityConfig.filterCoefficientRSRQ = 6; |
3712 break; | 4291 break; |
3713 case 7: | 4292 case 7: |
3714 measConfig->quantityConfig.filterCoefficientRSRQ = 7; | 4293 measConfig->quantityConfig.filterCoefficientRSRQ = 7; |
3715 break; | 4294 break; |
3716 case 8: | 4295 case 8: |
3717 measConfig->quantityConfig.filterCoefficientRSRQ = 8; | 4296 measConfig->quantityConfig.filterCoefficientRSRQ = 8; |
3718 break; | 4297 break; |
3719 case 9: | 4298 case 9: |
3720 measConfig->quantityConfig.filterCoefficientRSRQ = 9; | 4299 measConfig->quantityConfig.filterCoefficientRSRQ = 9; |
3721 break; | 4300 break; |
3722 case 10: | 4301 case 10: |
3723 measConfig->quantityConfig.filterCoefficientRSRQ = 11; | 4302 measConfig->quantityConfig.filterCoefficientRSRQ = 11; |
3724 break; | 4303 break; |
3725 case 11: | 4304 case 11: |
3726 measConfig->quantityConfig.filterCoefficientRSRQ = 13; | 4305 measConfig->quantityConfig.filterCoefficientRSRQ = 13; |
3727 break; | 4306 break; |
3728 case 12: | 4307 case 12: |
3729 measConfig->quantityConfig.filterCoefficientRSRQ = 15; | 4308 measConfig->quantityConfig.filterCoefficientRSRQ = 15; |
3730 break; | 4309 break; |
3731 case 13: | 4310 case 13: |
3732 measConfig->quantityConfig.filterCoefficientRSRQ = 17; | 4311 measConfig->quantityConfig.filterCoefficientRSRQ = 17; |
3733 break; | 4312 break; |
3734 case 14: | 4313 case 14: |
3735 measConfig->quantityConfig.filterCoefficientRSRQ = 19; | 4314 measConfig->quantityConfig.filterCoefficientRSRQ = 19; |
3736 break; | 4315 break; |
3737 case 15: | 4316 case 15: |
3738 measConfig->quantityConfig.filterCoefficientRSRQ = 0; | 4317 measConfig->quantityConfig.filterCoefficientRSRQ = 0; |
3739 break; | 4318 break; |
3740 default: | 4319 default: |
3741 measConfig->quantityConfig.filterCoefficientRSRQ = 4; | 4320 measConfig->quantityConfig.filterCoefficientRSRQ = 4; |
3742 } | 4321 } |
3743 } | 4322 } |
3744 if (quantityConfigOpts[2]) | 4323 if (quantityConfigOpts[2]) |
3745 { | 4324 { |
3746 // quantityConfigUTRA | 4325 // quantityConfigUTRA |
3747 // ... | 4326 // ... |
3748 } | 4327 } |
3749 if (quantityConfigOpts[1]) | 4328 if (quantityConfigOpts[1]) |
3750 { | 4329 { |
3751 // quantityConfigGERAN | 4330 // quantityConfigGERAN |
3752 // ... | 4331 // ... |
3753 } | 4332 } |
3754 if (quantityConfigOpts[0]) | 4333 if (quantityConfigOpts[0]) |
3755 { | 4334 { |
3756 // quantityConfigCDMA2000 | 4335 // quantityConfigCDMA2000 |
3757 // ... | 4336 // ... |
3758 } | 4337 } |
3759 } | 4338 } |
3760 | 4339 |
3761 measConfig->haveMeasGapConfig = bitset11[3]; | 4340 measConfig->haveMeasGapConfig = bitset11[3]; |
3762 if (measConfig->haveMeasGapConfig) | 4341 if (measConfig->haveMeasGapConfig) |
3763 { | 4342 { |
3764 // measGapConfig | 4343 // measGapConfig |
3765 int measGapConfigChoice; | 4344 int measGapConfigChoice; |
3766 bIterator = DeserializeChoice (2, false, &measGapConfigChoice, bIterator); | 4345 bIterator = DeserializeChoice (2, false, &measGapConfigChoice, bIterator
); |
3767 switch (measGapConfigChoice) | 4346 switch (measGapConfigChoice) |
3768 { | 4347 { |
3769 case 0: | 4348 case 0: |
3770 measConfig->measGapConfig.type = LteRrcSap::MeasGapConfig::RESET; | 4349 measConfig->measGapConfig.type = LteRrcSap::MeasGapConfig::RESET; |
3771 bIterator = DeserializeNull (bIterator); | 4350 bIterator = DeserializeNull (bIterator); |
3772 break; | 4351 break; |
3773 case 1: | 4352 case 1: |
3774 default: | 4353 default: |
3775 measConfig->measGapConfig.type = LteRrcSap::MeasGapConfig::SETUP; | 4354 measConfig->measGapConfig.type = LteRrcSap::MeasGapConfig::SETUP; |
3776 bIterator = DeserializeSequence (&bitset0, false, bIterator); | 4355 bIterator = DeserializeSequence (&bitset0, false, bIterator); |
3777 | 4356 |
3778 int gapOffsetChoice; | 4357 int gapOffsetChoice; |
3779 bIterator = DeserializeChoice (2, true, &gapOffsetChoice, bIterator); | 4358 bIterator = DeserializeChoice (2, true, &gapOffsetChoice, bIterator)
; |
3780 switch (gapOffsetChoice) | 4359 switch (gapOffsetChoice) |
3781 { | 4360 { |
3782 case 0: | 4361 case 0: |
3783 measConfig->measGapConfig.gapOffsetChoice = LteRrcSap::MeasGapConf
ig::GP0; | 4362 measConfig->measGapConfig.gapOffsetChoice = LteRrcSap::MeasGapCo
nfig::GP0; |
3784 bIterator = DeserializeInteger (&n, 0, 39, bIterator); | 4363 bIterator = DeserializeInteger (&n, 0, 39, bIterator); |
3785 measConfig->measGapConfig.gapOffsetValue = n; | 4364 measConfig->measGapConfig.gapOffsetValue = n; |
3786 break; | 4365 break; |
3787 case 1: | 4366 case 1: |
3788 default: | 4367 default: |
3789 measConfig->measGapConfig.gapOffsetChoice = LteRrcSap::MeasGapConf
ig::GP1; | 4368 measConfig->measGapConfig.gapOffsetChoice = LteRrcSap::MeasGapCo
nfig::GP1; |
3790 bIterator = DeserializeInteger (&n, 0, 79, bIterator); | 4369 bIterator = DeserializeInteger (&n, 0, 79, bIterator); |
3791 measConfig->measGapConfig.gapOffsetValue = n; | 4370 measConfig->measGapConfig.gapOffsetValue = n; |
3792 } | 4371 } |
3793 } | 4372 } |
3794 } | 4373 } |
3795 | 4374 |
3796 measConfig->haveSmeasure = bitset11[2]; | 4375 measConfig->haveSmeasure = bitset11[2]; |
3797 if (measConfig->haveSmeasure) | 4376 if (measConfig->haveSmeasure) |
3798 { | 4377 { |
3799 // s-Measure | 4378 // s-Measure |
3800 bIterator = DeserializeInteger (&n, 0, 97, bIterator); | 4379 bIterator = DeserializeInteger (&n, 0, 97, bIterator); |
3801 measConfig->sMeasure = n; | 4380 measConfig->sMeasure = n; |
3802 } | 4381 } |
3803 | 4382 |
3804 if (bitset11[1]) | 4383 if (bitset11[1]) |
3805 { | 4384 { |
3806 // preRegistrationInfoHRPD | 4385 // preRegistrationInfoHRPD |
3807 // ... | 4386 // ... |
3808 } | 4387 } |
3809 | 4388 |
3810 measConfig->haveSpeedStatePars = bitset11[0]; | 4389 measConfig->haveSpeedStatePars = bitset11[0]; |
3811 if (measConfig->haveSpeedStatePars) | 4390 if (measConfig->haveSpeedStatePars) |
3812 { | 4391 { |
3813 // speedStatePars | 4392 // speedStatePars |
3814 int speedStateParsChoice; | 4393 int speedStateParsChoice; |
3815 bIterator = DeserializeChoice (2, false, &speedStateParsChoice, bIterator)
; | 4394 bIterator = DeserializeChoice (2, false, &speedStateParsChoice, bIterato
r); |
3816 switch (speedStateParsChoice) | 4395 switch (speedStateParsChoice) |
3817 { | 4396 { |
3818 case 0: | 4397 case 0: |
3819 measConfig->speedStatePars.type = LteRrcSap::SpeedStatePars::RESET; | 4398 measConfig->speedStatePars.type = LteRrcSap::SpeedStatePars::RESET; |
3820 bIterator = DeserializeNull (bIterator); | 4399 bIterator = DeserializeNull (bIterator); |
3821 break; | 4400 break; |
3822 case 1: | 4401 case 1: |
3823 default: | 4402 default: |
3824 measConfig->speedStatePars.type = LteRrcSap::SpeedStatePars::SETUP; | 4403 measConfig->speedStatePars.type = LteRrcSap::SpeedStatePars::SETUP; |
3825 bIterator = DeserializeSequence (&bitset0, false, bIterator); | 4404 bIterator = DeserializeSequence (&bitset0, false, bIterator); |
3826 | 4405 |
3827 // Deserialize mobilityStateParameters | 4406 // Deserialize mobilityStateParameters |
3828 // Deserialize t-Evaluation | 4407 // Deserialize t-Evaluation |
3829 bIterator = DeserializeEnum (8, &n, bIterator); | 4408 bIterator = DeserializeEnum (8, &n, bIterator); |
3830 switch (n) | 4409 switch (n) |
3831 { | 4410 { |
3832 case 0: | 4411 case 0: |
3833 measConfig->speedStatePars.mobilityStateParameters.tEvaluation = 3
0; | 4412 measConfig->speedStatePars.mobilityStateParameters.tEvaluation =
30; |
3834 break; | 4413 break; |
3835 case 1: | 4414 case 1: |
3836 measConfig->speedStatePars.mobilityStateParameters.tEvaluation = 6
0; | 4415 measConfig->speedStatePars.mobilityStateParameters.tEvaluation =
60; |
3837 break; | 4416 break; |
3838 case 2: | 4417 case 2: |
3839 measConfig->speedStatePars.mobilityStateParameters.tEvaluation = 1
20; | 4418 measConfig->speedStatePars.mobilityStateParameters.tEvaluation =
120; |
3840 break; | 4419 break; |
3841 case 3: | 4420 case 3: |
3842 measConfig->speedStatePars.mobilityStateParameters.tEvaluation = 1
80; | 4421 measConfig->speedStatePars.mobilityStateParameters.tEvaluation =
180; |
3843 break; | 4422 break; |
3844 case 4: | 4423 case 4: |
3845 measConfig->speedStatePars.mobilityStateParameters.tEvaluation = 2
40; | 4424 measConfig->speedStatePars.mobilityStateParameters.tEvaluation =
240; |
3846 break; | 4425 break; |
3847 default: | 4426 default: |
3848 measConfig->speedStatePars.mobilityStateParameters.tEvaluation = 0
; | 4427 measConfig->speedStatePars.mobilityStateParameters.tEvaluation =
0; |
3849 } | 4428 } |
3850 // Deserialize t-HystNormal | 4429 // Deserialize t-HystNormal |
3851 bIterator = DeserializeEnum (8, &n, bIterator); | 4430 bIterator = DeserializeEnum (8, &n, bIterator); |
3852 switch (n) | 4431 switch (n) |
3853 { | 4432 { |
3854 case 0: | 4433 case 0: |
3855 measConfig->speedStatePars.mobilityStateParameters.tHystNormal = 3
0; | 4434 measConfig->speedStatePars.mobilityStateParameters.tHystNormal =
30; |
3856 break; | 4435 break; |
3857 case 1: | 4436 case 1: |
3858 measConfig->speedStatePars.mobilityStateParameters.tHystNormal = 6
0; | 4437 measConfig->speedStatePars.mobilityStateParameters.tHystNormal =
60; |
3859 break; | 4438 break; |
3860 case 2: | 4439 case 2: |
3861 measConfig->speedStatePars.mobilityStateParameters.tHystNormal = 1
20; | 4440 measConfig->speedStatePars.mobilityStateParameters.tHystNormal =
120; |
3862 break; | 4441 break; |
3863 case 3: | 4442 case 3: |
3864 measConfig->speedStatePars.mobilityStateParameters.tHystNormal = 1
80; | 4443 measConfig->speedStatePars.mobilityStateParameters.tHystNormal =
180; |
3865 break; | 4444 break; |
3866 case 4: | 4445 case 4: |
3867 measConfig->speedStatePars.mobilityStateParameters.tHystNormal = 2
40; | 4446 measConfig->speedStatePars.mobilityStateParameters.tHystNormal =
240; |
3868 break; | 4447 break; |
3869 default: | 4448 default: |
3870 measConfig->speedStatePars.mobilityStateParameters.tHystNormal = 0
; | 4449 measConfig->speedStatePars.mobilityStateParameters.tHystNormal =
0; |
3871 } | 4450 } |
3872 | 4451 |
3873 bIterator = DeserializeInteger (&n, 1, 16, bIterator); | 4452 bIterator = DeserializeInteger (&n, 1, 16, bIterator); |
3874 measConfig->speedStatePars.mobilityStateParameters.nCellChangeMedium =
n; | 4453 measConfig->speedStatePars.mobilityStateParameters.nCellChangeMedium
= n; |
3875 | 4454 |
3876 bIterator = DeserializeInteger (&n, 1, 16, bIterator); | 4455 bIterator = DeserializeInteger (&n, 1, 16, bIterator); |
3877 measConfig->speedStatePars.mobilityStateParameters.nCellChangeHigh = n
; | 4456 measConfig->speedStatePars.mobilityStateParameters.nCellChangeHigh =
n; |
3878 | 4457 |
3879 // Deserialize timeToTriggerSf | 4458 // Deserialize timeToTriggerSf |
3880 bIterator = DeserializeEnum (4, &n, bIterator); | 4459 bIterator = DeserializeEnum (4, &n, bIterator); |
3881 measConfig->speedStatePars.timeToTriggerSf.sfMedium = (n + 1) * 25; | 4460 measConfig->speedStatePars.timeToTriggerSf.sfMedium = (n + 1) * 25; |
3882 bIterator = DeserializeEnum (4, &n, bIterator); | 4461 bIterator = DeserializeEnum (4, &n, bIterator); |
3883 measConfig->speedStatePars.timeToTriggerSf.sfHigh = (n + 1) * 25; | 4462 measConfig->speedStatePars.timeToTriggerSf.sfHigh = (n + 1) * 25; |
3884 } | 4463 } |
3885 } | 4464 } |
3886 return bIterator; | 4465 return bIterator; |
3887 } | 4466 } |
3888 //////////////////// RrcConnectionRequest class //////////////////////// | 4467 //////////////////// RrcConnectionRequest class //////////////////////// |
3889 | 4468 |
3890 // Constructor | 4469 // Constructor |
3891 RrcConnectionRequestHeader::RrcConnectionRequestHeader () : RrcUlCcchMessage () | 4470 RrcConnectionRequestHeader::RrcConnectionRequestHeader () : RrcUlCcchMessage (
) |
3892 { | 4471 { |
3893 m_mmec = std::bitset<8> (0ul); | 4472 m_mmec = std::bitset<8> (0ul); |
3894 m_mTmsi = std::bitset<32> (0ul); | 4473 m_mTmsi = std::bitset<32> (0ul); |
3895 m_establishmentCause = MO_SIGNALLING; | 4474 m_establishmentCause = MO_SIGNALLING; |
3896 m_spare = std::bitset<1> (0ul); | 4475 m_spare = std::bitset<1> (0ul); |
3897 } | 4476 } |
3898 | 4477 |
3899 // Destructor | 4478 // Destructor |
3900 RrcConnectionRequestHeader::~RrcConnectionRequestHeader () | 4479 RrcConnectionRequestHeader::~RrcConnectionRequestHeader () |
3901 { | 4480 { |
3902 } | 4481 } |
3903 | 4482 |
3904 TypeId | 4483 TypeId |
3905 RrcConnectionRequestHeader::GetTypeId (void) | 4484 RrcConnectionRequestHeader::GetTypeId (void) |
3906 { | 4485 { |
3907 static TypeId tid = TypeId ("ns3::RrcConnectionRequestHeader") | 4486 static TypeId tid = TypeId ("ns3::RrcConnectionRequestHeader") |
3908 .SetParent<Header> () | 4487 .SetParent<Header> () |
3909 .SetGroupName("Lte") | 4488 .SetGroupName("Lte") |
3910 ; | 4489 ; |
3911 return tid; | 4490 return tid; |
3912 } | 4491 } |
3913 | 4492 |
3914 void | 4493 void |
3915 RrcConnectionRequestHeader::Print (std::ostream &os) const | 4494 RrcConnectionRequestHeader::Print (std::ostream &os) const |
3916 { | 4495 { |
3917 os << "MMEC:" << m_mmec << std::endl; | 4496 os << "MMEC:" << m_mmec << std::endl; |
3918 os << "MTMSI:" << m_mTmsi << std::endl; | 4497 os << "MTMSI:" << m_mTmsi << std::endl; |
3919 os << "EstablishmentCause:" << m_establishmentCause << std::endl; | 4498 os << "EstablishmentCause:" << m_establishmentCause << std::endl; |
3920 os << "Spare: " << m_spare << std::endl; | 4499 os << "Spare: " << m_spare << std::endl; |
3921 } | 4500 } |
3922 | 4501 |
3923 void | 4502 void |
3924 RrcConnectionRequestHeader::PreSerialize () const | 4503 RrcConnectionRequestHeader::PreSerialize () const |
3925 { | 4504 { |
3926 m_serializationResult = Buffer (); | 4505 m_serializationResult = Buffer (); |
3927 | 4506 |
3928 SerializeUlCcchMessage (1); | 4507 SerializeUlCcchMessage (1); |
3929 | 4508 |
3930 // Serialize RRCConnectionRequest sequence: | 4509 // Serialize RRCConnectionRequest sequence: |
3931 // no default or optional fields. Extension marker not present. | 4510 // no default or optional fields. Extension marker not present. |
3932 SerializeSequence (std::bitset<0> (),false); | 4511 SerializeSequence (std::bitset<0> (),false); |
3933 | 4512 |
3934 // Serialize criticalExtensions choice: | 4513 // Serialize criticalExtensions choice: |
3935 // 2 options, selected: 0 (option: rrcConnectionRequest-r8) | 4514 // 2 options, selected: 0 (option: rrcConnectionRequest-r8) |
3936 SerializeChoice (2,0,false); | 4515 SerializeChoice (2,0,false); |
3937 | 4516 |
3938 // Serialize RRCConnectionRequest-r8-IEs sequence: | 4517 // Serialize RRCConnectionRequest-r8-IEs sequence: |
3939 // no default or optional fields. Extension marker not present. | 4518 // no default or optional fields. Extension marker not present. |
3940 SerializeSequence (std::bitset<0> (),false); | 4519 SerializeSequence (std::bitset<0> (),false); |
3941 | 4520 |
3942 // Serialize InitialUE-Identity choice: | 4521 // Serialize InitialUE-Identity choice: |
3943 // 2 options, selected: 0 (option: s-TMSI) | 4522 // 2 options, selected: 0 (option: s-TMSI) |
3944 SerializeChoice (2,0,false); | 4523 SerializeChoice (2,0,false); |
3945 | 4524 |
3946 // Serialize S-TMSI sequence: | 4525 // Serialize S-TMSI sequence: |
3947 // no default or optional fields. Extension marker not present. | 4526 // no default or optional fields. Extension marker not present. |
3948 SerializeSequence (std::bitset<0> (),false); | 4527 SerializeSequence (std::bitset<0> (),false); |
3949 | 4528 |
3950 // Serialize mmec : MMEC ::= BIT STRING (SIZE (8)) | 4529 // Serialize mmec : MMEC ::= BIT STRING (SIZE (8)) |
3951 SerializeBitstring (m_mmec); | 4530 SerializeBitstring (m_mmec); |
3952 | 4531 |
3953 // Serialize m-TMSI ::= BIT STRING (SIZE (32)) | 4532 // Serialize m-TMSI ::= BIT STRING (SIZE (32)) |
3954 SerializeBitstring (m_mTmsi); | 4533 SerializeBitstring (m_mTmsi); |
3955 | 4534 |
3956 // Serialize establishmentCause : EstablishmentCause ::= ENUMERATED | 4535 // Serialize establishmentCause : EstablishmentCause ::= ENUMERATED |
3957 SerializeEnum (8,m_establishmentCause); | 4536 SerializeEnum (8,m_establishmentCause); |
3958 | 4537 |
3959 // Serialize spare : BIT STRING (SIZE (1)) | 4538 // Serialize spare : BIT STRING (SIZE (1)) |
3960 SerializeBitstring (std::bitset<1> ()); | 4539 SerializeBitstring (std::bitset<1> ()); |
3961 | 4540 |
3962 // Finish serialization | 4541 // Finish serialization |
3963 FinalizeSerialization (); | 4542 FinalizeSerialization (); |
3964 } | 4543 } |
3965 | 4544 |
3966 uint32_t | 4545 uint32_t |
3967 RrcConnectionRequestHeader::Deserialize (Buffer::Iterator bIterator) | 4546 RrcConnectionRequestHeader::Deserialize (Buffer::Iterator bIterator) |
3968 { | 4547 { |
3969 std::bitset<1> dummy; | 4548 std::bitset<1> dummy; |
3970 std::bitset<0> optionalOrDefaultMask; | 4549 std::bitset<0> optionalOrDefaultMask; |
3971 int selectedOption; | 4550 int selectedOption; |
3972 | 4551 |
3973 bIterator = DeserializeUlCcchMessage (bIterator); | 4552 bIterator = DeserializeUlCcchMessage (bIterator); |
3974 | 4553 |
3975 // Deserialize RCConnectionRequest sequence | 4554 // Deserialize RCConnectionRequest sequence |
3976 bIterator = DeserializeSequence (&optionalOrDefaultMask,false,bIterator); | 4555 bIterator = DeserializeSequence (&optionalOrDefaultMask,false,bIterator); |
3977 | 4556 |
3978 // Deserialize criticalExtensions choice: | 4557 // Deserialize criticalExtensions choice: |
3979 bIterator = DeserializeChoice (2,false,&selectedOption,bIterator); | 4558 bIterator = DeserializeChoice (2,false,&selectedOption,bIterator); |
3980 | 4559 |
3981 // Deserialize RRCConnectionRequest-r8-IEs sequence | 4560 // Deserialize RRCConnectionRequest-r8-IEs sequence |
3982 bIterator = DeserializeSequence (&optionalOrDefaultMask,false,bIterator); | 4561 bIterator = DeserializeSequence (&optionalOrDefaultMask,false,bIterator); |
3983 | 4562 |
3984 // Deserialize InitialUE-Identity choice | 4563 // Deserialize InitialUE-Identity choice |
3985 bIterator = DeserializeChoice (2,false,&selectedOption,bIterator); | 4564 bIterator = DeserializeChoice (2,false,&selectedOption,bIterator); |
3986 | 4565 |
3987 // Deserialize S-TMSI sequence | 4566 // Deserialize S-TMSI sequence |
3988 bIterator = DeserializeSequence (&optionalOrDefaultMask,false,bIterator); | 4567 bIterator = DeserializeSequence (&optionalOrDefaultMask,false,bIterator); |
3989 | 4568 |
3990 // Deserialize mmec | 4569 // Deserialize mmec |
3991 bIterator = DeserializeBitstring (&m_mmec,bIterator); | 4570 bIterator = DeserializeBitstring (&m_mmec,bIterator); |
3992 | 4571 |
3993 // Deserialize m-TMSI | 4572 // Deserialize m-TMSI |
3994 bIterator = DeserializeBitstring (&m_mTmsi,bIterator); | 4573 bIterator = DeserializeBitstring (&m_mTmsi,bIterator); |
3995 | 4574 |
3996 // Deserialize establishmentCause | 4575 // Deserialize establishmentCause |
3997 bIterator = DeserializeEnum (8,&selectedOption,bIterator); | 4576 bIterator = DeserializeEnum (8,&selectedOption,bIterator); |
3998 | 4577 |
3999 // Deserialize spare | 4578 // Deserialize spare |
4000 bIterator = DeserializeBitstring (&dummy,bIterator); | 4579 bIterator = DeserializeBitstring (&dummy,bIterator); |
4001 | 4580 |
4002 return GetSerializedSize (); | 4581 return GetSerializedSize (); |
4003 } | 4582 } |
4004 | 4583 |
4005 void | 4584 void |
4006 RrcConnectionRequestHeader::SetMessage (LteRrcSap::RrcConnectionRequest msg) | 4585 RrcConnectionRequestHeader::SetMessage (LteRrcSap::RrcConnectionRequest msg) |
4007 { | 4586 { |
4008 m_mTmsi = std::bitset<32> ((uint32_t)msg.ueIdentity); | 4587 m_mTmsi = std::bitset<32> ((uint32_t)msg.ueIdentity); |
4009 m_mmec = std::bitset<8> ((uint32_t)(msg.ueIdentity >> 32)); | 4588 m_mmec = std::bitset<8> ((uint32_t)(msg.ueIdentity >> 32)); |
4010 m_isDataSerialized = false; | 4589 m_isDataSerialized = false; |
4011 } | 4590 } |
4012 | 4591 |
4013 LteRrcSap::RrcConnectionRequest | 4592 LteRrcSap::RrcConnectionRequest |
4014 RrcConnectionRequestHeader::GetMessage () const | 4593 RrcConnectionRequestHeader::GetMessage () const |
4015 { | 4594 { |
4016 LteRrcSap::RrcConnectionRequest msg; | 4595 LteRrcSap::RrcConnectionRequest msg; |
4017 msg.ueIdentity = (((uint64_t) m_mmec.to_ulong ()) << 32) | (m_mTmsi.to_ulong (
)); | 4596 msg.ueIdentity = (((uint64_t) m_mmec.to_ulong ()) << 32) | (m_mTmsi.to_ulong
()); |
4018 | 4597 |
4019 return msg; | 4598 return msg; |
4020 } | 4599 } |
4021 | 4600 |
4022 std::bitset<8> | 4601 std::bitset<8> |
4023 RrcConnectionRequestHeader::GetMmec () const | 4602 RrcConnectionRequestHeader::GetMmec () const |
4024 { | 4603 { |
4025 return m_mmec; | 4604 return m_mmec; |
4026 } | 4605 } |
4027 | 4606 |
4028 std::bitset<32> | 4607 std::bitset<32> |
4029 RrcConnectionRequestHeader::GetMtmsi () const | 4608 RrcConnectionRequestHeader::GetMtmsi () const |
4030 { | 4609 { |
4031 return m_mTmsi; | 4610 return m_mTmsi; |
4032 } | 4611 } |
4033 | 4612 |
4034 | 4613 |
4035 //////////////////// RrcConnectionSetup class //////////////////////// | 4614 //////////////////// RrcConnectionSetup class //////////////////////// |
4036 RrcConnectionSetupHeader::RrcConnectionSetupHeader () | 4615 RrcConnectionSetupHeader::RrcConnectionSetupHeader () |
4037 { | 4616 { |
4038 } | 4617 } |
4039 · | 4618 · |
4040 RrcConnectionSetupHeader::~RrcConnectionSetupHeader () | 4619 RrcConnectionSetupHeader::~RrcConnectionSetupHeader () |
4041 { | 4620 { |
4042 } | 4621 } |
4043 · | 4622 · |
4044 void | 4623 void |
4045 RrcConnectionSetupHeader::Print (std::ostream &os) const | 4624 RrcConnectionSetupHeader::Print (std::ostream &os) const |
4046 { | 4625 { |
4047 os << "rrcTransactionIdentifier: " << (int)m_rrcTransactionIdentifier << std::
endl; | 4626 os << "rrcTransactionIdentifier: " << (int)m_rrcTransactionIdentifier << std
::endl; |
4048 os << "radioResourceConfigDedicated:" << std::endl; | 4627 os << "radioResourceConfigDedicated:" << std::endl; |
4049 RrcAsn1Header::Print (os,m_radioResourceConfigDedicated); | 4628 RrcAsn1Header::Print (os,m_radioResourceConfigDedicated); |
4050 } | 4629 } |
4051 | 4630 |
4052 void | 4631 void |
4053 RrcConnectionSetupHeader::PreSerialize () const | 4632 RrcConnectionSetupHeader::PreSerialize () const |
4054 { | 4633 { |
4055 m_serializationResult = Buffer (); | 4634 m_serializationResult = Buffer (); |
4056 | 4635 |
4057 SerializeDlCcchMessage (3); | 4636 SerializeDlCcchMessage (3); |
4058 | 4637 |
4059 SerializeInteger (15,0,15); | 4638 SerializeInteger (15,0,15); |
4060 | 4639 |
4061 // Serialize RRCConnectionSetup sequence: | 4640 // Serialize RRCConnectionSetup sequence: |
4062 // no default or optional fields. Extension marker not present. | 4641 // no default or optional fields. Extension marker not present. |
4063 SerializeSequence (std::bitset<0> (),false); | 4642 SerializeSequence (std::bitset<0> (),false); |
4064 | 4643 |
4065 // Serialize rrc-TransactionIdentifier ::=INTEGER (0..3) | 4644 // Serialize rrc-TransactionIdentifier ::=INTEGER (0..3) |
4066 SerializeInteger (m_rrcTransactionIdentifier,0,3); | 4645 SerializeInteger (m_rrcTransactionIdentifier,0,3); |
4067 | 4646 |
4068 // Serialize criticalExtensions choice: | 4647 // Serialize criticalExtensions choice: |
4069 // 2 options, selected: 0 (option: c1) | 4648 // 2 options, selected: 0 (option: c1) |
4070 SerializeChoice (2,0,false); | 4649 SerializeChoice (2,0,false); |
4071 | 4650 |
4072 // Serialize c1 choice: | 4651 // Serialize c1 choice: |
4073 // 8 options, selected: 0 (option: rrcConnectionSetup-r8) | 4652 // 8 options, selected: 0 (option: rrcConnectionSetup-r8) |
4074 SerializeChoice (8,0,false); | 4653 SerializeChoice (8,0,false); |
4075 | 4654 |
4076 // Serialize rrcConnectionSetup-r8 sequence | 4655 // Serialize rrcConnectionSetup-r8 sequence |
4077 // 1 optional fields (not present). Extension marker not present. | 4656 // 1 optional fields (not present). Extension marker not present. |
4078 SerializeSequence (std::bitset<1> (0),false); | 4657 SerializeSequence (std::bitset<1> (0),false); |
4079 | 4658 |
4080 // Serialize RadioResourceConfigDedicated sequence | 4659 // Serialize RadioResourceConfigDedicated sequence |
4081 SerializeRadioResourceConfigDedicated (m_radioResourceConfigDedicated); | 4660 SerializeRadioResourceConfigDedicated (m_radioResourceConfigDedicated); |
4082 | 4661 |
4083 // Serialize nonCriticalExtension sequence | 4662 // Serialize nonCriticalExtension sequence |
4084 // 2 optional fields, none present. No extension marker. | 4663 // 2 optional fields, none present. No extension marker. |
4085 SerializeSequence (std::bitset<2> (0),false); | 4664 SerializeSequence (std::bitset<2> (0),false); |
4086 | 4665 |
4087 // Finish serialization | 4666 // Finish serialization |
4088 FinalizeSerialization (); | 4667 FinalizeSerialization (); |
4089 } | 4668 } |
4090 | 4669 |
4091 | 4670 |
4092 uint32_t | 4671 uint32_t |
4093 RrcConnectionSetupHeader::Deserialize (Buffer::Iterator bIterator) | 4672 RrcConnectionSetupHeader::Deserialize (Buffer::Iterator bIterator) |
4094 { | 4673 { |
4095 int n; | 4674 int n; |
4096 | 4675 |
4097 std::bitset<0> bitset0; | 4676 std::bitset<0> bitset0; |
4098 std::bitset<1> bitset1; | 4677 std::bitset<1> bitset1; |
4099 std::bitset<2> bitset2; | 4678 std::bitset<2> bitset2; |
4100 | 4679 |
4101 bIterator = DeserializeDlCcchMessage (bIterator); | 4680 bIterator = DeserializeDlCcchMessage (bIterator); |
4102 | 4681 |
4103 bIterator = DeserializeInteger (&n,0,15,bIterator); | 4682 bIterator = DeserializeInteger (&n,0,15,bIterator); |
4104 | 4683 |
4105 // Deserialize RRCConnectionSetup sequence | 4684 // Deserialize RRCConnectionSetup sequence |
4106 bIterator = DeserializeSequence (&bitset0,false,bIterator); | 4685 bIterator = DeserializeSequence (&bitset0,false,bIterator); |
4107 | 4686 |
4108 // Deserialize rrc-TransactionIdentifier ::=INTEGER (0..3) | 4687 // Deserialize rrc-TransactionIdentifier ::=INTEGER (0..3) |
4109 bIterator = DeserializeInteger (&n,0,3,bIterator); | 4688 bIterator = DeserializeInteger (&n,0,3,bIterator); |
4110 m_rrcTransactionIdentifier = n; | 4689 m_rrcTransactionIdentifier = n; |
4111 | 4690 |
4112 // Deserialize criticalExtensions choice | 4691 // Deserialize criticalExtensions choice |
4113 int criticalExtensionChoice; | 4692 int criticalExtensionChoice; |
4114 bIterator = DeserializeChoice (2,false,&criticalExtensionChoice,bIterator); | 4693 bIterator = DeserializeChoice (2,false,&criticalExtensionChoice,bIterator); |
4115 if (criticalExtensionChoice == 1) | 4694 if (criticalExtensionChoice == 1) |
4116 { | 4695 { |
4117 // Deserialize criticalExtensionsFuture | 4696 // Deserialize criticalExtensionsFuture |
4118 bIterator = DeserializeSequence (&bitset0,false,bIterator); | 4697 bIterator = DeserializeSequence (&bitset0,false,bIterator); |
4119 } | 4698 } |
4120 else if (criticalExtensionChoice == 0) | 4699 else if (criticalExtensionChoice == 0) |
4121 { | 4700 { |
4122 // Deserialize c1 | 4701 // Deserialize c1 |
4123 int c1; | 4702 int c1; |
4124 bIterator = DeserializeChoice (8,false,&c1,bIterator); | 4703 bIterator = DeserializeChoice (8,false,&c1,bIterator); |
4125 | 4704 |
4126 if (c1 > 0) | 4705 if (c1 > 0) |
4127 { | 4706 { |
4128 // Deserialize spareX , X:=7..1 | 4707 // Deserialize spareX , X:=7..1 |
4129 bIterator = DeserializeNull (bIterator); | 4708 bIterator = DeserializeNull (bIterator); |
4130 } | 4709 } |
4131 else if (c1 == 0) | 4710 else if (c1 == 0) |
4132 { | 4711 { |
4133 // Deserialize rrcConnectionSetup-r8 | 4712 // Deserialize rrcConnectionSetup-r8 |
4134 // 1 optional fields, no extension marker. | 4713 // 1 optional fields, no extension marker. |
4135 bIterator = DeserializeSequence (&bitset1,false,bIterator); | 4714 bIterator = DeserializeSequence (&bitset1,false,bIterator); |
4136 | 4715 |
4137 // Deserialize radioResourceConfigDedicated | 4716 // Deserialize radioResourceConfigDedicated |
4138 bIterator = DeserializeRadioResourceConfigDedicated (&m_radioResourceC
onfigDedicated,bIterator); | 4717 bIterator = DeserializeRadioResourceConfigDedicated (&m_radioResourc
eConfigDedicated,bIterator); |
4139 | 4718 |
4140 if (bitset1[0]) | 4719 if (bitset1[0]) |
4141 { | 4720 { |
4142 // Deserialize nonCriticalExtension | 4721 // Deserialize nonCriticalExtension |
4143 // 2 optional fields, no extension marker. | 4722 // 2 optional fields, no extension marker. |
4144 bIterator = DeserializeSequence (&bitset2,false,bIterator); | 4723 bIterator = DeserializeSequence (&bitset2,false,bIterator); |
4145 | 4724 |
4146 // Deserialization of lateR8NonCriticalExtension and nonCriticalEx
tension | 4725 // Deserialization of lateR8NonCriticalExtension and nonCritical
Extension |
4147 // ... | 4726 // ... |
4148 } | 4727 } |
4149 } | 4728 } |
4150 } | 4729 } |
4151 return GetSerializedSize (); | 4730 return GetSerializedSize (); |
4152 } | 4731 } |
4153 | 4732 |
4154 void | 4733 void |
4155 RrcConnectionSetupHeader::SetMessage (LteRrcSap::RrcConnectionSetup msg) | 4734 RrcConnectionSetupHeader::SetMessage (LteRrcSap::RrcConnectionSetup msg) |
4156 { | 4735 { |
4157 m_rrcTransactionIdentifier = msg.rrcTransactionIdentifier; | 4736 m_rrcTransactionIdentifier = msg.rrcTransactionIdentifier; |
4158 m_radioResourceConfigDedicated = msg.radioResourceConfigDedicated; | 4737 m_radioResourceConfigDedicated = msg.radioResourceConfigDedicated; |
4159 m_isDataSerialized = false; | 4738 m_isDataSerialized = false; |
4160 } | 4739 } |
4161 | 4740 |
4162 LteRrcSap::RrcConnectionSetup | 4741 LteRrcSap::RrcConnectionSetup |
4163 RrcConnectionSetupHeader::GetMessage () const | 4742 RrcConnectionSetupHeader::GetMessage () const |
4164 { | 4743 { |
4165 LteRrcSap::RrcConnectionSetup msg; | 4744 LteRrcSap::RrcConnectionSetup msg; |
4166 msg.rrcTransactionIdentifier = m_rrcTransactionIdentifier; | 4745 msg.rrcTransactionIdentifier = m_rrcTransactionIdentifier; |
4167 msg.radioResourceConfigDedicated = m_radioResourceConfigDedicated;· | 4746 msg.radioResourceConfigDedicated = m_radioResourceConfigDedicated;· |
4168 return msg; | 4747 return msg; |
4169 } | 4748 } |
4170 | 4749 |
4171 uint8_t | 4750 uint8_t |
4172 RrcConnectionSetupHeader::GetRrcTransactionIdentifier () const | 4751 RrcConnectionSetupHeader::GetRrcTransactionIdentifier () const |
4173 { | 4752 { |
4174 return m_rrcTransactionIdentifier; | 4753 return m_rrcTransactionIdentifier; |
4175 } | 4754 } |
4176 | 4755 |
4177 bool | 4756 bool |
4178 RrcConnectionSetupHeader::HavePhysicalConfigDedicated () const | 4757 RrcConnectionSetupHeader::HavePhysicalConfigDedicated () const |
4179 { | 4758 { |
4180 return m_radioResourceConfigDedicated.havePhysicalConfigDedicated; | 4759 return m_radioResourceConfigDedicated.havePhysicalConfigDedicated; |
4181 } | 4760 } |
4182 | 4761 |
4183 std::list<LteRrcSap::SrbToAddMod> | 4762 std::list<LteRrcSap::SrbToAddMod> |
4184 RrcConnectionSetupHeader::GetSrbToAddModList () const | 4763 RrcConnectionSetupHeader::GetSrbToAddModList () const |
4185 { | 4764 { |
4186 return m_radioResourceConfigDedicated.srbToAddModList; | 4765 return m_radioResourceConfigDedicated.srbToAddModList; |
4187 } | 4766 } |
4188 | 4767 |
4189 std::list<LteRrcSap::DrbToAddMod> | 4768 std::list<LteRrcSap::DrbToAddMod> |
4190 RrcConnectionSetupHeader::GetDrbToAddModList () const | 4769 RrcConnectionSetupHeader::GetDrbToAddModList () const |
4191 { | 4770 { |
4192 return m_radioResourceConfigDedicated.drbToAddModList; | 4771 return m_radioResourceConfigDedicated.drbToAddModList; |
4193 }· | 4772 }· |
4194 | 4773 |
4195 std::list<uint8_t> | 4774 std::list<uint8_t> |
4196 RrcConnectionSetupHeader::GetDrbToReleaseList () const | 4775 RrcConnectionSetupHeader::GetDrbToReleaseList () const |
4197 { | 4776 { |
4198 return m_radioResourceConfigDedicated.drbToReleaseList; | 4777 return m_radioResourceConfigDedicated.drbToReleaseList; |
4199 } | 4778 } |
4200 | 4779 |
4201 LteRrcSap::PhysicalConfigDedicated | 4780 LteRrcSap::PhysicalConfigDedicated |
4202 RrcConnectionSetupHeader::GetPhysicalConfigDedicated () const | 4781 RrcConnectionSetupHeader::GetPhysicalConfigDedicated () const |
4203 { | 4782 { |
4204 return m_radioResourceConfigDedicated.physicalConfigDedicated; | 4783 return m_radioResourceConfigDedicated.physicalConfigDedicated; |
4205 } | 4784 } |
4206 | 4785 |
4207 LteRrcSap::RadioResourceConfigDedicated | 4786 LteRrcSap::RadioResourceConfigDedicated |
4208 RrcConnectionSetupHeader::GetRadioResourceConfigDedicated () const | 4787 RrcConnectionSetupHeader::GetRadioResourceConfigDedicated () const |
4209 { | 4788 { |
4210 return m_radioResourceConfigDedicated; | 4789 return m_radioResourceConfigDedicated; |
4211 } | 4790 } |
4212 | 4791 |
4213 //////////////////// RrcConnectionSetupCompleteHeader class ////////////////////
//// | 4792 //////////////////// RrcConnectionSetupCompleteHeader class //////////////////
////// |
4214 | 4793 |
4215 RrcConnectionSetupCompleteHeader::RrcConnectionSetupCompleteHeader () | 4794 RrcConnectionSetupCompleteHeader::RrcConnectionSetupCompleteHeader () |
4216 { | 4795 { |
4217 } | 4796 } |
4218 | 4797 |
4219 RrcConnectionSetupCompleteHeader::~RrcConnectionSetupCompleteHeader () | 4798 RrcConnectionSetupCompleteHeader::~RrcConnectionSetupCompleteHeader () |
4220 { | 4799 { |
4221 } | 4800 } |
4222 | 4801 |
4223 void | 4802 void |
4224 RrcConnectionSetupCompleteHeader::PreSerialize () const | 4803 RrcConnectionSetupCompleteHeader::PreSerialize () const |
4225 { | 4804 { |
4226 m_serializationResult = Buffer (); | 4805 m_serializationResult = Buffer (); |
4227 | 4806 |
4228 // Serialize DCCH message | 4807 // Serialize DCCH message |
4229 SerializeUlDcchMessage (4); | 4808 SerializeUlDcchMessage (4); |
4230 | 4809 |
4231 // Serialize RRCConnectionSetupComplete sequence: | 4810 // Serialize RRCConnectionSetupComplete sequence: |
4232 // no default or optional fields. Extension marker not present. | 4811 // no default or optional fields. Extension marker not present. |
4233 SerializeSequence (std::bitset<0> (),false); | 4812 SerializeSequence (std::bitset<0> (),false); |
4234 | 4813 |
4235 // Serialize rrc-TransactionIdentifier | 4814 // Serialize rrc-TransactionIdentifier |
4236 SerializeInteger (m_rrcTransactionIdentifier,0,3); | 4815 SerializeInteger (m_rrcTransactionIdentifier,0,3); |
4237 | 4816 |
4238 // Serialize criticalExtensions choice | 4817 // Serialize criticalExtensions choice |
4239 // 2 options, selected 0 (c1) | 4818 // 2 options, selected 0 (c1) |
4240 SerializeChoice (2,0,false); | 4819 SerializeChoice (2,0,false); |
4241 | 4820 |
4242 // Choose spare3 NULL | 4821 // Choose spare3 NULL |
4243 SerializeChoice (4,1,false); | 4822 SerializeChoice (4,1,false); |
4244 | 4823 |
4245 // Serialize spare3 NULL | 4824 // Serialize spare3 NULL |
4246 SerializeNull (); | 4825 SerializeNull (); |
4247 | 4826 |
4248 // Finish serialization | 4827 // Finish serialization |
4249 FinalizeSerialization (); | 4828 FinalizeSerialization (); |
4250 } | 4829 } |
4251 | 4830 |
4252 uint32_t | 4831 uint32_t |
4253 RrcConnectionSetupCompleteHeader::Deserialize (Buffer::Iterator bIterator) | 4832 RrcConnectionSetupCompleteHeader::Deserialize (Buffer::Iterator bIterator) |
4254 { | 4833 { |
4255 std::bitset<0> bitset0; | 4834 std::bitset<0> bitset0; |
4256 | 4835 |
4257 bIterator = DeserializeUlDcchMessage (bIterator); | 4836 bIterator = DeserializeUlDcchMessage (bIterator); |
4258 | 4837 |
4259 bIterator = DeserializeSequence (&bitset0,false,bIterator); | 4838 bIterator = DeserializeSequence (&bitset0,false,bIterator); |
4260 | 4839 |
4261 int n; | 4840 int n; |
4262 bIterator = DeserializeInteger (&n,0,3,bIterator); | 4841 bIterator = DeserializeInteger (&n,0,3,bIterator); |
4263 m_rrcTransactionIdentifier = n; | 4842 m_rrcTransactionIdentifier = n; |
4264 | 4843 |
4265 bIterator = DeserializeChoice (2,false,&n,bIterator); | 4844 bIterator = DeserializeChoice (2,false,&n,bIterator); |
4266 | 4845 |
4267 if (n == 1) | 4846 if (n == 1) |
4268 { | 4847 { |
4269 // Deserialize criticalExtensionsFuture | 4848 // Deserialize criticalExtensionsFuture |
4270 bIterator = DeserializeSequence (&bitset0,false,bIterator); | 4849 bIterator = DeserializeSequence (&bitset0,false,bIterator); |
4271 } | 4850 } |
4272 else if (n == 0) | 4851 else if (n == 0) |
4273 { | 4852 { |
4274 // Deserialize c1 | 4853 // Deserialize c1 |
4275 int c1Chosen; | 4854 int c1Chosen; |
4276 bIterator = DeserializeChoice (4,false,&c1Chosen,bIterator); | 4855 bIterator = DeserializeChoice (4,false,&c1Chosen,bIterator); |
4277 | 4856 |
4278 if (c1Chosen == 0) | 4857 if (c1Chosen == 0) |
4279 { | 4858 { |
4280 // Deserialize rrcConnectionSetupComplete-r8 | 4859 // Deserialize rrcConnectionSetupComplete-r8 |
4281 // ... | 4860 // ... |
4282 } | 4861 } |
4283 else | 4862 else |
4284 { | 4863 { |
4285 bIterator = DeserializeNull (bIterator); | 4864 bIterator = DeserializeNull (bIterator); |
4286 } | 4865 } |
4287 } | 4866 } |
4288 | 4867 |
4289 return GetSerializedSize (); | 4868 return GetSerializedSize (); |
4290 } | 4869 } |
4291 | 4870 |
4292 void | 4871 void |
4293 RrcConnectionSetupCompleteHeader::Print (std::ostream &os) const | 4872 RrcConnectionSetupCompleteHeader::Print (std::ostream &os) const |
4294 { | 4873 { |
4295 os << "rrcTransactionIdentifier: " << (int) m_rrcTransactionIdentifier << std:
:endl; | 4874 os << "rrcTransactionIdentifier: " << (int) m_rrcTransactionIdentifier << st
d::endl; |
4296 } | 4875 } |
4297 | 4876 |
4298 void | 4877 void |
4299 RrcConnectionSetupCompleteHeader::SetMessage (LteRrcSap::RrcConnectionSetupCompl
eted msg) | 4878 RrcConnectionSetupCompleteHeader::SetMessage (LteRrcSap::RrcConnectionSetupCom
pleted msg) |
4300 { | 4879 { |
4301 m_rrcTransactionIdentifier = msg.rrcTransactionIdentifier; | 4880 m_rrcTransactionIdentifier = msg.rrcTransactionIdentifier; |
4302 m_isDataSerialized = false; | 4881 m_isDataSerialized = false; |
4303 } | 4882 } |
4304 | 4883 |
4305 uint8_t | 4884 uint8_t |
4306 RrcConnectionSetupCompleteHeader::GetRrcTransactionIdentifier () const | 4885 RrcConnectionSetupCompleteHeader::GetRrcTransactionIdentifier () const |
4307 { | 4886 { |
4308 return m_rrcTransactionIdentifier; | 4887 return m_rrcTransactionIdentifier; |
4309 } | 4888 } |
4310 | 4889 |
4311 LteRrcSap::RrcConnectionSetupCompleted | 4890 LteRrcSap::RrcConnectionSetupCompleted |
4312 RrcConnectionSetupCompleteHeader::GetMessage () const | 4891 RrcConnectionSetupCompleteHeader::GetMessage () const |
4313 { | 4892 { |
4314 LteRrcSap::RrcConnectionSetupCompleted msg; | 4893 LteRrcSap::RrcConnectionSetupCompleted msg; |
4315 msg.rrcTransactionIdentifier = m_rrcTransactionIdentifier; | 4894 msg.rrcTransactionIdentifier = m_rrcTransactionIdentifier; |
4316 return msg; | 4895 return msg; |
4317 } | 4896 } |
4318 | 4897 |
4319 //////////////////// RrcConnectionReconfigurationCompleteHeader class //////////
////////////// | 4898 //////////////////// RrcConnectionReconfigurationCompleteHeader class ////////
//////////////// |
4320 | 4899 |
4321 RrcConnectionReconfigurationCompleteHeader::RrcConnectionReconfigurationComplete
Header () | 4900 RrcConnectionReconfigurationCompleteHeader::RrcConnectionReconfigurationComple
teHeader () |
4322 { | 4901 { |
4323 } | 4902 } |
4324 | 4903 |
4325 RrcConnectionReconfigurationCompleteHeader::~RrcConnectionReconfigurationComplet
eHeader () | 4904 RrcConnectionReconfigurationCompleteHeader::~RrcConnectionReconfigurationCompl
eteHeader () |
4326 { | 4905 { |
4327 } | 4906 } |
4328 | 4907 |
4329 void | 4908 void |
4330 RrcConnectionReconfigurationCompleteHeader::PreSerialize () const | 4909 RrcConnectionReconfigurationCompleteHeader::PreSerialize () const |
4331 { | 4910 { |
4332 m_serializationResult = Buffer (); | 4911 m_serializationResult = Buffer (); |
4333 | 4912 |
4334 // Serialize DCCH message | 4913 // Serialize DCCH message |
4335 SerializeUlDcchMessage (2); | 4914 SerializeUlDcchMessage (2); |
4336 | 4915 |
4337 // Serialize RRCConnectionSetupComplete sequence: | 4916 // Serialize RRCConnectionSetupComplete sequence: |
4338 // no default or optional fields. Extension marker not present. | 4917 // no default or optional fields. Extension marker not present. |
4339 SerializeSequence (std::bitset<0> (),false); | 4918 SerializeSequence (std::bitset<0> (),false); |
4340 | 4919 |
4341 // Serialize rrc-TransactionIdentifier | 4920 // Serialize rrc-TransactionIdentifier |
4342 SerializeInteger (m_rrcTransactionIdentifier,0,3); | 4921 SerializeInteger (m_rrcTransactionIdentifier,0,3); |
4343 | 4922 |
4344 // Serialize criticalExtensions choice | 4923 // Serialize criticalExtensions choice |
4345 // 2 options, selected 1 (criticalExtensionsFuture) | 4924 // 2 options, selected 1 (criticalExtensionsFuture) |
4346 SerializeChoice (2,1,false); | 4925 SerializeChoice (2,1,false); |
4347 | 4926 |
4348 // Choose criticalExtensionsFuture | 4927 // Choose criticalExtensionsFuture |
4349 SerializeSequence (std::bitset<0> (),false); | 4928 SerializeSequence (std::bitset<0> (),false); |
4350 | 4929 |
4351 // Finish serialization | 4930 // Finish serialization |
4352 FinalizeSerialization (); | 4931 FinalizeSerialization (); |
4353 } | 4932 } |
4354 | 4933 |
4355 uint32_t | 4934 uint32_t |
4356 RrcConnectionReconfigurationCompleteHeader::Deserialize (Buffer::Iterator bItera
tor) | 4935 RrcConnectionReconfigurationCompleteHeader::Deserialize (Buffer::Iterator bIte
rator) |
4357 { | 4936 { |
4358 std::bitset<0> bitset0; | 4937 std::bitset<0> bitset0; |
4359 int n; | 4938 int n; |
4360 | 4939 |
4361 bIterator = DeserializeUlDcchMessage (bIterator); | 4940 bIterator = DeserializeUlDcchMessage (bIterator); |
4362 bIterator = DeserializeSequence (&bitset0,false,bIterator); | 4941 bIterator = DeserializeSequence (&bitset0,false,bIterator); |
4363 | 4942 |
4364 bIterator = DeserializeInteger (&n,0,3,bIterator); | 4943 bIterator = DeserializeInteger (&n,0,3,bIterator); |
4365 m_rrcTransactionIdentifier = n; | 4944 m_rrcTransactionIdentifier = n; |
4366 | 4945 |
4367 bIterator = DeserializeChoice (2,false,&n,bIterator); | 4946 bIterator = DeserializeChoice (2,false,&n,bIterator); |
4368 | 4947 |
4369 if (n == 1) | 4948 if (n == 1) |
4370 { | 4949 { |
4371 // Deserialize criticalExtensionsFuture | 4950 // Deserialize criticalExtensionsFuture |
4372 bIterator = DeserializeSequence (&bitset0,false,bIterator); | 4951 bIterator = DeserializeSequence (&bitset0,false,bIterator); |
4373 } | 4952 } |
4374 else if (n == 0) | 4953 else if (n == 0) |
4375 { | 4954 { |
4376 // Deserialize rrcConnectionReconfigurationComplete-r8 | 4955 // Deserialize rrcConnectionReconfigurationComplete-r8 |
4377 // ... | 4956 // ... |
4378 } | 4957 } |
4379 | 4958 |
4380 return GetSerializedSize (); | 4959 return GetSerializedSize (); |
4381 } | 4960 } |
4382 | 4961 |
4383 void | 4962 void |
4384 RrcConnectionReconfigurationCompleteHeader::Print (std::ostream &os) const | 4963 RrcConnectionReconfigurationCompleteHeader::Print (std::ostream &os) const |
4385 { | 4964 { |
4386 os << "rrcTransactionIdentifier: " << (int) m_rrcTransactionIdentifier << std:
:endl; | 4965 os << "rrcTransactionIdentifier: " << (int) m_rrcTransactionIdentifier << st
d::endl; |
4387 } | 4966 } |
4388 | 4967 |
4389 void | 4968 void |
4390 RrcConnectionReconfigurationCompleteHeader::SetMessage (LteRrcSap::RrcConnection
ReconfigurationCompleted msg) | 4969 RrcConnectionReconfigurationCompleteHeader::SetMessage (LteRrcSap::RrcConnecti
onReconfigurationCompleted msg) |
4391 { | 4970 { |
4392 m_rrcTransactionIdentifier = msg.rrcTransactionIdentifier; | 4971 m_rrcTransactionIdentifier = msg.rrcTransactionIdentifier; |
4393 m_isDataSerialized = false; | 4972 m_isDataSerialized = false; |
4394 } | 4973 } |
4395 | 4974 |
4396 LteRrcSap::RrcConnectionReconfigurationCompleted | 4975 LteRrcSap::RrcConnectionReconfigurationCompleted |
4397 RrcConnectionReconfigurationCompleteHeader::GetMessage () const | 4976 RrcConnectionReconfigurationCompleteHeader::GetMessage () const |
4398 { | 4977 { |
4399 LteRrcSap::RrcConnectionReconfigurationCompleted msg; | 4978 LteRrcSap::RrcConnectionReconfigurationCompleted msg; |
4400 msg.rrcTransactionIdentifier = m_rrcTransactionIdentifier; | 4979 msg.rrcTransactionIdentifier = m_rrcTransactionIdentifier; |
4401 return msg; | 4980 return msg; |
4402 } | 4981 } |
4403 | 4982 |
4404 uint8_t | 4983 uint8_t |
4405 RrcConnectionReconfigurationCompleteHeader::GetRrcTransactionIdentifier () const | 4984 RrcConnectionReconfigurationCompleteHeader::GetRrcTransactionIdentifier () con
st |
4406 { | 4985 { |
4407 return m_rrcTransactionIdentifier; | 4986 return m_rrcTransactionIdentifier; |
4408 } | 4987 } |
4409 | 4988 |
4410 //////////////////// RrcConnectionReconfigurationHeader class //////////////////
////// | 4989 //////////////////// RrcConnectionReconfigurationHeader class ////////////////
//////// |
4411 | 4990 |
4412 RrcConnectionReconfigurationHeader::RrcConnectionReconfigurationHeader () | 4991 RrcConnectionReconfigurationHeader::RrcConnectionReconfigurationHeader () |
4413 { | 4992 { |
4414 } | 4993 } |
4415 | 4994 |
4416 RrcConnectionReconfigurationHeader::~RrcConnectionReconfigurationHeader () | 4995 RrcConnectionReconfigurationHeader::~RrcConnectionReconfigurationHeader () |
4417 { | 4996 { |
4418 } | 4997 } |
4419 | 4998 |
4420 void | 4999 void |
4421 RrcConnectionReconfigurationHeader::PreSerialize () const | 5000 RrcConnectionReconfigurationHeader::PreSerialize () const |
4422 { | 5001 { |
4423 m_serializationResult = Buffer (); | 5002 m_serializationResult = Buffer (); |
4424 | 5003 |
4425 SerializeDlDcchMessage (4); | 5004 SerializeDlDcchMessage (4); |
4426 | 5005 |
4427 // Serialize RRCConnectionSetupComplete sequence: | 5006 // Serialize RRCConnectionSetupComplete sequence: |
4428 // no default or optional fields. Extension marker not present. | 5007 // no default or optional fields. Extension marker not present. |
4429 SerializeSequence (std::bitset<0> (),false); | 5008 SerializeSequence (std::bitset<0> (),false); |
4430 | 5009 |
4431 // Serialize rrc-TransactionIdentifier | 5010 // Serialize rrc-TransactionIdentifier |
4432 SerializeInteger (m_rrcTransactionIdentifier,0,3); | 5011 SerializeInteger (m_rrcTransactionIdentifier,0,3); |
4433 | 5012 |
4434 // Serialize criticalExtensions choice | 5013 // Serialize criticalExtensions choice |
4435 // 2 options, selected 0 (c1) | 5014 // 2 options, selected 0 (c1) |
4436 SerializeChoice (2,0,false); | 5015 SerializeChoice (2,0,false); |
4437 | 5016 |
4438 // Serialize c1 choice | 5017 // Serialize c1 choice |
4439 // 8 options, selected 0 (rrcConnectionReconfiguration-r8) | 5018 // 8 options, selected 0 (rrcConnectionReconfiguration-r8) |
4440 SerializeChoice (8,0,false); | 5019 SerializeChoice (8,0,false); |
4441 | 5020 |
4442 // Serialize RRCConnectionReconfiguration-r8-IEs sequence: | 5021 // Serialize RRCConnectionReconfiguration-r8-IEs sequence: |
4443 // 6 optional fields. Extension marker not present. | 5022 // 6 optional fields. Extension marker not present. |
4444 std::bitset<6> options; | 5023 std::bitset<6> options; |
4445 options.set (5,m_haveMeasConfig); | 5024 options.set (5,m_haveMeasConfig); |
4446 options.set (4,m_haveMobilityControlInfo); | 5025 options.set (4,m_haveMobilityControlInfo); |
4447 options.set (3,0); // No dedicatedInfoNASList | 5026 options.set (3,0); // No dedicatedInfoNASList |
4448 options.set (2,m_haveRadioResourceConfigDedicated); | 5027 options.set (2,m_haveRadioResourceConfigDedicated); |
4449 options.set (1,0); // No securityConfigHO | 5028 options.set (1,0); // No securityConfigHO |
4450 options.set (0,0); // No nonCriticalExtension | 5029 options.set (0,m_haveNonCriticalExtension); // Implemented nonCriticalExtens
ion because compatibility with R10 - CA |
4451 SerializeSequence (options,false); | 5030 SerializeSequence (options,false); |
4452 | 5031 |
4453 if (m_haveMeasConfig) | 5032 if (m_haveMeasConfig) |
4454 { | 5033 { |
4455 SerializeMeasConfig (m_measConfig); | 5034 SerializeMeasConfig (m_measConfig); |
4456 } | 5035 } |
4457 | 5036 |
4458 if (m_haveMobilityControlInfo) | 5037 if (m_haveMobilityControlInfo) |
4459 { | 5038 { |
4460 // Serialize MobilityControlInfo | 5039 // Serialize MobilityControlInfo |
4461 | 5040 |
4462 // 4 optional fields, extension marker present. | 5041 // 4 optional fields, extension marker present. |
4463 std::bitset<4> mobCtrlIntoOptional; | 5042 std::bitset<4> mobCtrlIntoOptional; |
4464 mobCtrlIntoOptional.set (3,m_mobilityControlInfo.haveCarrierFreq); | 5043 mobCtrlIntoOptional.set (3,m_mobilityControlInfo.haveCarrierFreq); |
4465 mobCtrlIntoOptional.set (2,m_mobilityControlInfo.haveCarrierBandwidth); | 5044 mobCtrlIntoOptional.set (2,m_mobilityControlInfo.haveCarrierBandwidth); |
4466 mobCtrlIntoOptional.set (1,0); // No additionalSpectrumEmission | 5045 mobCtrlIntoOptional.set (1,0); // No additionalSpectrumEmission |
4467 mobCtrlIntoOptional.set (0,m_mobilityControlInfo.haveRachConfigDedicated); | 5046 mobCtrlIntoOptional.set (0,m_mobilityControlInfo.haveRachConfigDedicated
); |
4468 SerializeSequence (mobCtrlIntoOptional,true); | 5047 SerializeSequence (mobCtrlIntoOptional,true); |
4469 | 5048 |
4470 // Serialize targetPhysCellId | 5049 // Serialize targetPhysCellId |
4471 SerializeInteger (m_mobilityControlInfo.targetPhysCellId,0,503); | 5050 SerializeInteger (m_mobilityControlInfo.targetPhysCellId,0,503); |
4472 | 5051 |
4473 if (m_mobilityControlInfo.haveCarrierFreq) | 5052 if (m_mobilityControlInfo.haveCarrierFreq) |
4474 { | 5053 { |
4475 SerializeSequence (std::bitset<1> (1),false); | 5054 SerializeSequence (std::bitset<1> (1),false); |
4476 SerializeInteger (m_mobilityControlInfo.carrierFreq.dlCarrierFreq,0,MA
X_EARFCN); | 5055 SerializeInteger (m_mobilityControlInfo.carrierFreq.dlCarrierFreq,0,
MAX_EARFCN); |
4477 SerializeInteger (m_mobilityControlInfo.carrierFreq.ulCarrierFreq,0,MA
X_EARFCN); | 5056 SerializeInteger (m_mobilityControlInfo.carrierFreq.ulCarrierFreq,0,
MAX_EARFCN); |
4478 } | 5057 } |
4479 | 5058 |
4480 if (m_mobilityControlInfo.haveCarrierBandwidth) | 5059 if (m_mobilityControlInfo.haveCarrierBandwidth) |
4481 { | 5060 { |
4482 SerializeSequence (std::bitset<1> (1),false); | 5061 SerializeSequence (std::bitset<1> (1),false); |
4483 | 5062 |
4484 // Serialize dl-Bandwidth | 5063 // Serialize dl-Bandwidth |
4485 switch (m_mobilityControlInfo.carrierBandwidth.dlBandwidth) | 5064 switch (m_mobilityControlInfo.carrierBandwidth.dlBandwidth) |
4486 { | 5065 { |
4487 case 6: | 5066 case 6: |
4488 SerializeEnum (16,0); | 5067 SerializeEnum (16,0); |
4489 break; | 5068 break; |
4490 case 15: | 5069 case 15: |
4491 SerializeEnum (16,1); | 5070 SerializeEnum (16,1); |
4492 break; | 5071 break; |
4493 case 25: | 5072 case 25: |
4494 SerializeEnum (16,2); | 5073 SerializeEnum (16,2); |
4495 break; | 5074 break; |
4496 case 50: | 5075 case 50: |
4497 SerializeEnum (16,3); | 5076 SerializeEnum (16,3); |
4498 break; | 5077 break; |
4499 case 75: | 5078 case 75: |
4500 SerializeEnum (16,4); | 5079 SerializeEnum (16,4); |
4501 break; | 5080 break; |
4502 case 100: | 5081 case 100: |
4503 SerializeEnum (16,5); | 5082 SerializeEnum (16,5); |
4504 break; | 5083 break; |
4505 default: | 5084 default: |
4506 SerializeEnum (16,6); | 5085 SerializeEnum (16,6); |
4507 } | 5086 } |
4508 | 5087 |
4509 // Serialize ul-Bandwidth | 5088 // Serialize ul-Bandwidth |
4510 switch (m_mobilityControlInfo.carrierBandwidth.ulBandwidth) | 5089 switch (m_mobilityControlInfo.carrierBandwidth.ulBandwidth) |
4511 { | 5090 { |
4512 case 6: | 5091 case 6: |
4513 SerializeEnum (16,0); | 5092 SerializeEnum (16,0); |
4514 break; | 5093 break; |
4515 case 15: | 5094 case 15: |
4516 SerializeEnum (16,1); | 5095 SerializeEnum (16,1); |
4517 break; | 5096 break; |
4518 case 25: | 5097 case 25: |
4519 SerializeEnum (16,2); | 5098 SerializeEnum (16,2); |
4520 break; | 5099 break; |
4521 case 50: | 5100 case 50: |
4522 SerializeEnum (16,3); | 5101 SerializeEnum (16,3); |
4523 break; | 5102 break; |
4524 case 75: | 5103 case 75: |
4525 SerializeEnum (16,4); | 5104 SerializeEnum (16,4); |
4526 break; | 5105 break; |
4527 case 100: | 5106 case 100: |
4528 SerializeEnum (16,5); | 5107 SerializeEnum (16,5); |
4529 break; | 5108 break; |
4530 default: | 5109 default: |
4531 SerializeEnum (16,6); | 5110 SerializeEnum (16,6); |
4532 } | 5111 } |
4533 } | 5112 } |
4534 | 5113 |
4535 // Serialize t304 | 5114 // Serialize t304 |
4536 SerializeEnum (8,0); | 5115 SerializeEnum (8,0); |
4537 | 5116 |
4538 // Serialize newUE-Identitiy | 5117 // Serialize newUE-Identitiy |
4539 SerializeBitstring (std::bitset<16> (m_mobilityControlInfo.newUeIdentity))
; | 5118 SerializeBitstring (std::bitset<16> (m_mobilityControlInfo.newUeIdentity
)); |
4540 | 5119 |
4541 // Serialize radioResourceConfigCommon | 5120 // Serialize radioResourceConfigCommon |
4542 SerializeRadioResourceConfigCommon (m_mobilityControlInfo.radioResourceCon
figCommon); | 5121 SerializeRadioResourceConfigCommon (m_mobilityControlInfo.radioResourceC
onfigCommon); |
4543 | 5122 |
4544 if (m_mobilityControlInfo.haveRachConfigDedicated) | 5123 if (m_mobilityControlInfo.haveRachConfigDedicated) |
4545 { | 5124 { |
4546 SerializeSequence (std::bitset<0> (),false); | 5125 SerializeSequence (std::bitset<0> (),false); |
4547 SerializeInteger (m_mobilityControlInfo.rachConfigDedicated.raPreamble
Index,0,63); | 5126 SerializeInteger (m_mobilityControlInfo.rachConfigDedicated.raPreamb
leIndex,0,63); |
4548 SerializeInteger (m_mobilityControlInfo.rachConfigDedicated.raPrachMas
kIndex,0,15); | 5127 SerializeInteger (m_mobilityControlInfo.rachConfigDedicated.raPrachM
askIndex,0,15); |
4549 } | 5128 } |
4550 } | 5129 } |
4551 | 5130 |
4552 if (m_haveRadioResourceConfigDedicated) | 5131 if (m_haveRadioResourceConfigDedicated) |
4553 { | 5132 { |
4554 // Serialize RadioResourceConfigDedicated | 5133 // Serialize RadioResourceConfigDedicated |
4555 SerializeRadioResourceConfigDedicated (m_radioResourceConfigDedicated); | 5134 SerializeRadioResourceConfigDedicated (m_radioResourceConfigDedicated); |
4556 } | 5135 } |
4557 | 5136 |
4558 // Finish serialization | 5137 if (m_haveNonCriticalExtension) |
4559 FinalizeSerialization (); | 5138 { |
4560 } | 5139 // Serialize NonCriticalExtension RRCConnectionReconfiguration-v890-IEs
sequence: |
4561 | 5140 // 2 optional fields. Extension marker not present. |
4562 uint32_t | 5141 std::bitset<2> noncriticalExtension_v890; |
4563 RrcConnectionReconfigurationHeader::Deserialize (Buffer::Iterator bIterator) | 5142 noncriticalExtension_v890.set (1,0); // No lateNonCriticalExtension |
4564 { | 5143 noncriticalExtension_v890.set (0,m_haveNonCriticalExtension); // Impleme
nted nonCriticalExtension because compatibility with R10 - CA |
4565 std::bitset<0> bitset0; | 5144 //Enable RRCCoonectionReconfiguration-v920-IEs |
4566 | 5145 SerializeSequence (noncriticalExtension_v890,false); |
4567 bIterator = DeserializeDlDcchMessage (bIterator); | 5146 ·········· |
4568 | 5147 // Serialize NonCriticalExtension RRCConnectionReconfiguration-v920-IEs
sequence: |
4569 // RRCConnectionReconfiguration sequence | 5148 // 3 optional fields. Extension marker not present. |
4570 bIterator = DeserializeSequence (&bitset0,false,bIterator); | 5149 std::bitset<3> noncriticalExtension_v920; |
4571 | 5150 noncriticalExtension_v920.set (1,0); // No otehrConfig-r9 |
4572 // rrc-TransactionIdentifier | 5151 noncriticalExtension_v920.set (1,0); // No fullConfig-r9 |
4573 int n; | 5152 //Enable RRCCoonectionReconfiguration-v1020-IEs |
4574 bIterator = DeserializeInteger (&n,0,3,bIterator); | 5153 noncriticalExtension_v920.set (0,m_haveNonCriticalExtension); // Impleme
nted nonCriticalExtension because compatibility with R10 - CA |
4575 m_rrcTransactionIdentifier = n; | 5154 SerializeSequence (noncriticalExtension_v920,false); |
4576 | 5155 ·········· |
4577 // criticalExtensions | 5156 SerializeNonCriticalExtensionConfiguration (m_nonCriticalExtension); //S
erializing RRCConnectionReconfiguration-r8-IEs |
4578 int sel; | 5157 } |
4579 bIterator = DeserializeChoice (2,false,&sel,bIterator); | 5158 |
4580 if (sel == 1) | 5159 // Finish serialization |
4581 { | 5160 FinalizeSerialization (); |
4582 // criticalExtensionsFuture | 5161 } |
4583 bIterator = DeserializeSequence (&bitset0,false,bIterator); | 5162 |
4584 } | 5163 uint32_t |
4585 else if (sel == 0) | 5164 RrcConnectionReconfigurationHeader::Deserialize (Buffer::Iterator bIterator) |
4586 { | 5165 { |
4587 // c1 | 5166 std::bitset<0> bitset0; |
4588 int c1Chosen; | 5167 |
4589 bIterator = DeserializeChoice (8,false,&c1Chosen,bIterator); | 5168 bIterator = DeserializeDlDcchMessage (bIterator); |
4590 if (c1Chosen > 0) | 5169 |
4591 { | 5170 // RRCConnectionReconfiguration sequence |
4592 bIterator = DeserializeNull (bIterator); | 5171 bIterator = DeserializeSequence (&bitset0,false,bIterator); |
4593 } | 5172 |
4594 else if (c1Chosen == 0) | 5173 // rrc-TransactionIdentifier |
4595 { | 5174 int n; |
4596 // rrcConnectionReconfiguration-r8 | 5175 bIterator = DeserializeInteger (&n,0,3,bIterator); |
4597 std::bitset<6> rrcConnRecOpts; | 5176 m_rrcTransactionIdentifier = n; |
4598 bIterator = DeserializeSequence (&rrcConnRecOpts,false,bIterator); | 5177 |
4599 | 5178 // criticalExtensions |
4600 m_haveMeasConfig = rrcConnRecOpts[5]; | 5179 int sel; |
4601 if (m_haveMeasConfig) | 5180 bIterator = DeserializeChoice (2,false,&sel,bIterator); |
4602 { | 5181 if (sel == 1) |
4603 bIterator = DeserializeMeasConfig (&m_measConfig, bIterator); | 5182 { |
4604 } | 5183 // criticalExtensionsFuture |
4605 | 5184 bIterator = DeserializeSequence (&bitset0,false,bIterator); |
4606 m_haveMobilityControlInfo = rrcConnRecOpts[4]; | 5185 } |
4607 if (m_haveMobilityControlInfo) | 5186 else if (sel == 0) |
4608 { | 5187 { |
4609 // mobilityControlInfo | 5188 // c1 |
4610 std::bitset<4> mobCtrlOpts; | 5189 int c1Chosen; |
4611 bIterator = DeserializeSequence (&mobCtrlOpts,true,bIterator); | 5190 bIterator = DeserializeChoice (8,false,&c1Chosen,bIterator); |
4612 | 5191 if (c1Chosen > 0) |
4613 // PhysCellId | 5192 { |
4614 bIterator = DeserializeInteger (&n,0,503,bIterator); | 5193 bIterator = DeserializeNull (bIterator); |
4615 m_mobilityControlInfo.targetPhysCellId = n; | 5194 } |
4616 | 5195 else if (c1Chosen == 0) |
4617 // carrierFreq | 5196 { |
4618 m_mobilityControlInfo.haveCarrierFreq = mobCtrlOpts[3]; | 5197 // rrcConnectionReconfiguration-r8 |
4619 if (m_mobilityControlInfo.haveCarrierFreq) | 5198 std::bitset<6> rrcConnRecOpts; |
4620 { | 5199 bIterator = DeserializeSequence (&rrcConnRecOpts,false,bIterator); |
4621 std::bitset<1> ulCarrierFreqPresent; | 5200 |
4622 bIterator = DeserializeSequence (&ulCarrierFreqPresent,false,b
Iterator); | 5201 m_haveMeasConfig = rrcConnRecOpts[5]; |
4623 | 5202 if (m_haveMeasConfig) |
4624 bIterator = DeserializeInteger (&n,0,MAX_EARFCN,bIterator); | 5203 { |
4625 m_mobilityControlInfo.carrierFreq.dlCarrierFreq = n; | 5204 bIterator = DeserializeMeasConfig (&m_measConfig, bIterator); |
4626 | 5205 } |
4627 if (ulCarrierFreqPresent[0]) | 5206 |
4628 { | 5207 m_haveMobilityControlInfo = rrcConnRecOpts[4]; |
4629 bIterator = DeserializeInteger (&n,0,MAX_EARFCN,bIterator)
; | 5208 if (m_haveMobilityControlInfo) |
4630 m_mobilityControlInfo.carrierFreq.ulCarrierFreq = n; | 5209 { |
4631 } | 5210 // mobilityControlInfo |
4632 } | 5211 std::bitset<4> mobCtrlOpts; |
4633 | 5212 bIterator = DeserializeSequence (&mobCtrlOpts,true,bIterator); |
4634 // carrierBandwidth | 5213 |
4635 m_mobilityControlInfo.haveCarrierBandwidth = mobCtrlOpts[2]; | 5214 // PhysCellId |
4636 if (m_mobilityControlInfo.haveCarrierBandwidth) | 5215 bIterator = DeserializeInteger (&n,0,503,bIterator); |
4637 { | 5216 m_mobilityControlInfo.targetPhysCellId = n; |
4638 std::bitset<1> ulBandwidthPresent; | 5217 |
4639 bIterator = DeserializeSequence (&ulBandwidthPresent,false,bIt
erator); | 5218 // carrierFreq |
4640 | 5219 m_mobilityControlInfo.haveCarrierFreq = mobCtrlOpts[3]; |
4641 bIterator = DeserializeEnum (16,&n,bIterator); | 5220 if (m_mobilityControlInfo.haveCarrierFreq) |
4642 switch (n) | 5221 { |
4643 { | 5222 std::bitset<1> ulCarrierFreqPresent; |
4644 case 0: | 5223 bIterator = DeserializeSequence (&ulCarrierFreqPresent,false
,bIterator); |
4645 m_mobilityControlInfo.carrierBandwidth.dlBandwidth = 6; | 5224 |
4646 break; | 5225 bIterator = DeserializeInteger (&n,0,MAX_EARFCN,bIterator); |
4647 case 1: | 5226 m_mobilityControlInfo.carrierFreq.dlCarrierFreq = n; |
4648 m_mobilityControlInfo.carrierBandwidth.dlBandwidth = 15; | 5227 |
4649 break; | 5228 if (ulCarrierFreqPresent[0]) |
4650 case 2: | 5229 { |
4651 m_mobilityControlInfo.carrierBandwidth.dlBandwidth = 25; | 5230 bIterator = DeserializeInteger (&n,0,MAX_EARFCN,bIterato
r); |
4652 break; | 5231 m_mobilityControlInfo.carrierFreq.ulCarrierFreq = n; |
4653 case 3: | 5232 } |
4654 m_mobilityControlInfo.carrierBandwidth.dlBandwidth = 50; | 5233 } |
4655 break; | 5234 |
4656 case 4: | 5235 // carrierBandwidth |
4657 m_mobilityControlInfo.carrierBandwidth.dlBandwidth = 75; | 5236 m_mobilityControlInfo.haveCarrierBandwidth = mobCtrlOpts[2]; |
4658 break; | 5237 if (m_mobilityControlInfo.haveCarrierBandwidth) |
4659 case 5: | 5238 { |
4660 m_mobilityControlInfo.carrierBandwidth.dlBandwidth = 100; | 5239 std::bitset<1> ulBandwidthPresent; |
4661 break; | 5240 bIterator = DeserializeSequence (&ulBandwidthPresent,false,b
Iterator); |
4662 case 6: | 5241 |
4663 m_mobilityControlInfo.carrierBandwidth.dlBandwidth = 0; | 5242 bIterator = DeserializeEnum (16,&n,bIterator); |
4664 break; | 5243 switch (n) |
4665 } | 5244 { |
4666 | 5245 case 0: |
4667 if (ulBandwidthPresent[0]) | 5246 m_mobilityControlInfo.carrierBandwidth.dlBandwidth = 6; |
4668 { | 5247 break; |
4669 bIterator = DeserializeEnum (16,&n,bIterator); | 5248 case 1: |
4670 switch (n) | 5249 m_mobilityControlInfo.carrierBandwidth.dlBandwidth = 15; |
4671 { | 5250 break; |
4672 case 0: | 5251 case 2: |
4673 m_mobilityControlInfo.carrierBandwidth.ulBandwidth = 6
; | 5252 m_mobilityControlInfo.carrierBandwidth.dlBandwidth = 25; |
4674 break; | 5253 break; |
4675 case 1: | 5254 case 3: |
4676 m_mobilityControlInfo.carrierBandwidth.ulBandwidth = 1
5; | 5255 m_mobilityControlInfo.carrierBandwidth.dlBandwidth = 50; |
4677 break; | 5256 break; |
4678 case 2: | 5257 case 4: |
4679 m_mobilityControlInfo.carrierBandwidth.ulBandwidth = 2
5; | 5258 m_mobilityControlInfo.carrierBandwidth.dlBandwidth = 75; |
4680 break; | 5259 break; |
4681 case 3: | 5260 case 5: |
4682 m_mobilityControlInfo.carrierBandwidth.ulBandwidth = 5
0; | 5261 m_mobilityControlInfo.carrierBandwidth.dlBandwidth = 100
; |
4683 break; | 5262 break; |
4684 case 4: | 5263 case 6: |
4685 m_mobilityControlInfo.carrierBandwidth.ulBandwidth = 7
5; | 5264 m_mobilityControlInfo.carrierBandwidth.dlBandwidth = 0; |
4686 break; | 5265 break; |
4687 case 5: | 5266 } |
4688 m_mobilityControlInfo.carrierBandwidth.ulBandwidth = 1
00; | 5267 |
4689 break; | 5268 if (ulBandwidthPresent[0]) |
4690 case 6: | 5269 { |
4691 m_mobilityControlInfo.carrierBandwidth.ulBandwidth = 0
; | 5270 bIterator = DeserializeEnum (16,&n,bIterator); |
4692 break; | 5271 switch (n) |
4693 } | 5272 { |
4694 } | 5273 case 0: |
4695 } | 5274 m_mobilityControlInfo.carrierBandwidth.ulBandwidth =
6; |
4696 | 5275 break; |
4697 // additionalSpectrumEmission | 5276 case 1: |
4698 if (mobCtrlOpts[1]) | 5277 m_mobilityControlInfo.carrierBandwidth.ulBandwidth =
15; |
4699 { | 5278 break; |
4700 // ... | 5279 case 2: |
4701 } | 5280 m_mobilityControlInfo.carrierBandwidth.ulBandwidth =
25; |
4702 | 5281 break; |
4703 // t304 | 5282 case 3: |
4704 bIterator = DeserializeEnum (8,&n,bIterator); | 5283 m_mobilityControlInfo.carrierBandwidth.ulBandwidth =
50; |
4705 | 5284 break; |
4706 // newUE-Identity | 5285 case 4: |
4707 std::bitset<16> cRnti; | 5286 m_mobilityControlInfo.carrierBandwidth.ulBandwidth =
75; |
4708 bIterator = DeserializeBitstring (&cRnti, bIterator); | 5287 break; |
4709 m_mobilityControlInfo.newUeIdentity = cRnti.to_ulong (); | 5288 case 5: |
4710 | 5289 m_mobilityControlInfo.carrierBandwidth.ulBandwidth =
100; |
4711 // radioResourceConfigCommon | 5290 break; |
4712 bIterator = DeserializeRadioResourceConfigCommon (&m_mobilityContr
olInfo.radioResourceConfigCommon, bIterator); | 5291 case 6: |
4713 | 5292 m_mobilityControlInfo.carrierBandwidth.ulBandwidth =
0; |
4714 m_mobilityControlInfo.haveRachConfigDedicated = mobCtrlOpts[0]; | 5293 break; |
4715 if (m_mobilityControlInfo.haveRachConfigDedicated) | 5294 } |
4716 { | 5295 } |
4717 bIterator = DeserializeSequence (&bitset0, false, bIterator); | 5296 } |
4718 bIterator = DeserializeInteger (&n,0,63, bIterator); | 5297 |
4719 m_mobilityControlInfo.rachConfigDedicated.raPreambleIndex = n; | 5298 // additionalSpectrumEmission |
4720 bIterator = DeserializeInteger (&n,0,15, bIterator); | 5299 if (mobCtrlOpts[1]) |
4721 m_mobilityControlInfo.rachConfigDedicated.raPrachMaskIndex = n
; | 5300 { |
4722 } | 5301 // ... |
4723 } | 5302 } |
4724 | 5303 |
4725 // dedicatedInfoNASList | 5304 // t304 |
4726 if (rrcConnRecOpts[3]) | 5305 bIterator = DeserializeEnum (8,&n,bIterator); |
4727 { | 5306 |
4728 // ... | 5307 // newUE-Identity |
4729 } | 5308 std::bitset<16> cRnti; |
4730 | 5309 bIterator = DeserializeBitstring (&cRnti, bIterator); |
4731 // radioResourceConfigDedicated | 5310 m_mobilityControlInfo.newUeIdentity = cRnti.to_ulong (); |
4732 m_haveRadioResourceConfigDedicated = rrcConnRecOpts[2]; | 5311 |
4733 if (m_haveRadioResourceConfigDedicated) | 5312 // radioResourceConfigCommon |
4734 { | 5313 bIterator = DeserializeRadioResourceConfigCommon (&m_mobilityCon
trolInfo.radioResourceConfigCommon, bIterator); |
4735 bIterator = DeserializeRadioResourceConfigDedicated (&m_radioResou
rceConfigDedicated,bIterator); | 5314 |
4736 } | 5315 m_mobilityControlInfo.haveRachConfigDedicated = mobCtrlOpts[0]; |
4737 | 5316 if (m_mobilityControlInfo.haveRachConfigDedicated) |
4738 // securityConfigHO | 5317 { |
4739 if (rrcConnRecOpts[1]) | 5318 bIterator = DeserializeSequence (&bitset0, false, bIterator)
; |
4740 { | 5319 bIterator = DeserializeInteger (&n,0,63, bIterator); |
4741 // ... | 5320 m_mobilityControlInfo.rachConfigDedicated.raPreambleIndex =
n; |
4742 } | 5321 bIterator = DeserializeInteger (&n,0,15, bIterator); |
4743 | 5322 m_mobilityControlInfo.rachConfigDedicated.raPrachMaskIndex =
n; |
4744 // nonCriticalExtension | 5323 } |
4745 if (rrcConnRecOpts[0]) | 5324 } |
4746 { | 5325 |
4747 // ... | 5326 // dedicatedInfoNASList |
4748 } | 5327 if (rrcConnRecOpts[3]) |
4749 } | 5328 { |
4750 } | 5329 // ... |
4751 | 5330 } |
4752 return GetSerializedSize (); | 5331 |
4753 } | 5332 // radioResourceConfigDedicated |
4754 | 5333 m_haveRadioResourceConfigDedicated = rrcConnRecOpts[2]; |
4755 void | 5334 if (m_haveRadioResourceConfigDedicated) |
4756 RrcConnectionReconfigurationHeader::Print (std::ostream &os) const | 5335 { |
4757 { | 5336 bIterator = DeserializeRadioResourceConfigDedicated (&m_radioRes
ourceConfigDedicated,bIterator); |
4758 os << "rrcTransactionIdentifier: " << (int) m_rrcTransactionIdentifier << std:
:endl; | 5337 } |
4759 os << "haveMeasConfig: " << m_haveMeasConfig << std::endl; | 5338 |
4760 if (m_haveMeasConfig) | 5339 // securityConfigHO |
4761 { | 5340 if (rrcConnRecOpts[1]) |
4762 if (!m_measConfig.measObjectToRemoveList.empty ()) | 5341 { |
4763 { | 5342 // ... |
4764 os << " measObjectToRemoveList: "; | 5343 } |
4765 std::list<uint8_t> auxList = m_measConfig.measObjectToRemoveList; | 5344 // nonCriticalExtension··· |
4766 std::list<uint8_t>::iterator it = auxList.begin (); | 5345 m_haveNonCriticalExtension = rrcConnRecOpts[0]; |
4767 for (; it != auxList.end (); it++) | 5346 if (m_haveNonCriticalExtension) |
4768 { | 5347 { |
4769 os << (int) *it << ", "; | 5348 // implemented during GSoC 2015 |
4770 } | 5349 bIterator = DeserializeNonCriticalExtensionConfig (&m_nonCritica
lExtension,bIterator); |
4771 os << std::endl; | 5350 |
4772 } | 5351 |
4773 if (!m_measConfig.reportConfigToRemoveList.empty ()) | 5352 } |
4774 { | 5353 } |
4775 os << " reportConfigToRemoveList: "; | 5354 } |
4776 std::list<uint8_t> auxList = m_measConfig.reportConfigToRemoveList; | 5355 |
4777 std::list<uint8_t>::iterator it = auxList.begin (); | 5356 return GetSerializedSize (); |
4778 for (; it != auxList.end (); it++) | 5357 } |
4779 { | 5358 |
4780 os << (int) *it << ", "; | 5359 void |
4781 } | 5360 RrcConnectionReconfigurationHeader::Print (std::ostream &os) const |
4782 os << std::endl; | 5361 { |
4783 } | 5362 os << "rrcTransactionIdentifier: " << (int) m_rrcTransactionIdentifier << st
d::endl; |
4784 if (!m_measConfig.measIdToRemoveList.empty ()) | 5363 os << "haveMeasConfig: " << m_haveMeasConfig << std::endl; |
4785 { | 5364 if (m_haveMeasConfig) |
4786 os << " measIdToRemoveList: "; | 5365 { |
4787 std::list<uint8_t> auxList = m_measConfig.measIdToRemoveList; | 5366 if (!m_measConfig.measObjectToRemoveList.empty ()) |
4788 std::list<uint8_t>::iterator it = auxList.begin (); | 5367 { |
4789 for (; it != auxList.end (); it++) | 5368 os << " measObjectToRemoveList: "; |
4790 { | 5369 std::list<uint8_t> auxList = m_measConfig.measObjectToRemoveList; |
4791 os << (int) *it << ", "; | 5370 std::list<uint8_t>::iterator it = auxList.begin (); |
4792 } | 5371 for (; it != auxList.end (); it++) |
4793 os << std::endl; | 5372 { |
4794 } | 5373 os << (int) *it << ", "; |
4795 | 5374 } |
4796 if (!m_measConfig.measObjectToAddModList.empty ()) | 5375 os << std::endl; |
4797 { | 5376 } |
4798 os << " measObjectToAddMod: " << std::endl; | 5377 if (!m_measConfig.reportConfigToRemoveList.empty ()) |
4799 std::list<LteRrcSap::MeasObjectToAddMod> auxList = m_measConfig.measOb
jectToAddModList; | 5378 { |
4800 std::list<LteRrcSap::MeasObjectToAddMod>::iterator it = auxList.begin
(); | 5379 os << " reportConfigToRemoveList: "; |
4801 for (; it != auxList.end (); it++) | 5380 std::list<uint8_t> auxList = m_measConfig.reportConfigToRemoveList; |
4802 { | 5381 std::list<uint8_t>::iterator it = auxList.begin (); |
4803 os << " measObjectId: " << (int)it->measObjectId << std::endl; | 5382 for (; it != auxList.end (); it++) |
4804 os << " carrierFreq: " << (int)it->measObjectEutra.carrierFreq
<< std::endl; | 5383 { |
4805 os << " allowedMeasBandwidth: " << (int)it->measObjectEutra.al
lowedMeasBandwidth << std::endl; | 5384 os << (int) *it << ", "; |
4806 os << " presenceAntennaPort1: " << it->measObjectEutra.presenc
eAntennaPort1 << std::endl; | 5385 } |
4807 os << " neighCellConfig: " << (int) it->measObjectEutra.neighCe
llConfig << std::endl; | 5386 os << std::endl; |
4808 os << " offsetFreq: " << (int)it->measObjectEutra.offsetFreq
<< std::endl; | 5387 } |
4809 | 5388 if (!m_measConfig.measIdToRemoveList.empty ()) |
4810 | 5389 { |
4811 if (!it->measObjectEutra.cellsToRemoveList.empty ()) | 5390 os << " measIdToRemoveList: "; |
4812 { | 5391 std::list<uint8_t> auxList = m_measConfig.measIdToRemoveList; |
4813 os << " cellsToRemoveList: "; | 5392 std::list<uint8_t>::iterator it = auxList.begin (); |
4814 std::list<uint8_t> auxList = it->measObjectEutra.cellsToRemove
List; | 5393 for (; it != auxList.end (); it++) |
4815 std::list<uint8_t>::iterator it = auxList.begin (); | 5394 { |
4816 for (; it != auxList.end (); it++) | 5395 os << (int) *it << ", "; |
4817 { | 5396 } |
4818 os << (int) *it << ", "; | 5397 os << std::endl; |
4819 } | 5398 } |
4820 os << std::endl; | 5399 |
4821 } | 5400 if (!m_measConfig.measObjectToAddModList.empty ()) |
4822 | 5401 { |
4823 if (!it->measObjectEutra.blackCellsToRemoveList.empty ()) | 5402 os << " measObjectToAddMod: " << std::endl; |
4824 { | 5403 std::list<LteRrcSap::MeasObjectToAddMod> auxList = m_measConfig.meas
ObjectToAddModList; |
4825 os << " blackCellsToRemoveList: "; | 5404 std::list<LteRrcSap::MeasObjectToAddMod>::iterator it = auxList.begi
n (); |
4826 std::list<uint8_t> auxList = it->measObjectEutra.blackCellsToR
emoveList; | 5405 for (; it != auxList.end (); it++) |
4827 std::list<uint8_t>::iterator it = auxList.begin (); | 5406 { |
4828 for (; it != auxList.end (); it++) | 5407 os << " measObjectId: " << (int)it->measObjectId << std::endl
; |
4829 { | 5408 os << " carrierFreq: " << (int)it->measObjectEutra.carrierFre
q << std::endl; |
4830 os << (int) *it << ", "; | 5409 os << " allowedMeasBandwidth: " << (int)it->measObjectEutra.
allowedMeasBandwidth << std::endl; |
4831 } | 5410 os << " presenceAntennaPort1: " << it->measObjectEutra.prese
nceAntennaPort1 << std::endl; |
4832 os << std::endl; | 5411 os << " neighCellConfig: " << (int) it->measObjectEutra.neigh
CellConfig << std::endl; |
4833 } | 5412 os << " offsetFreq: " << (int)it->measObjectEutra.offsetFreq
<< std::endl; |
4834 | 5413 |
4835 if (!it->measObjectEutra.cellsToAddModList.empty ()) | 5414 |
4836 { | 5415 if (!it->measObjectEutra.cellsToRemoveList.empty ()) |
4837 os << " cellsToAddModList: " << std::endl; | 5416 { |
4838 std::list<LteRrcSap::CellsToAddMod> auxList = it->measObjectEu
tra.cellsToAddModList; | 5417 os << " cellsToRemoveList: "; |
4839 std::list<LteRrcSap::CellsToAddMod>::iterator it = auxList.beg
in (); | 5418 std::list<uint8_t> auxList = it->measObjectEutra.cellsToRemo
veList; |
4840 for (; it != auxList.end (); it++) | 5419 std::list<uint8_t>::iterator it = auxList.begin (); |
4841 { | 5420 for (; it != auxList.end (); it++) |
4842 os << " cellIndex: " << (int)it->cellIndex << std::e
ndl; | 5421 { |
4843 os << " physCellId: " << (int)it->physCellId << std
::endl; | 5422 os << (int) *it << ", "; |
4844 os << " cellIndividualOffset: " << (int)it->cellIndi
vidualOffset << std::endl; | 5423 } |
4845 os << " ------ " << std::endl; | 5424 os << std::endl; |
4846 } | 5425 } |
4847 } | 5426 |
4848 | 5427 if (!it->measObjectEutra.blackCellsToRemoveList.empty ()) |
4849 if (!it->measObjectEutra.blackCellsToAddModList.empty ()) | 5428 { |
4850 { | 5429 os << " blackCellsToRemoveList: "; |
4851 os << " blackCellsToAddModList: " << std::endl; | 5430 std::list<uint8_t> auxList = it->measObjectEutra.blackCellsT
oRemoveList; |
4852 std::list<LteRrcSap::BlackCellsToAddMod> auxList = it->measObj
ectEutra.blackCellsToAddModList; | 5431 std::list<uint8_t>::iterator it = auxList.begin (); |
4853 std::list<LteRrcSap::BlackCellsToAddMod>::iterator it = auxLis
t.begin (); | 5432 for (; it != auxList.end (); it++) |
4854 for (; it != auxList.end (); it++) | 5433 { |
4855 { | 5434 os << (int) *it << ", "; |
4856 os << " cellIndex: " << (int)it->cellIndex << std::e
ndl; | 5435 } |
4857 os << " physCellIdRange.start: " << (int)it->physCel
lIdRange.start << std::endl; | 5436 os << std::endl; |
4858 os << " physCellIdRange.haveRange: " << it->physCell
IdRange.haveRange << std::endl; | 5437 } |
4859 os << " physCellIdRange.range: " << (int)it->physCel
lIdRange.range << std::endl; | 5438 |
4860 os << " ------ " << std::endl; | 5439 if (!it->measObjectEutra.cellsToAddModList.empty ()) |
4861 } | 5440 { |
4862 } | 5441 os << " cellsToAddModList: " << std::endl; |
4863 | 5442 std::list<LteRrcSap::CellsToAddMod> auxList = it->measObject
Eutra.cellsToAddModList; |
4864 os << " haveCellForWhichToReportCGI: " << it->measObjectEutra.
haveCellForWhichToReportCGI << std::endl; | 5443 std::list<LteRrcSap::CellsToAddMod>::iterator it = auxList.b
egin (); |
4865 os << " cellForWhichToReportCGI: " << (int)it->measObjectEutra
.cellForWhichToReportCGI << std::endl; | 5444 for (; it != auxList.end (); it++) |
4866 os << " ------------- " << std::endl; | 5445 { |
4867 } | 5446 os << " cellIndex: " << (int)it->cellIndex << std:
:endl; |
4868 | 5447 os << " physCellId: " << (int)it->physCellId << s
td::endl; |
4869 } | 5448 os << " cellIndividualOffset: " << (int)it->cellIn
dividualOffset << std::endl; |
4870 | 5449 os << " ------ " << std::endl; |
4871 if (!m_measConfig.reportConfigToAddModList.empty ()) | 5450 } |
4872 { | 5451 } |
4873 os << " reportConfigToAddModList: " << std::endl; | 5452 |
4874 std::list<LteRrcSap::ReportConfigToAddMod> auxList = m_measConfig.repo
rtConfigToAddModList; | 5453 if (!it->measObjectEutra.blackCellsToAddModList.empty ()) |
4875 std::list<LteRrcSap::ReportConfigToAddMod>::iterator it = auxList.begi
n (); | 5454 { |
4876 for (; it != auxList.end (); it++) | 5455 os << " blackCellsToAddModList: " << std::endl; |
4877 { | 5456 std::list<LteRrcSap::BlackCellsToAddMod> auxList = it->measO
bjectEutra.blackCellsToAddModList; |
4878 os << " reportConfigId: " << (int)it->reportConfigId << std::en
dl; | 5457 std::list<LteRrcSap::BlackCellsToAddMod>::iterator it = auxL
ist.begin (); |
4879 os << " reportConfigEutra.triggerType " << (int)it->reportCon
figEutra.triggerType << std::endl; | 5458 for (; it != auxList.end (); it++) |
4880 if (it->reportConfigEutra.triggerType == LteRrcSap::ReportConfigEu
tra::EVENT) | 5459 { |
4881 { | 5460 os << " cellIndex: " << (int)it->cellIndex << std:
:endl; |
4882 os << " reportConfigEutra.eventId " << (int)it->reportCon
figEutra.eventId << std::endl; | 5461 os << " physCellIdRange.start: " << (int)it->physC
ellIdRange.start << std::endl; |
4883 if (it->reportConfigEutra.eventId == LteRrcSap::ReportConfigEu
tra::EVENT_A3) | 5462 os << " physCellIdRange.haveRange: " << it->physCe
llIdRange.haveRange << std::endl; |
4884 { | 5463 os << " physCellIdRange.range: " << (int)it->physC
ellIdRange.range << std::endl; |
4885 os << " reportConfigEutra.reportOnLeave " << (int)it-
>reportConfigEutra.reportOnLeave << std::endl; | 5464 os << " ------ " << std::endl; |
4886 os << " reportConfigEutra.a3Offset " << (int)it->repo
rtConfigEutra.a3Offset << std::endl; | 5465 } |
4887 } | 5466 } |
4888 else | 5467 |
4889 { | 5468 os << " haveCellForWhichToReportCGI: " << it->measObjectEutr
a.haveCellForWhichToReportCGI << std::endl; |
4890 os << " reportConfigEutra.threshold1.choice " << (int
)it->reportConfigEutra.threshold1.choice << std::endl; | 5469 os << " cellForWhichToReportCGI: " << (int)it->measObjectEut
ra.cellForWhichToReportCGI << std::endl; |
4891 os << " reportConfigEutra.threshold1.range " << (int)
it->reportConfigEutra.threshold1.range << std::endl; | 5470 os << " ------------- " << std::endl; |
4892 if (it->reportConfigEutra.eventId == LteRrcSap::ReportConf
igEutra::EVENT_A5) | 5471 } |
4893 { | 5472 |
4894 os << " reportConfigEutra.threshold2.choice " <<
(int)it->reportConfigEutra.threshold2.choice << std::endl; | 5473 } |
4895 os << " reportConfigEutra.threshold2.range " << (
int)it->reportConfigEutra.threshold2.range << std::endl; | 5474 |
4896 } | 5475 if (!m_measConfig.reportConfigToAddModList.empty ()) |
4897 } | 5476 { |
4898 os << " reportConfigEutra.hysteresis " << (int)it->report
ConfigEutra.hysteresis << std::endl; | 5477 os << " reportConfigToAddModList: " << std::endl; |
4899 os << " reportConfigEutra.timeToTrigger " << (int)it->rep
ortConfigEutra.timeToTrigger << std::endl; | 5478 std::list<LteRrcSap::ReportConfigToAddMod> auxList = m_measConfig.re
portConfigToAddModList; |
4900 } | 5479 std::list<LteRrcSap::ReportConfigToAddMod>::iterator it = auxList.be
gin (); |
4901 else | 5480 for (; it != auxList.end (); it++) |
4902 { | 5481 { |
4903 os << " reportConfigEutra.purpose " << (int)it->reportCon
figEutra.purpose << std::endl; | 5482 os << " reportConfigId: " << (int)it->reportConfigId << std::
endl; |
4904 } | 5483 os << " reportConfigEutra.triggerType " << (int)it->reportC
onfigEutra.triggerType << std::endl; |
4905 os << " reportConfigEutra.triggerQuantity " << (int)it->repor
tConfigEutra.triggerQuantity << std::endl; | 5484 if (it->reportConfigEutra.triggerType == LteRrcSap::ReportConfig
Eutra::EVENT) |
4906 os << " reportConfigEutra.reportQuantity " << (int)it->report
ConfigEutra.reportQuantity << std::endl; | 5485 { |
4907 os << " reportConfigEutra.maxReportCells " << (int)it->report
ConfigEutra.maxReportCells << std::endl; | 5486 os << " reportConfigEutra.eventId " << (int)it->reportC
onfigEutra.eventId << std::endl; |
4908 os << " reportConfigEutra.reportInterval " << (int)it->report
ConfigEutra.reportInterval << std::endl; | 5487 if (it->reportConfigEutra.eventId == LteRrcSap::ReportConfig
Eutra::EVENT_A3) |
4909 os << " reportConfigEutra.reportAmount " << (int)it->reportCo
nfigEutra.reportAmount << std::endl; | 5488 { |
4910 } | 5489 os << " reportConfigEutra.reportOnLeave " << (int)i
t->reportConfigEutra.reportOnLeave << std::endl; |
4911 } | 5490 os << " reportConfigEutra.a3Offset " << (int)it->re
portConfigEutra.a3Offset << std::endl; |
4912 | 5491 } |
4913 if (!m_measConfig.measIdToAddModList.empty ()) | 5492 else |
4914 { | 5493 { |
4915 os << " measIdToAddModList: " << std::endl; | 5494 os << " reportConfigEutra.threshold1.choice " << (i
nt)it->reportConfigEutra.threshold1.choice << std::endl; |
4916 std::list<LteRrcSap::MeasIdToAddMod> auxList = m_measConfig.measIdToAd
dModList; | 5495 os << " reportConfigEutra.threshold1.range " << (in
t)it->reportConfigEutra.threshold1.range << std::endl; |
4917 std::list<LteRrcSap::MeasIdToAddMod>::iterator it = auxList.begin (); | 5496 if (it->reportConfigEutra.eventId == LteRrcSap::ReportCo
nfigEutra::EVENT_A5) |
4918 for (; it != auxList.end (); it++) | 5497 { |
4919 { | 5498 os << " reportConfigEutra.threshold2.choice " <<
(int)it->reportConfigEutra.threshold2.choice << std::endl; |
4920 os << " measId: " << (int)it->measId << std::endl; | 5499 os << " reportConfigEutra.threshold2.range " <<
(int)it->reportConfigEutra.threshold2.range << std::endl; |
4921 os << " measObjectId: " << (int)it->measObjectId << std::endl; | 5500 } |
4922 os << " reportConfigId: " << (int)it->reportConfigId << std::en
dl; | 5501 } |
4923 os << " ------ " << std::endl; | 5502 os << " reportConfigEutra.hysteresis " << (int)it->repo
rtConfigEutra.hysteresis << std::endl; |
4924 } | 5503 os << " reportConfigEutra.timeToTrigger " << (int)it->r
eportConfigEutra.timeToTrigger << std::endl; |
4925 } | 5504 } |
4926 | 5505 else |
4927 os << " haveQuantityConfig: " << m_measConfig.haveQuantityConfig << std::
endl; | 5506 { |
4928 if (m_measConfig.haveQuantityConfig) | 5507 os << " reportConfigEutra.purpose " << (int)it->reportC
onfigEutra.purpose << std::endl; |
4929 { | 5508 } |
4930 os << " filterCoefficientRSRP: " << (int)m_measConfig.quantityConfi
g.filterCoefficientRSRP << std::endl; | 5509 os << " reportConfigEutra.triggerQuantity " << (int)it->rep
ortConfigEutra.triggerQuantity << std::endl; |
4931 os << " filterCoefficientRSRQ:" << (int)m_measConfig.quantityConfig
.filterCoefficientRSRQ << std::endl; | 5510 os << " reportConfigEutra.reportQuantity " << (int)it->repo
rtConfigEutra.reportQuantity << std::endl; |
4932 } | 5511 os << " reportConfigEutra.maxReportCells " << (int)it->repo
rtConfigEutra.maxReportCells << std::endl; |
4933 | 5512 os << " reportConfigEutra.reportInterval " << (int)it->repo
rtConfigEutra.reportInterval << std::endl; |
4934 os << " haveMeasGapConfig: " << m_measConfig.haveMeasGapConfig << std::en
dl; | 5513 os << " reportConfigEutra.reportAmount " << (int)it->report
ConfigEutra.reportAmount << std::endl; |
4935 if (m_measConfig.haveMeasGapConfig) | 5514 } |
4936 { | 5515 } |
4937 os << " measGapConfig.type: " << m_measConfig.measGapConfig.type <<
std::endl; | 5516 |
4938 os << " measGapConfig.gap (gap0/1,value): (" << m_measConfig.measGa
pConfig.gapOffsetChoice | 5517 if (!m_measConfig.measIdToAddModList.empty ()) |
4939 << "," << (int) m_measConfig.measGapConfig.gapOffsetValue << ")" <<
std::endl; | 5518 { |
4940 } | 5519 os << " measIdToAddModList: " << std::endl; |
4941 | 5520 std::list<LteRrcSap::MeasIdToAddMod> auxList = m_measConfig.measIdTo
AddModList; |
4942 os << " haveSmeasure: " << m_measConfig.haveSmeasure << std::endl; | 5521 std::list<LteRrcSap::MeasIdToAddMod>::iterator it = auxList.begin ()
; |
4943 if (m_measConfig.haveSmeasure) | 5522 for (; it != auxList.end (); it++) |
4944 { | 5523 { |
4945 os << " sMeasure: " << (int) m_measConfig.sMeasure << std::endl; | 5524 os << " measId: " << (int)it->measId << std::endl; |
4946 } | 5525 os << " measObjectId: " << (int)it->measObjectId << std::endl
; |
4947 | 5526 os << " reportConfigId: " << (int)it->reportConfigId << std::
endl; |
4948 os << " haveSpeedStatePars: " << m_measConfig.haveSpeedStatePars << std::
endl; | 5527 os << " ------ " << std::endl; |
4949 if (m_measConfig.haveSpeedStatePars) | 5528 } |
4950 { | 5529 } |
4951 os << " speedStatePars.type: " << m_measConfig.speedStatePars.type
<< std::endl; | 5530 |
4952 os << " speedStatePars.mobilityStateParameters.tEvaluation: " << (i
nt)m_measConfig.speedStatePars.mobilityStateParameters.tEvaluation << std::endl; | 5531 os << " haveQuantityConfig: " << m_measConfig.haveQuantityConfig << std
::endl; |
4953 os << " speedStatePars.mobilityStateParameters.tHystNormal: " << (i
nt)m_measConfig.speedStatePars.mobilityStateParameters.tHystNormal << std::endl; | 5532 if (m_measConfig.haveQuantityConfig) |
4954 os << " speedStatePars.mobilityStateParameters.nCellChangeMedium: "
<< (int)m_measConfig.speedStatePars.mobilityStateParameters.nCellChangeMedium <
< std::endl; | 5533 { |
4955 os << " speedStatePars.mobilityStateParameters.nCellChangeHigh: " <
< (int)m_measConfig.speedStatePars.mobilityStateParameters.nCellChangeHigh << st
d::endl; | 5534 os << " filterCoefficientRSRP: " << (int)m_measConfig.quantityCon
fig.filterCoefficientRSRP << std::endl; |
4956 os << " speedStatePars.timeToTriggerSf.sfMedium: " << (int)m_measCo
nfig.speedStatePars.timeToTriggerSf.sfMedium << std::endl; | 5535 os << " filterCoefficientRSRQ:" << (int)m_measConfig.quantityConf
ig.filterCoefficientRSRQ << std::endl; |
4957 os << " speedStatePars.timeToTriggerSf.sfHigh: " << (int)m_measConf
ig.speedStatePars.timeToTriggerSf.sfHigh << std::endl; | 5536 } |
4958 } | 5537 |
4959 } | 5538 os << " haveMeasGapConfig: " << m_measConfig.haveMeasGapConfig << std::
endl; |
4960 | 5539 if (m_measConfig.haveMeasGapConfig) |
4961 os << "haveMobilityControlInfo: " << m_haveMobilityControlInfo << std::endl; | 5540 { |
4962 if (m_haveMobilityControlInfo) | 5541 os << " measGapConfig.type: " << m_measConfig.measGapConfig.type
<< std::endl; |
4963 { | 5542 os << " measGapConfig.gap (gap0/1,value): (" << m_measConfig.meas
GapConfig.gapOffsetChoice |
4964 os << "targetPhysCellId: " << (int)m_mobilityControlInfo.targetPhysCellId
<< std::endl; | 5543 << "," << (int) m_measConfig.measGapConfig.gapOffsetValue << ")"
<< std::endl; |
4965 os << "haveCarrierFreq: " << m_mobilityControlInfo.haveCarrierFreq << std:
:endl; | 5544 } |
4966 if (m_mobilityControlInfo.haveCarrierFreq) | 5545 |
4967 { | 5546 os << " haveSmeasure: " << m_measConfig.haveSmeasure << std::endl; |
4968 os << " carrierFreq.dlCarrierFreq: " << (int) m_mobilityControlInfo.c
arrierFreq.dlCarrierFreq << std::endl; | 5547 if (m_measConfig.haveSmeasure) |
4969 os << " carrierFreq.dlCarrierFreq: " << (int) m_mobilityControlInfo.c
arrierFreq.ulCarrierFreq << std::endl; | 5548 { |
4970 } | 5549 os << " sMeasure: " << (int) m_measConfig.sMeasure << std::endl; |
4971 os << "haveCarrierBandwidth: " << m_mobilityControlInfo.haveCarrierBandwid
th << std::endl; | 5550 } |
4972 if (m_mobilityControlInfo.haveCarrierBandwidth) | 5551 |
4973 { | 5552 os << " haveSpeedStatePars: " << m_measConfig.haveSpeedStatePars << std
::endl; |
4974 os << " carrierBandwidth.dlBandwidth: " << (int) m_mobilityControlInf
o.carrierBandwidth.dlBandwidth << std::endl; | 5553 if (m_measConfig.haveSpeedStatePars) |
4975 os << " carrierBandwidth.ulBandwidth: " << (int) m_mobilityControlInf
o.carrierBandwidth.ulBandwidth << std::endl; | 5554 { |
4976 } | 5555 os << " speedStatePars.type: " << m_measConfig.speedStatePars.typ
e << std::endl; |
4977 os << "newUeIdentity: " << (int) m_mobilityControlInfo.newUeIdentity << st
d::endl; | 5556 os << " speedStatePars.mobilityStateParameters.tEvaluation: " <<
(int)m_measConfig.speedStatePars.mobilityStateParameters.tEvaluation << std::end
l; |
4978 os << "haveRachConfigDedicated: " << m_mobilityControlInfo.haveRachConfigD
edicated << std::endl; | 5557 os << " speedStatePars.mobilityStateParameters.tHystNormal: " <<
(int)m_measConfig.speedStatePars.mobilityStateParameters.tHystNormal << std::end
l; |
4979 if (m_mobilityControlInfo.haveRachConfigDedicated) | 5558 os << " speedStatePars.mobilityStateParameters.nCellChangeMedium:
" << (int)m_measConfig.speedStatePars.mobilityStateParameters.nCellChangeMedium
<< std::endl; |
4980 { | 5559 os << " speedStatePars.mobilityStateParameters.nCellChangeHigh: "
<< (int)m_measConfig.speedStatePars.mobilityStateParameters.nCellChangeHigh <<
std::endl; |
4981 os << "raPreambleIndex: " << (int) m_mobilityControlInfo.rachConfigDed
icated.raPreambleIndex << std::endl; | 5560 os << " speedStatePars.timeToTriggerSf.sfMedium: " << (int)m_meas
Config.speedStatePars.timeToTriggerSf.sfMedium << std::endl; |
4982 os << "raPrachMaskIndex: " << (int) m_mobilityControlInfo.rachConfigD
edicated.raPrachMaskIndex << std::endl; | 5561 os << " speedStatePars.timeToTriggerSf.sfHigh: " << (int)m_measCo
nfig.speedStatePars.timeToTriggerSf.sfHigh << std::endl; |
4983 } | 5562 } |
4984 } | 5563 } |
4985 os << "haveRadioResourceConfigDedicated: " << m_haveRadioResourceConfigDedicat
ed << std::endl; | 5564 |
4986 if (m_haveRadioResourceConfigDedicated) | 5565 os << "haveMobilityControlInfo: " << m_haveMobilityControlInfo << std::endl; |
4987 { | 5566 if (m_haveMobilityControlInfo) |
4988 RrcAsn1Header::Print (os,m_radioResourceConfigDedicated); | 5567 { |
4989 } | 5568 os << "targetPhysCellId: " << (int)m_mobilityControlInfo.targetPhysCellI
d << std::endl; |
4990 } | 5569 os << "haveCarrierFreq: " << m_mobilityControlInfo.haveCarrierFreq << st
d::endl; |
4991 | 5570 if (m_mobilityControlInfo.haveCarrierFreq) |
4992 void | 5571 { |
4993 RrcConnectionReconfigurationHeader::SetMessage (LteRrcSap::RrcConnectionReconfig
uration msg) | 5572 os << " carrierFreq.dlCarrierFreq: " << (int) m_mobilityControlInfo
.carrierFreq.dlCarrierFreq << std::endl; |
4994 { | 5573 os << " carrierFreq.dlCarrierFreq: " << (int) m_mobilityControlInfo
.carrierFreq.ulCarrierFreq << std::endl; |
4995 m_rrcTransactionIdentifier = msg.rrcTransactionIdentifier; | 5574 } |
4996 m_haveMeasConfig = msg.haveMeasConfig; | 5575 os << "haveCarrierBandwidth: " << m_mobilityControlInfo.haveCarrierBandw
idth << std::endl; |
4997 m_measConfig = msg.measConfig; | 5576 if (m_mobilityControlInfo.haveCarrierBandwidth) |
4998 m_haveMobilityControlInfo = msg.haveMobilityControlInfo; | 5577 { |
4999 m_mobilityControlInfo = msg.mobilityControlInfo; | 5578 os << " carrierBandwidth.dlBandwidth: " << (int) m_mobilityControlI
nfo.carrierBandwidth.dlBandwidth << std::endl; |
5000 m_haveRadioResourceConfigDedicated = msg.haveRadioResourceConfigDedicated; | 5579 os << " carrierBandwidth.ulBandwidth: " << (int) m_mobilityControlI
nfo.carrierBandwidth.ulBandwidth << std::endl; |
5001 m_radioResourceConfigDedicated = msg.radioResourceConfigDedicated; | 5580 } |
5002 | 5581 os << "newUeIdentity: " << (int) m_mobilityControlInfo.newUeIdentity <<
std::endl; |
5003 m_isDataSerialized = false; | 5582 os << "haveRachConfigDedicated: " << m_mobilityControlInfo.haveRachConfi
gDedicated << std::endl; |
5004 } | 5583 if (m_mobilityControlInfo.haveRachConfigDedicated) |
5005 | 5584 { |
5006 LteRrcSap::RrcConnectionReconfiguration | 5585 os << "raPreambleIndex: " << (int) m_mobilityControlInfo.rachConfigD
edicated.raPreambleIndex << std::endl; |
5007 RrcConnectionReconfigurationHeader::GetMessage () const | 5586 os << "raPrachMaskIndex: " << (int) m_mobilityControlInfo.rachConfi
gDedicated.raPrachMaskIndex << std::endl; |
5008 { | 5587 } |
5009 LteRrcSap::RrcConnectionReconfiguration msg; | 5588 } |
5010 | 5589 os << "haveRadioResourceConfigDedicated: " << m_haveRadioResourceConfigDedic
ated << std::endl; |
5011 msg.rrcTransactionIdentifier = m_rrcTransactionIdentifier; | 5590 if (m_haveRadioResourceConfigDedicated) |
5012 msg.haveMeasConfig = m_haveMeasConfig; | 5591 { |
5013 msg.measConfig = m_measConfig; | 5592 RrcAsn1Header::Print (os,m_radioResourceConfigDedicated); |
5014 msg.haveMobilityControlInfo = m_haveMobilityControlInfo; | 5593 } |
5015 msg.mobilityControlInfo = m_mobilityControlInfo; | 5594 } |
5016 msg.haveRadioResourceConfigDedicated = m_haveRadioResourceConfigDedicated; | 5595 |
5017 msg.radioResourceConfigDedicated = m_radioResourceConfigDedicated; | 5596 void |
5018 | 5597 RrcConnectionReconfigurationHeader::SetMessage (LteRrcSap::RrcConnectionReconf
iguration msg) |
5019 return msg; | 5598 { |
5020 } | 5599 m_rrcTransactionIdentifier = msg.rrcTransactionIdentifier; |
5021 | 5600 m_haveMeasConfig = msg.haveMeasConfig; |
5022 uint8_t | 5601 m_measConfig = msg.measConfig; |
5023 RrcConnectionReconfigurationHeader::GetRrcTransactionIdentifier () const | 5602 m_haveMobilityControlInfo = msg.haveMobilityControlInfo; |
5024 { | 5603 m_mobilityControlInfo = msg.mobilityControlInfo; |
5025 return m_rrcTransactionIdentifier; | 5604 m_haveRadioResourceConfigDedicated = msg.haveRadioResourceConfigDedicated; |
5026 } | 5605 m_radioResourceConfigDedicated = msg.radioResourceConfigDedicated; |
5027 | 5606 m_haveNonCriticalExtension = msg.haveNonCriticalExtension; |
5028 bool | 5607 m_nonCriticalExtension = msg.nonCriticalExtension; |
5029 RrcConnectionReconfigurationHeader::GetHaveMeasConfig () | 5608 |
5030 { | 5609 m_isDataSerialized = false; |
5031 return m_haveMeasConfig; | 5610 } |
5032 } | 5611 |
5033 | 5612 LteRrcSap::RrcConnectionReconfiguration |
5034 LteRrcSap::MeasConfig | 5613 RrcConnectionReconfigurationHeader::GetMessage () const |
5035 RrcConnectionReconfigurationHeader::GetMeasConfig () | 5614 { |
5036 { | 5615 LteRrcSap::RrcConnectionReconfiguration msg; |
5037 return m_measConfig; | 5616 |
5038 } | 5617 msg.rrcTransactionIdentifier = m_rrcTransactionIdentifier; |
5039 | 5618 msg.haveMeasConfig = m_haveMeasConfig; |
5040 bool | 5619 msg.measConfig = m_measConfig; |
5041 RrcConnectionReconfigurationHeader::GetHaveMobilityControlInfo () | 5620 msg.haveMobilityControlInfo = m_haveMobilityControlInfo; |
5042 { | 5621 msg.mobilityControlInfo = m_mobilityControlInfo; |
5043 return m_haveMobilityControlInfo; | 5622 msg.haveRadioResourceConfigDedicated = m_haveRadioResourceConfigDedicated; |
5044 } | 5623 msg.radioResourceConfigDedicated = m_radioResourceConfigDedicated; |
5045 | 5624 msg.haveNonCriticalExtension = m_haveNonCriticalExtension; |
5046 LteRrcSap::MobilityControlInfo | 5625 msg.nonCriticalExtension = m_nonCriticalExtension; |
5047 RrcConnectionReconfigurationHeader::GetMobilityControlInfo () | 5626 |
5048 { | 5627 return msg; |
5049 return m_mobilityControlInfo; | 5628 } |
5050 } | 5629 |
5051 | 5630 uint8_t |
5052 bool | 5631 RrcConnectionReconfigurationHeader::GetRrcTransactionIdentifier () const |
5053 RrcConnectionReconfigurationHeader::GetHaveRadioResourceConfigDedicated () | 5632 { |
5054 { | 5633 return m_rrcTransactionIdentifier; |
5055 return m_haveRadioResourceConfigDedicated; | 5634 } |
5056 } | 5635 |
5057 | 5636 bool |
5058 LteRrcSap::RadioResourceConfigDedicated | 5637 RrcConnectionReconfigurationHeader::GetHaveMeasConfig () |
5059 RrcConnectionReconfigurationHeader::GetRadioResourceConfigDedicated () | 5638 { |
5060 { | 5639 return m_haveMeasConfig; |
5061 return m_radioResourceConfigDedicated; | 5640 } |
5062 } | 5641 |
5063 | 5642 LteRrcSap::MeasConfig |
5064 bool | 5643 RrcConnectionReconfigurationHeader::GetMeasConfig () |
5065 RrcConnectionReconfigurationHeader::HavePhysicalConfigDedicated () const | 5644 { |
5066 { | 5645 return m_measConfig; |
5067 return m_radioResourceConfigDedicated.havePhysicalConfigDedicated; | 5646 } |
5068 } | 5647 |
5069 | 5648 bool |
5070 std::list<LteRrcSap::SrbToAddMod>· | 5649 RrcConnectionReconfigurationHeader::GetHaveMobilityControlInfo () |
5071 RrcConnectionReconfigurationHeader::GetSrbToAddModList () const | 5650 { |
5072 { | 5651 return m_haveMobilityControlInfo; |
5073 return m_radioResourceConfigDedicated.srbToAddModList; | 5652 } |
5074 } | 5653 |
5075 | 5654 LteRrcSap::MobilityControlInfo |
5076 std::list<LteRrcSap::DrbToAddMod>· | 5655 RrcConnectionReconfigurationHeader::GetMobilityControlInfo () |
5077 RrcConnectionReconfigurationHeader::GetDrbToAddModList () const | 5656 { |
5078 { | 5657 return m_mobilityControlInfo; |
5079 return m_radioResourceConfigDedicated.drbToAddModList; | 5658 } |
5080 } | 5659 |
5081 | 5660 bool |
5082 std::list<uint8_t>· | 5661 RrcConnectionReconfigurationHeader::GetHaveRadioResourceConfigDedicated () |
5083 RrcConnectionReconfigurationHeader::GetDrbToReleaseList () const | 5662 { |
5084 { | 5663 return m_haveRadioResourceConfigDedicated; |
5085 return m_radioResourceConfigDedicated.drbToReleaseList; | 5664 } |
5086 } | 5665 |
5087 | 5666 LteRrcSap::RadioResourceConfigDedicated |
5088 LteRrcSap::PhysicalConfigDedicated· | 5667 RrcConnectionReconfigurationHeader::GetRadioResourceConfigDedicated () |
5089 RrcConnectionReconfigurationHeader::GetPhysicalConfigDedicated () const | 5668 { |
5090 { | 5669 return m_radioResourceConfigDedicated; |
5091 return m_radioResourceConfigDedicated.physicalConfigDedicated; | 5670 } |
5092 } | 5671 |
5093 | 5672 bool |
5094 | 5673 RrcConnectionReconfigurationHeader::GetHaveNonCriticalExtensionConfig () |
5095 //////////////////// HandoverPreparationInfoHeader class ///////////////////////
/ | 5674 { |
5096 | 5675 return m_haveNonCriticalExtension; |
5097 HandoverPreparationInfoHeader::HandoverPreparationInfoHeader () | 5676 } |
5098 { | 5677 |
5099 } | 5678 LteRrcSap::NonCriticalExtensionConfiguration |
5100 | 5679 RrcConnectionReconfigurationHeader::GetNonCriticalExtensionConfig () |
5101 void | 5680 { |
5102 HandoverPreparationInfoHeader::PreSerialize () const | 5681 return m_nonCriticalExtension; |
5103 { | 5682 } |
5104 m_serializationResult = Buffer (); | 5683 |
5105 | 5684 bool |
5106 // Serialize HandoverPreparationInformation sequence: | 5685 RrcConnectionReconfigurationHeader::HavePhysicalConfigDedicated () const |
5107 // no default or optional fields. Extension marker not present. | 5686 { |
5108 SerializeSequence (std::bitset<0> (),false); | 5687 return m_radioResourceConfigDedicated.havePhysicalConfigDedicated; |
5109 | 5688 } |
5110 // Serialize criticalExtensions choice | 5689 |
5111 // 2 options, selected 0 (c1) | 5690 std::list<LteRrcSap::SrbToAddMod>· |
5112 SerializeChoice (2,0,false); | 5691 RrcConnectionReconfigurationHeader::GetSrbToAddModList () const |
5113 | 5692 { |
5114 // Serialize c1 choice | 5693 return m_radioResourceConfigDedicated.srbToAddModList; |
5115 // 8 options, selected 0 (handoverPreparationInformation-r8) | 5694 } |
5116 SerializeChoice (8,0,false); | 5695 |
5117 | 5696 std::list<LteRrcSap::DrbToAddMod>· |
5118 // Serialize HandoverPreparationInformation-r8-IEs sequence | 5697 RrcConnectionReconfigurationHeader::GetDrbToAddModList () const |
5119 // 4 optional fields, no extension marker. | 5698 { |
5120 std::bitset<4> handoverPrepInfoOpts; | 5699 return m_radioResourceConfigDedicated.drbToAddModList; |
5121 handoverPrepInfoOpts.set (3,1); // as-Config present | 5700 } |
5122 handoverPrepInfoOpts.set (2,0); // rrm-Config not present | 5701 |
5123 handoverPrepInfoOpts.set (1,0); // as-Context not present | 5702 std::list<uint8_t>· |
5124 handoverPrepInfoOpts.set (0,0); // nonCriticalExtension not present | 5703 RrcConnectionReconfigurationHeader::GetDrbToReleaseList () const |
5125 SerializeSequence (handoverPrepInfoOpts,false); | 5704 { |
5126 | 5705 return m_radioResourceConfigDedicated.drbToReleaseList; |
5127 // Serialize ue-RadioAccessCapabilityInfo | 5706 } |
5128 SerializeSequenceOf (0,MAX_RAT_CAPABILITIES,0); | 5707 |
5129 | 5708 LteRrcSap::PhysicalConfigDedicated· |
5130 // Serialize as-Config | 5709 RrcConnectionReconfigurationHeader::GetPhysicalConfigDedicated () const |
5131 SerializeSequence (std::bitset<0> (),true); | 5710 { |
5132 | 5711 return m_radioResourceConfigDedicated.physicalConfigDedicated; |
5133 // Serialize sourceMeasConfig | 5712 } |
5134 SerializeMeasConfig (m_asConfig.sourceMeasConfig); | 5713 |
5135 | 5714 |
5136 // Serialize sourceRadioResourceConfig | 5715 //////////////////// HandoverPreparationInfoHeader class /////////////////////
/// |
5137 SerializeRadioResourceConfigDedicated (m_asConfig.sourceRadioResourceConfig); | 5716 |
5138 | 5717 HandoverPreparationInfoHeader::HandoverPreparationInfoHeader () |
5139 // Serialize sourceSecurityAlgorithmConfig | 5718 { |
5140 SerializeSequence (std::bitset<0> (),false); | 5719 } |
5141 // cipheringAlgorithm | 5720 |
5142 SerializeEnum (8,0); | 5721 void |
5143 // integrityProtAlgorithm | 5722 HandoverPreparationInfoHeader::PreSerialize () const |
5144 SerializeEnum (8,0); | 5723 { |
5145 | 5724 m_serializationResult = Buffer (); |
5146 // Serialize sourceUE-Identity | 5725 |
5147 SerializeBitstring (std::bitset<16> (m_asConfig.sourceUeIdentity)); | 5726 // Serialize HandoverPreparationInformation sequence: |
5148 | 5727 // no default or optional fields. Extension marker not present. |
5149 // Serialize sourceMasterInformationBlock | 5728 SerializeSequence (std::bitset<0> (),false); |
5150 SerializeSequence (std::bitset<0> (),false); | 5729 |
5151 SerializeEnum (6,m_asConfig.sourceMasterInformationBlock.dlBandwidth); // dl-B
andwidth | 5730 // Serialize criticalExtensions choice |
5152 SerializeSequence (std::bitset<0> (),false); // phich-Config sequence | 5731 // 2 options, selected 0 (c1) |
5153 SerializeEnum (2,0); // phich-Duration | 5732 SerializeChoice (2,0,false); |
5154 SerializeEnum (4,0); // phich-Resource | 5733 |
5155 SerializeBitstring (std::bitset<8> (m_asConfig.sourceMasterInformationBlock.sy
stemFrameNumber)); // systemFrameNumber | 5734 // Serialize c1 choice |
5156 SerializeBitstring (std::bitset<10> (321)); // spare | 5735 // 8 options, selected 0 (handoverPreparationInformation-r8) |
5157 | 5736 SerializeChoice (8,0,false); |
5158 // Serialize sourceSystemInformationBlockType1 sequence | 5737 |
5159 SerializeSystemInformationBlockType1 (m_asConfig.sourceSystemInformationBlockT
ype1); | 5738 // Serialize HandoverPreparationInformation-r8-IEs sequence |
5160 | 5739 // 4 optional fields, no extension marker. |
5161 // Serialize sourceSystemInformationBlockType2 | 5740 std::bitset<4> handoverPrepInfoOpts; |
5162 SerializeSystemInformationBlockType2 (m_asConfig.sourceSystemInformationBlockT
ype2); | 5741 handoverPrepInfoOpts.set (3,1); // as-Config present |
5163 | 5742 handoverPrepInfoOpts.set (2,0); // rrm-Config not present |
5164 // Serialize AntennaInfoCommon· | 5743 handoverPrepInfoOpts.set (1,0); // as-Context not present |
5165 SerializeSequence (std::bitset<0> (0),false); | 5744 handoverPrepInfoOpts.set (0,0); // nonCriticalExtension not present |
5166 SerializeEnum (4,0); // antennaPortsCount· | 5745 SerializeSequence (handoverPrepInfoOpts,false); |
5167 | 5746 |
5168 // Serialize sourceDlCarrierFreq | 5747 // Serialize ue-RadioAccessCapabilityInfo |
5169 SerializeInteger (m_asConfig.sourceDlCarrierFreq,0,MAX_EARFCN); | 5748 SerializeSequenceOf (0,MAX_RAT_CAPABILITIES,0); |
5170 | 5749 |
5171 // Finish serialization | 5750 // Serialize as-Config |
5172 FinalizeSerialization (); | 5751 SerializeSequence (std::bitset<0> (),true); |
5173 } | 5752 |
5174 | 5753 // Serialize sourceMeasConfig |
5175 uint32_t | 5754 SerializeMeasConfig (m_asConfig.sourceMeasConfig); |
5176 HandoverPreparationInfoHeader::Deserialize (Buffer::Iterator bIterator) | 5755 |
5177 { | 5756 // Serialize sourceRadioResourceConfig |
5178 std::bitset<0> bitset0; | 5757 SerializeRadioResourceConfigDedicated (m_asConfig.sourceRadioResourceConfig)
; |
5179 int n; | 5758 |
5180 | 5759 // Serialize sourceSecurityAlgorithmConfig |
5181 // Deserialize HandoverPreparationInformation sequence | 5760 SerializeSequence (std::bitset<0> (),false); |
5182 // 0 optional fields, no extension marker | 5761 // cipheringAlgorithm |
5183 bIterator = DeserializeSequence (&bitset0,false,bIterator); | 5762 SerializeEnum (8,0); |
5184 | 5763 // integrityProtAlgorithm |
5185 // Deserialize criticalExtensions choice | 5764 SerializeEnum (8,0); |
5186 int criticalExtensionsChosen; | 5765 |
5187 bIterator = DeserializeChoice (2,false,&criticalExtensionsChosen,bIterator); | 5766 // Serialize sourceUE-Identity |
5188 | 5767 SerializeBitstring (std::bitset<16> (m_asConfig.sourceUeIdentity)); |
5189 if (criticalExtensionsChosen == 1) | 5768 |
5190 { | 5769 // Serialize sourceMasterInformationBlock |
5191 // Deserialize criticalExtensionsFuture | 5770 SerializeSequence (std::bitset<0> (),false); |
5192 bIterator = DeserializeSequence (&bitset0,false,bIterator); | 5771 SerializeEnum (6,m_asConfig.sourceMasterInformationBlock.dlBandwidth); // dl
-Bandwidth |
5193 } | 5772 SerializeSequence (std::bitset<0> (),false); // phich-Config sequence |
5194 else if (criticalExtensionsChosen == 0) | 5773 SerializeEnum (2,0); // phich-Duration |
5195 { | 5774 SerializeEnum (4,0); // phich-Resource |
5196 // Deserialize c1 choice | 5775 SerializeBitstring (std::bitset<8> (m_asConfig.sourceMasterInformationBlock.
systemFrameNumber)); // systemFrameNumber |
5197 int c1Chosen; | 5776 SerializeBitstring (std::bitset<10> (321)); // spare |
5198 bIterator = DeserializeChoice (8,false,&c1Chosen,bIterator); | 5777 |
5199 if (c1Chosen > 0) | 5778 // Serialize sourceSystemInformationBlockType1 sequence |
5200 { | 5779 SerializeSystemInformationBlockType1 (m_asConfig.sourceSystemInformationBloc
kType1); |
5201 bIterator = DeserializeNull (bIterator); | 5780 |
5202 } | 5781 // Serialize sourceSystemInformationBlockType2 |
5203 else if (c1Chosen == 0) | 5782 SerializeSystemInformationBlockType2 (m_asConfig.sourceSystemInformationBloc
kType2); |
5204 { | 5783 |
5205 // Deserialize handoverPreparationInformation-r8 | 5784 // Serialize AntennaInfoCommon· |
5206 std::bitset<4> handoverPrepInfoOpts; | 5785 SerializeSequence (std::bitset<0> (0),false); |
5207 bIterator = DeserializeSequence (&handoverPrepInfoOpts,false,bIterator
); | 5786 SerializeEnum (4,0); // antennaPortsCount· |
5208 | 5787 |
5209 // Deserialize ue-RadioAccessCapabilityInfo | 5788 // Serialize sourceDlCarrierFreq |
5210 bIterator = DeserializeSequenceOf (&n,MAX_RAT_CAPABILITIES,0,bIterator
); | 5789 SerializeInteger (m_asConfig.sourceDlCarrierFreq,0,MAX_EARFCN); |
5211 for (int i = 0; i < n; i++) | 5790 |
5212 { | 5791 // Finish serialization |
5213 // Deserialize UE-CapabilityRAT-Container | 5792 FinalizeSerialization (); |
5214 // ... | 5793 } |
5215 } | 5794 |
5216 | 5795 uint32_t |
5217 if (handoverPrepInfoOpts[3]) | 5796 HandoverPreparationInfoHeader::Deserialize (Buffer::Iterator bIterator) |
5218 { | 5797 { |
5219 // Deserialize as-Config sequence | 5798 std::bitset<0> bitset0; |
5220 bIterator = DeserializeSequence (&bitset0,true,bIterator); | 5799 int n; |
5221 | 5800 |
5222 // Deserialize sourceMeasConfig | 5801 // Deserialize HandoverPreparationInformation sequence |
5223 bIterator = DeserializeMeasConfig (&m_asConfig.sourceMeasConfig, b
Iterator); | 5802 // 0 optional fields, no extension marker |
5224 | 5803 bIterator = DeserializeSequence (&bitset0,false,bIterator); |
5225 // Deserialize sourceRadioResourceConfig | 5804 |
5226 bIterator = DeserializeRadioResourceConfigDedicated (&m_asConfig.s
ourceRadioResourceConfig,bIterator); | 5805 // Deserialize criticalExtensions choice |
5227 | 5806 int criticalExtensionsChosen; |
5228 // Deserialize sourceSecurityAlgorithmConfig | 5807 bIterator = DeserializeChoice (2,false,&criticalExtensionsChosen,bIterator); |
5229 bIterator = DeserializeSequence (&bitset0,false,bIterator); | 5808 |
5230 bIterator = DeserializeEnum (8,&n,bIterator); // cipheringAlgorith
m | 5809 if (criticalExtensionsChosen == 1) |
5231 bIterator = DeserializeEnum (8,&n,bIterator); // integrityProtAlgo
rithm | 5810 { |
5232 | 5811 // Deserialize criticalExtensionsFuture |
5233 // Deserialize sourceUE-Identity | 5812 bIterator = DeserializeSequence (&bitset0,false,bIterator); |
5234 std::bitset<16> cRnti; | 5813 } |
5235 bIterator = DeserializeBitstring (&cRnti,bIterator); | 5814 else if (criticalExtensionsChosen == 0) |
5236 m_asConfig.sourceUeIdentity = cRnti.to_ulong (); | 5815 { |
5237 | 5816 // Deserialize c1 choice |
5238 // Deserialize sourceMasterInformationBlock | 5817 int c1Chosen; |
5239 bIterator = DeserializeSequence (&bitset0,false,bIterator); | 5818 bIterator = DeserializeChoice (8,false,&c1Chosen,bIterator); |
5240 bIterator = DeserializeEnum (6,&n,bIterator); // dl-Bandwidth | 5819 if (c1Chosen > 0) |
5241 m_asConfig.sourceMasterInformationBlock.dlBandwidth = n; | 5820 { |
5242 | 5821 bIterator = DeserializeNull (bIterator); |
5243 // phich-Config | 5822 } |
5244 bIterator = DeserializeSequence (&bitset0,false,bIterator); | 5823 else if (c1Chosen == 0) |
5245 bIterator = DeserializeEnum (2,&n,bIterator); // phich-Duration | 5824 { |
5246 bIterator = DeserializeEnum (4,&n,bIterator); // phich-Resource | 5825 // Deserialize handoverPreparationInformation-r8 |
5247 | 5826 std::bitset<4> handoverPrepInfoOpts; |
5248 // systemFrameNumber | 5827 bIterator = DeserializeSequence (&handoverPrepInfoOpts,false,bIterat
or); |
5249 std::bitset<8> systemFrameNumber; | 5828 |
5250 bIterator = DeserializeBitstring (&systemFrameNumber,bIterator); | 5829 // Deserialize ue-RadioAccessCapabilityInfo |
5251 m_asConfig.sourceMasterInformationBlock.systemFrameNumber = system
FrameNumber.to_ulong (); | 5830 bIterator = DeserializeSequenceOf (&n,MAX_RAT_CAPABILITIES,0,bIterat
or); |
5252 // spare | 5831 for (int i = 0; i < n; i++) |
5253 std::bitset<10> spare; | 5832 { |
5254 bIterator = DeserializeBitstring (&spare,bIterator); | 5833 // Deserialize UE-CapabilityRAT-Container |
5255 | 5834 // ... |
5256 // Deserialize sourceSystemInformationBlockType1 | 5835 } |
5257 bIterator = DeserializeSystemInformationBlockType1 (&m_asConfig.so
urceSystemInformationBlockType1,bIterator); | 5836 |
5258 | 5837 if (handoverPrepInfoOpts[3]) |
5259 // Deserialize sourceSystemInformationBlockType2 | 5838 { |
5260 bIterator = DeserializeSystemInformationBlockType2 (&m_asConfig.so
urceSystemInformationBlockType2,bIterator); | 5839 // Deserialize as-Config sequence |
5261 | 5840 bIterator = DeserializeSequence (&bitset0,true,bIterator); |
5262 // Deserialize antennaInfoCommon | 5841 |
5263 bIterator = DeserializeSequence (&bitset0,false,bIterator); | 5842 // Deserialize sourceMeasConfig |
5264 bIterator = DeserializeEnum (4,&n,bIterator); // antennaPortsCount | 5843 bIterator = DeserializeMeasConfig (&m_asConfig.sourceMeasConfig,
bIterator); |
5265 | 5844 |
5266 // Deserialize sourceDl-CarrierFreq | 5845 // Deserialize sourceRadioResourceConfig |
5267 bIterator = DeserializeInteger (&n,0,MAX_EARFCN,bIterator); | 5846 bIterator = DeserializeRadioResourceConfigDedicated (&m_asConfig
.sourceRadioResourceConfig,bIterator); |
5268 m_asConfig.sourceDlCarrierFreq = n; | 5847 |
5269 } | 5848 // Deserialize sourceSecurityAlgorithmConfig |
5270 if (handoverPrepInfoOpts[2]) | 5849 bIterator = DeserializeSequence (&bitset0,false,bIterator); |
5271 { | 5850 bIterator = DeserializeEnum (8,&n,bIterator); // cipheringAlgori
thm |
5272 // Deserialize rrm-Config | 5851 bIterator = DeserializeEnum (8,&n,bIterator); // integrityProtAl
gorithm |
5273 // ... | 5852 |
5274 } | 5853 // Deserialize sourceUE-Identity |
5275 if (handoverPrepInfoOpts[1]) | 5854 std::bitset<16> cRnti; |
5276 { | 5855 bIterator = DeserializeBitstring (&cRnti,bIterator); |
5277 // Deserialize as-Context | 5856 m_asConfig.sourceUeIdentity = cRnti.to_ulong (); |
5278 // ... | 5857 |
5279 } | 5858 // Deserialize sourceMasterInformationBlock |
5280 if (handoverPrepInfoOpts[0]) | 5859 bIterator = DeserializeSequence (&bitset0,false,bIterator); |
5281 { | 5860 bIterator = DeserializeEnum (6,&n,bIterator); // dl-Bandwidth |
5282 // Deserialize nonCriticalExtension | 5861 m_asConfig.sourceMasterInformationBlock.dlBandwidth = n; |
5283 // ... | 5862 |
5284 } | 5863 // phich-Config |
5285 } | 5864 bIterator = DeserializeSequence (&bitset0,false,bIterator); |
5286 } | 5865 bIterator = DeserializeEnum (2,&n,bIterator); // phich-Duration |
5287 | 5866 bIterator = DeserializeEnum (4,&n,bIterator); // phich-Resource |
5288 return GetSerializedSize (); | 5867 |
5289 } | 5868 // systemFrameNumber |
5290 | 5869 std::bitset<8> systemFrameNumber; |
5291 void | 5870 bIterator = DeserializeBitstring (&systemFrameNumber,bIterator); |
5292 HandoverPreparationInfoHeader::Print (std::ostream &os) const | 5871 m_asConfig.sourceMasterInformationBlock.systemFrameNumber = syst
emFrameNumber.to_ulong (); |
5293 { | 5872 // spare |
5294 RrcAsn1Header::Print (os,m_asConfig.sourceRadioResourceConfig); | 5873 std::bitset<10> spare; |
5295 os << "sourceUeIdentity: " << m_asConfig.sourceUeIdentity << std::endl; | 5874 bIterator = DeserializeBitstring (&spare,bIterator); |
5296 os << "dlBandwidth: " << (int)m_asConfig.sourceMasterInformationBlock.dlBandwi
dth << std::endl; | 5875 |
5297 os << "systemFrameNumber: " << (int)m_asConfig.sourceMasterInformationBlock.sy
stemFrameNumber << std::endl; | 5876 // Deserialize sourceSystemInformationBlockType1 |
5298 os << "plmnIdentityInfo.plmnIdentity: " << (int) m_asConfig.sourceSystemInform
ationBlockType1.cellAccessRelatedInfo.plmnIdentityInfo.plmnIdentity << std::endl
; | 5877 bIterator = DeserializeSystemInformationBlockType1 (&m_asConfig.
sourceSystemInformationBlockType1,bIterator); |
5299 os << "cellAccessRelatedInfo.cellIdentity " << (int)m_asConfig.sourceSystemInf
ormationBlockType1.cellAccessRelatedInfo.cellIdentity << std::endl; | 5878 |
5300 os << "cellAccessRelatedInfo.csgIndication: " << m_asConfig.sourceSystemInform
ationBlockType1.cellAccessRelatedInfo.csgIndication << std::endl; | 5879 // Deserialize sourceSystemInformationBlockType2 |
5301 os << "cellAccessRelatedInfo.csgIdentity: " << (int)m_asConfig.sourceSystemInf
ormationBlockType1.cellAccessRelatedInfo.csgIdentity << std::endl; | 5880 bIterator = DeserializeSystemInformationBlockType2 (&m_asConfig.
sourceSystemInformationBlockType2,bIterator); |
5302 os << "sourceDlCarrierFreq: " << m_asConfig.sourceDlCarrierFreq << std::endl; | 5881 |
5303 } | 5882 // Deserialize antennaInfoCommon |
5304 | 5883 bIterator = DeserializeSequence (&bitset0,false,bIterator); |
5305 void | 5884 bIterator = DeserializeEnum (4,&n,bIterator); // antennaPortsCou
nt |
5306 HandoverPreparationInfoHeader::SetMessage (LteRrcSap::HandoverPreparationInfo ms
g) | 5885 |
5307 { | 5886 // Deserialize sourceDl-CarrierFreq |
5308 m_asConfig = msg.asConfig; | 5887 bIterator = DeserializeInteger (&n,0,MAX_EARFCN,bIterator); |
5309 m_isDataSerialized = false; | 5888 m_asConfig.sourceDlCarrierFreq = n; |
5310 } | 5889 } |
5311 | 5890 if (handoverPrepInfoOpts[2]) |
5312 LteRrcSap::HandoverPreparationInfo | 5891 { |
5313 HandoverPreparationInfoHeader::GetMessage () const | 5892 // Deserialize rrm-Config |
5314 { | 5893 // ... |
5315 LteRrcSap::HandoverPreparationInfo msg; | 5894 } |
5316 msg.asConfig = m_asConfig; | 5895 if (handoverPrepInfoOpts[1]) |
5317 | 5896 { |
5318 return msg; | 5897 // Deserialize as-Context |
5319 } | 5898 // ... |
5320 | 5899 } |
5321 LteRrcSap::AsConfig | 5900 if (handoverPrepInfoOpts[0]) |
5322 HandoverPreparationInfoHeader::GetAsConfig () const | 5901 { |
5323 { | 5902 // Deserialize nonCriticalExtension |
5324 return m_asConfig; | 5903 // ... |
5325 } | 5904 } |
5326 | 5905 } |
5327 //////////////////// RrcConnectionReestablishmentRequestHeader class ///////////
///////////// | 5906 } |
5328 | 5907 |
5329 RrcConnectionReestablishmentRequestHeader::RrcConnectionReestablishmentRequestHe
ader () | 5908 return GetSerializedSize (); |
5330 { | 5909 } |
5331 } | 5910 |
5332 | 5911 void |
5333 RrcConnectionReestablishmentRequestHeader::~RrcConnectionReestablishmentRequestH
eader () | 5912 HandoverPreparationInfoHeader::Print (std::ostream &os) const |
5334 { | 5913 { |
5335 } | 5914 RrcAsn1Header::Print (os,m_asConfig.sourceRadioResourceConfig); |
5336 | 5915 os << "sourceUeIdentity: " << m_asConfig.sourceUeIdentity << std::endl; |
5337 void | 5916 os << "dlBandwidth: " << (int)m_asConfig.sourceMasterInformationBlock.dlBand
width << std::endl; |
5338 RrcConnectionReestablishmentRequestHeader::PreSerialize () const | 5917 os << "systemFrameNumber: " << (int)m_asConfig.sourceMasterInformationBlock.
systemFrameNumber << std::endl; |
5339 { | 5918 os << "plmnIdentityInfo.plmnIdentity: " << (int) m_asConfig.sourceSystemInfo
rmationBlockType1.cellAccessRelatedInfo.plmnIdentityInfo.plmnIdentity << std::en
dl; |
5340 m_serializationResult = Buffer (); | 5919 os << "cellAccessRelatedInfo.cellIdentity " << (int)m_asConfig.sourceSystemI
nformationBlockType1.cellAccessRelatedInfo.cellIdentity << std::endl; |
5341 | 5920 os << "cellAccessRelatedInfo.csgIndication: " << m_asConfig.sourceSystemInfo
rmationBlockType1.cellAccessRelatedInfo.csgIndication << std::endl; |
5342 SerializeUlCcchMessage (0); | 5921 os << "cellAccessRelatedInfo.csgIdentity: " << (int)m_asConfig.sourceSystemI
nformationBlockType1.cellAccessRelatedInfo.csgIdentity << std::endl; |
5343 | 5922 os << "sourceDlCarrierFreq: " << m_asConfig.sourceDlCarrierFreq << std::endl
; |
5344 // Serialize RrcConnectionReestablishmentReques sequence: | 5923 } |
5345 // no default or optional fields. Extension marker not present. | 5924 |
5346 SerializeSequence (std::bitset<0> (),false); | 5925 void |
5347 | 5926 HandoverPreparationInfoHeader::SetMessage (LteRrcSap::HandoverPreparationInfo
msg) |
5348 // Serialize criticalExtensions choice | 5927 { |
5349 // chosen: rrcConnectionReestablishmentRequest-r8 | 5928 m_asConfig = msg.asConfig; |
5350 SerializeChoice (2,0,false); | 5929 m_isDataSerialized = false; |
5351 | 5930 } |
5352 // Serialize RRCConnectionReestablishmentRequest-r8-IEs sequence | 5931 |
5353 // no default or optional fields. Extension marker not present. | 5932 LteRrcSap::HandoverPreparationInfo |
5354 SerializeSequence (std::bitset<0> (),false); | 5933 HandoverPreparationInfoHeader::GetMessage () const |
5355 | 5934 { |
5356 // Serialize ue-Identity | 5935 LteRrcSap::HandoverPreparationInfo msg; |
5357 SerializeSequence (std::bitset<0> (),false); | 5936 msg.asConfig = m_asConfig; |
5358 // Serialize c-RNTI | 5937 |
5359 SerializeBitstring (std::bitset<16> (m_ueIdentity.cRnti)); | 5938 return msg; |
5360 // Serialize physCellId | 5939 } |
5361 SerializeInteger (m_ueIdentity.physCellId,0,503); | 5940 |
5362 // Serialize shortMAC-I | 5941 LteRrcSap::AsConfig |
5363 SerializeBitstring (std::bitset<16> (0)); | 5942 HandoverPreparationInfoHeader::GetAsConfig () const |
5364 | 5943 { |
5365 // Serialize ReestablishmentCause | 5944 return m_asConfig; |
5366 switch (m_reestablishmentCause) | 5945 } |
5367 { | 5946 |
5368 case LteRrcSap::RECONFIGURATION_FAILURE: | 5947 //////////////////// RrcConnectionReestablishmentRequestHeader class /////////
/////////////// |
5369 SerializeEnum (4,0); | 5948 |
5370 break; | 5949 RrcConnectionReestablishmentRequestHeader::RrcConnectionReestablishmentRequest
Header () |
5371 case LteRrcSap::HANDOVER_FAILURE: | 5950 { |
5372 SerializeEnum (4,1); | 5951 } |
5373 break; | 5952 |
5374 case LteRrcSap::OTHER_FAILURE: | 5953 RrcConnectionReestablishmentRequestHeader::~RrcConnectionReestablishmentReques
tHeader () |
5375 SerializeEnum (4,2); | 5954 { |
5376 break; | 5955 } |
5377 default: | 5956 |
5378 SerializeEnum (4,3); | 5957 void |
5379 } | 5958 RrcConnectionReestablishmentRequestHeader::PreSerialize () const |
5380 | 5959 { |
5381 // Serialize spare | 5960 m_serializationResult = Buffer (); |
5382 SerializeBitstring (std::bitset<2> (0)); | 5961 |
5383 | 5962 SerializeUlCcchMessage (0); |
5384 // Finish serialization | 5963 |
5385 FinalizeSerialization (); | 5964 // Serialize RrcConnectionReestablishmentReques sequence: |
5386 } | 5965 // no default or optional fields. Extension marker not present. |
5387 | 5966 SerializeSequence (std::bitset<0> (),false); |
5388 uint32_t | 5967 |
5389 RrcConnectionReestablishmentRequestHeader::Deserialize (Buffer::Iterator bIterat
or) | 5968 // Serialize criticalExtensions choice |
5390 { | 5969 // chosen: rrcConnectionReestablishmentRequest-r8 |
5391 std::bitset<0> bitset0; | 5970 SerializeChoice (2,0,false); |
5392 int n; | 5971 |
5393 | 5972 // Serialize RRCConnectionReestablishmentRequest-r8-IEs sequence |
5394 bIterator = DeserializeUlCcchMessage (bIterator); | 5973 // no default or optional fields. Extension marker not present. |
5395 | 5974 SerializeSequence (std::bitset<0> (),false); |
5396 // Deserialize RrcConnectionReestablishmentRequest sequence | 5975 |
5397 // 0 optional fields, no extension marker | 5976 // Serialize ue-Identity |
5398 bIterator = DeserializeSequence (&bitset0,false,bIterator); | 5977 SerializeSequence (std::bitset<0> (),false); |
5399 | 5978 // Serialize c-RNTI |
5400 // Deserialize criticalExtensions choice | 5979 SerializeBitstring (std::bitset<16> (m_ueIdentity.cRnti)); |
5401 bIterator = DeserializeChoice (2,false,&n,bIterator); | 5980 // Serialize physCellId |
5402 if ( n == 1) | 5981 SerializeInteger (m_ueIdentity.physCellId,0,503); |
5403 { | 5982 // Serialize shortMAC-I |
5404 // Deserialize criticalExtensionsFuture | 5983 SerializeBitstring (std::bitset<16> (0)); |
5405 bIterator = DeserializeSequence (&bitset0,false,bIterator); | 5984 |
5406 } | 5985 // Serialize ReestablishmentCause |
5407 else if ( n == 0) | 5986 switch (m_reestablishmentCause) |
5408 { | 5987 { |
5409 // Deserialize RRCConnectionReestablishmentRequest-r8-IEs | 5988 case LteRrcSap::RECONFIGURATION_FAILURE: |
5410 bIterator = DeserializeSequence (&bitset0,false,bIterator); | 5989 SerializeEnum (4,0); |
5411 | 5990 break; |
5412 // Deserialize ReestabUE-Identity sequence | 5991 case LteRrcSap::HANDOVER_FAILURE: |
5413 bIterator = DeserializeSequence (&bitset0,false,bIterator); | 5992 SerializeEnum (4,1); |
5414 | 5993 break; |
5415 // Deserialize c-RNTI | 5994 case LteRrcSap::OTHER_FAILURE: |
5416 std::bitset<16> cRnti; | 5995 SerializeEnum (4,2); |
5417 bIterator = DeserializeBitstring (&cRnti,bIterator); | 5996 break; |
5418 m_ueIdentity.cRnti = cRnti.to_ulong (); | 5997 default: |
5419 | 5998 SerializeEnum (4,3); |
5420 // Deserialize physCellId | 5999 } |
5421 int physCellId; | 6000 |
5422 bIterator = DeserializeInteger (&physCellId,0,503,bIterator); | 6001 // Serialize spare |
5423 m_ueIdentity.physCellId = physCellId; | 6002 SerializeBitstring (std::bitset<2> (0)); |
5424 | 6003 |
5425 // Deserialize shortMAC-I | 6004 // Finish serialization |
5426 std::bitset<16> shortMacI; | 6005 FinalizeSerialization (); |
5427 bIterator = DeserializeBitstring (&shortMacI,bIterator); | 6006 } |
5428 | 6007 |
5429 // Deserialize ReestablishmentCause | 6008 uint32_t |
5430 int reestCs; | 6009 RrcConnectionReestablishmentRequestHeader::Deserialize (Buffer::Iterator bIter
ator) |
5431 bIterator = DeserializeEnum (4,&reestCs,bIterator); | 6010 { |
5432 switch (reestCs) | 6011 std::bitset<0> bitset0; |
5433 { | 6012 int n; |
5434 case 0: | 6013 |
5435 m_reestablishmentCause = LteRrcSap::RECONFIGURATION_FAILURE; | 6014 bIterator = DeserializeUlCcchMessage (bIterator); |
5436 break; | 6015 |
5437 case 1: | 6016 // Deserialize RrcConnectionReestablishmentRequest sequence |
5438 m_reestablishmentCause = LteRrcSap::HANDOVER_FAILURE; | 6017 // 0 optional fields, no extension marker |
5439 break; | 6018 bIterator = DeserializeSequence (&bitset0,false,bIterator); |
5440 case 2: | 6019 |
5441 m_reestablishmentCause = LteRrcSap::OTHER_FAILURE; | 6020 // Deserialize criticalExtensions choice |
5442 break; | 6021 bIterator = DeserializeChoice (2,false,&n,bIterator); |
5443 case 3: | 6022 if ( n == 1) |
5444 break; | 6023 { |
5445 } | 6024 // Deserialize criticalExtensionsFuture |
5446 | 6025 bIterator = DeserializeSequence (&bitset0,false,bIterator); |
5447 // Deserialize spare | 6026 } |
5448 std::bitset<2> spare; | 6027 else if ( n == 0) |
5449 bIterator = DeserializeBitstring (&spare,bIterator); | 6028 { |
5450 } | 6029 // Deserialize RRCConnectionReestablishmentRequest-r8-IEs |
5451 | 6030 bIterator = DeserializeSequence (&bitset0,false,bIterator); |
5452 return GetSerializedSize (); | 6031 |
5453 } | 6032 // Deserialize ReestabUE-Identity sequence |
5454 | 6033 bIterator = DeserializeSequence (&bitset0,false,bIterator); |
5455 void | 6034 |
5456 RrcConnectionReestablishmentRequestHeader::Print (std::ostream &os) const | 6035 // Deserialize c-RNTI |
5457 { | 6036 std::bitset<16> cRnti; |
5458 os << "ueIdentity.cRnti: " << (int)m_ueIdentity.cRnti << std::endl; | 6037 bIterator = DeserializeBitstring (&cRnti,bIterator); |
5459 os << "ueIdentity.physCellId: " << (int)m_ueIdentity.physCellId << std::endl; | 6038 m_ueIdentity.cRnti = cRnti.to_ulong (); |
5460 os << "m_reestablishmentCause: " << m_reestablishmentCause << std::endl; | 6039 |
5461 } | 6040 // Deserialize physCellId |
5462 | 6041 int physCellId; |
5463 void | 6042 bIterator = DeserializeInteger (&physCellId,0,503,bIterator); |
5464 RrcConnectionReestablishmentRequestHeader::SetMessage (LteRrcSap::RrcConnectionR
eestablishmentRequest msg) | 6043 m_ueIdentity.physCellId = physCellId; |
5465 { | 6044 |
5466 m_ueIdentity = msg.ueIdentity; | 6045 // Deserialize shortMAC-I |
5467 m_reestablishmentCause = msg.reestablishmentCause; | 6046 std::bitset<16> shortMacI; |
5468 m_isDataSerialized = false; | 6047 bIterator = DeserializeBitstring (&shortMacI,bIterator); |
5469 } | 6048 |
5470 | 6049 // Deserialize ReestablishmentCause |
5471 LteRrcSap::RrcConnectionReestablishmentRequest | 6050 int reestCs; |
5472 RrcConnectionReestablishmentRequestHeader::GetMessage () const | 6051 bIterator = DeserializeEnum (4,&reestCs,bIterator); |
5473 { | 6052 switch (reestCs) |
5474 LteRrcSap::RrcConnectionReestablishmentRequest msg; | 6053 { |
5475 msg.ueIdentity = m_ueIdentity; | 6054 case 0: |
5476 msg.reestablishmentCause = m_reestablishmentCause; | 6055 m_reestablishmentCause = LteRrcSap::RECONFIGURATION_FAILURE; |
5477 | 6056 break; |
5478 return msg; | 6057 case 1: |
5479 } | 6058 m_reestablishmentCause = LteRrcSap::HANDOVER_FAILURE; |
5480 | 6059 break; |
5481 LteRrcSap::ReestabUeIdentity | 6060 case 2: |
5482 RrcConnectionReestablishmentRequestHeader::GetUeIdentity () const | 6061 m_reestablishmentCause = LteRrcSap::OTHER_FAILURE; |
5483 { | 6062 break; |
5484 return m_ueIdentity; | 6063 case 3: |
5485 } | 6064 break; |
5486 | 6065 } |
5487 LteRrcSap::ReestablishmentCause | 6066 |
5488 RrcConnectionReestablishmentRequestHeader::GetReestablishmentCause () const | 6067 // Deserialize spare |
5489 { | 6068 std::bitset<2> spare; |
5490 return m_reestablishmentCause; | 6069 bIterator = DeserializeBitstring (&spare,bIterator); |
5491 } | 6070 } |
5492 | 6071 |
5493 //////////////////// RrcConnectionReestablishmentHeader class //////////////////
////// | 6072 return GetSerializedSize (); |
5494 | 6073 } |
5495 RrcConnectionReestablishmentHeader::RrcConnectionReestablishmentHeader () | 6074 |
5496 { | 6075 void |
5497 } | 6076 RrcConnectionReestablishmentRequestHeader::Print (std::ostream &os) const |
5498 | 6077 { |
5499 RrcConnectionReestablishmentHeader::~RrcConnectionReestablishmentHeader () | 6078 os << "ueIdentity.cRnti: " << (int)m_ueIdentity.cRnti << std::endl; |
5500 { | 6079 os << "ueIdentity.physCellId: " << (int)m_ueIdentity.physCellId << std::endl
; |
5501 } | 6080 os << "m_reestablishmentCause: " << m_reestablishmentCause << std::endl; |
5502 | 6081 } |
5503 void | 6082 |
5504 RrcConnectionReestablishmentHeader::PreSerialize () const | 6083 void |
5505 { | 6084 RrcConnectionReestablishmentRequestHeader::SetMessage (LteRrcSap::RrcConnectio
nReestablishmentRequest msg) |
5506 m_serializationResult = Buffer (); | 6085 { |
5507 | 6086 m_ueIdentity = msg.ueIdentity; |
5508 SerializeDlCcchMessage (0); | 6087 m_reestablishmentCause = msg.reestablishmentCause; |
5509 | 6088 m_isDataSerialized = false; |
5510 // Serialize RrcConnectionReestablishment sequence: | 6089 } |
5511 // no default or optional fields. Extension marker not present. | 6090 |
5512 SerializeSequence (std::bitset<0> (),false); | 6091 LteRrcSap::RrcConnectionReestablishmentRequest |
5513 | 6092 RrcConnectionReestablishmentRequestHeader::GetMessage () const |
5514 // Serialize rrc-TransactionIdentifier | 6093 { |
5515 SerializeInteger (m_rrcTransactionIdentifier,0,3); | 6094 LteRrcSap::RrcConnectionReestablishmentRequest msg; |
5516 | 6095 msg.ueIdentity = m_ueIdentity; |
5517 // Serialize criticalExtensions choice | 6096 msg.reestablishmentCause = m_reestablishmentCause; |
5518 SerializeChoice (2,0,false); | 6097 |
5519 | 6098 return msg; |
5520 // Serialize c1 choice | 6099 } |
5521 SerializeChoice (8,0,false); | 6100 |
5522 | 6101 LteRrcSap::ReestabUeIdentity |
5523 // Serialize RRCConnectionReestablishment-r8-IEs sequence | 6102 RrcConnectionReestablishmentRequestHeader::GetUeIdentity () const |
5524 // 1 optional field, no extension marker | 6103 { |
5525 SerializeSequence (std::bitset<1> (0),false); | 6104 return m_ueIdentity; |
5526 | 6105 } |
5527 // Serialize radioResourceConfigDedicated | 6106 |
5528 SerializeRadioResourceConfigDedicated (m_radioResourceConfigDedicated); | 6107 LteRrcSap::ReestablishmentCause |
5529 | 6108 RrcConnectionReestablishmentRequestHeader::GetReestablishmentCause () const |
5530 // Serialize nextHopChainingCount | 6109 { |
5531 SerializeInteger (0,0,7); | 6110 return m_reestablishmentCause; |
5532 | 6111 } |
5533 // Finish serialization | 6112 |
5534 FinalizeSerialization (); | 6113 //////////////////// RrcConnectionReestablishmentHeader class ////////////////
//////// |
5535 } | 6114 |
5536 | 6115 RrcConnectionReestablishmentHeader::RrcConnectionReestablishmentHeader () |
5537 uint32_t | 6116 { |
5538 RrcConnectionReestablishmentHeader::Deserialize (Buffer::Iterator bIterator) | 6117 } |
5539 { | 6118 |
5540 std::bitset<0> bitset0; | 6119 RrcConnectionReestablishmentHeader::~RrcConnectionReestablishmentHeader () |
5541 int n; | 6120 { |
5542 | 6121 } |
5543 bIterator = DeserializeDlCcchMessage (bIterator); | 6122 |
5544 | 6123 void |
5545 // Deserialize RrcConnectionReestablishment sequence | 6124 RrcConnectionReestablishmentHeader::PreSerialize () const |
5546 // 0 optional fields, no extension marker | 6125 { |
5547 bIterator = DeserializeSequence (&bitset0,false,bIterator); | 6126 m_serializationResult = Buffer (); |
5548 | 6127 |
5549 // Deserialize rrc-TransactionIdentifier | 6128 SerializeDlCcchMessage (0); |
5550 bIterator = DeserializeInteger (&n,0,3,bIterator); | 6129 |
5551 m_rrcTransactionIdentifier = n; | 6130 // Serialize RrcConnectionReestablishment sequence: |
5552 | 6131 // no default or optional fields. Extension marker not present. |
5553 // Deserialize criticalExtensions choice | 6132 SerializeSequence (std::bitset<0> (),false); |
5554 int criticalExtensionsChoice; | 6133 |
5555 bIterator = DeserializeChoice (2,false,&criticalExtensionsChoice,bIterator); | 6134 // Serialize rrc-TransactionIdentifier |
5556 if (criticalExtensionsChoice == 1) | 6135 SerializeInteger (m_rrcTransactionIdentifier,0,3); |
5557 { | 6136 |
5558 // Deserialize criticalExtensionsFuture | 6137 // Serialize criticalExtensions choice |
5559 bIterator = DeserializeSequence (&bitset0,false,bIterator); | 6138 SerializeChoice (2,0,false); |
5560 } | 6139 |
5561 else if (criticalExtensionsChoice == 0) | 6140 // Serialize c1 choice |
5562 { | 6141 SerializeChoice (8,0,false); |
5563 // Deserialize c1 | 6142 |
5564 int c1; | 6143 // Serialize RRCConnectionReestablishment-r8-IEs sequence |
5565 bIterator = DeserializeChoice (8,false,&c1,bIterator); | 6144 // 1 optional field, no extension marker |
5566 if (c1 > 0) | 6145 SerializeSequence (std::bitset<1> (0),false); |
5567 { | 6146 |
5568 bIterator = DeserializeNull (bIterator); | 6147 // Serialize radioResourceConfigDedicated |
5569 } | 6148 SerializeRadioResourceConfigDedicated (m_radioResourceConfigDedicated); |
5570 else if (c1 == 0) | 6149 |
5571 { | 6150 // Serialize nextHopChainingCount |
5572 // Deserialize rrcConnectionReestablishment-r8 | 6151 SerializeInteger (0,0,7); |
5573 // 1 optional field | 6152 |
5574 std::bitset<1> nonCriticalExtensionPresent; | 6153 // Finish serialization |
5575 bIterator = DeserializeSequence (&nonCriticalExtensionPresent,false,bI
terator); | 6154 FinalizeSerialization (); |
5576 | 6155 } |
5577 // Deserialize RadioResourceConfigDedicated | 6156 |
5578 bIterator = DeserializeRadioResourceConfigDedicated (&m_radioResourceC
onfigDedicated,bIterator); | 6157 uint32_t |
5579 | 6158 RrcConnectionReestablishmentHeader::Deserialize (Buffer::Iterator bIterator) |
5580 // Deserialize nextHopChainingCount | 6159 { |
5581 bIterator = DeserializeInteger (&n,0,7,bIterator); | 6160 std::bitset<0> bitset0; |
5582 } | 6161 int n; |
5583 } | 6162 |
5584 | 6163 bIterator = DeserializeDlCcchMessage (bIterator); |
5585 return GetSerializedSize (); | 6164 |
5586 } | 6165 // Deserialize RrcConnectionReestablishment sequence |
5587 | 6166 // 0 optional fields, no extension marker |
5588 void | 6167 bIterator = DeserializeSequence (&bitset0,false,bIterator); |
5589 RrcConnectionReestablishmentHeader::Print (std::ostream &os) const | 6168 |
5590 { | 6169 // Deserialize rrc-TransactionIdentifier |
5591 os << "rrcTransactionIdentifier: " << (int)m_rrcTransactionIdentifier << std::
endl; | 6170 bIterator = DeserializeInteger (&n,0,3,bIterator); |
5592 os << "RadioResourceConfigDedicated: " << std::endl; | 6171 m_rrcTransactionIdentifier = n; |
5593 RrcAsn1Header::Print (os,m_radioResourceConfigDedicated); | 6172 |
5594 } | 6173 // Deserialize criticalExtensions choice |
5595 | 6174 int criticalExtensionsChoice; |
5596 void | 6175 bIterator = DeserializeChoice (2,false,&criticalExtensionsChoice,bIterator); |
5597 RrcConnectionReestablishmentHeader::SetMessage (LteRrcSap::RrcConnectionReestabl
ishment msg) | 6176 if (criticalExtensionsChoice == 1) |
5598 { | 6177 { |
5599 m_rrcTransactionIdentifier = msg.rrcTransactionIdentifier; | 6178 // Deserialize criticalExtensionsFuture |
5600 m_radioResourceConfigDedicated = msg.radioResourceConfigDedicated; | 6179 bIterator = DeserializeSequence (&bitset0,false,bIterator); |
5601 m_isDataSerialized = false; | 6180 } |
5602 } | 6181 else if (criticalExtensionsChoice == 0) |
5603 | 6182 { |
5604 LteRrcSap::RrcConnectionReestablishment | 6183 // Deserialize c1 |
5605 RrcConnectionReestablishmentHeader::GetMessage () const | 6184 int c1; |
5606 { | 6185 bIterator = DeserializeChoice (8,false,&c1,bIterator); |
5607 LteRrcSap::RrcConnectionReestablishment msg; | 6186 if (c1 > 0) |
5608 msg.rrcTransactionIdentifier = m_rrcTransactionIdentifier; | 6187 { |
5609 msg.radioResourceConfigDedicated = m_radioResourceConfigDedicated; | 6188 bIterator = DeserializeNull (bIterator); |
5610 return msg; | 6189 } |
5611 } | 6190 else if (c1 == 0) |
5612 | 6191 { |
5613 uint8_t | 6192 // Deserialize rrcConnectionReestablishment-r8 |
5614 RrcConnectionReestablishmentHeader::GetRrcTransactionIdentifier () const | 6193 // 1 optional field |
5615 { | 6194 std::bitset<1> nonCriticalExtensionPresent; |
5616 return m_rrcTransactionIdentifier; | 6195 bIterator = DeserializeSequence (&nonCriticalExtensionPresent,false,
bIterator); |
5617 } | 6196 |
5618 | 6197 // Deserialize RadioResourceConfigDedicated |
5619 LteRrcSap::RadioResourceConfigDedicated | 6198 bIterator = DeserializeRadioResourceConfigDedicated (&m_radioResourc
eConfigDedicated,bIterator); |
5620 RrcConnectionReestablishmentHeader::GetRadioResourceConfigDedicated () const | 6199 |
5621 { | 6200 // Deserialize nextHopChainingCount |
5622 return m_radioResourceConfigDedicated; | 6201 bIterator = DeserializeInteger (&n,0,7,bIterator); |
5623 } | 6202 } |
5624 | 6203 } |
5625 //////////////////// RrcConnectionReestablishmentCompleteHeader class //////////
////////////// | 6204 |
5626 | 6205 return GetSerializedSize (); |
5627 RrcConnectionReestablishmentCompleteHeader::RrcConnectionReestablishmentComplete
Header () | 6206 } |
5628 { | 6207 |
5629 } | 6208 void |
5630 | 6209 RrcConnectionReestablishmentHeader::Print (std::ostream &os) const |
5631 void | 6210 { |
5632 RrcConnectionReestablishmentCompleteHeader::PreSerialize () const | 6211 os << "rrcTransactionIdentifier: " << (int)m_rrcTransactionIdentifier << std
::endl; |
5633 { | 6212 os << "RadioResourceConfigDedicated: " << std::endl; |
5634 m_serializationResult = Buffer (); | 6213 RrcAsn1Header::Print (os,m_radioResourceConfigDedicated); |
5635 | 6214 } |
5636 // Serialize DCCH message | 6215 |
5637 SerializeUlDcchMessage (3); | 6216 void |
5638 | 6217 RrcConnectionReestablishmentHeader::SetMessage (LteRrcSap::RrcConnectionReesta
blishment msg) |
5639 // Serialize RrcConnectionReestablishmentComplete sequence: | 6218 { |
5640 // no default or optional fields. Extension marker not present. | 6219 m_rrcTransactionIdentifier = msg.rrcTransactionIdentifier; |
5641 SerializeSequence (std::bitset<0> (),false); | 6220 m_radioResourceConfigDedicated = msg.radioResourceConfigDedicated; |
5642 | 6221 m_isDataSerialized = false; |
5643 // Serialize rrc-TransactionIdentifier | 6222 } |
5644 SerializeInteger (m_rrcTransactionIdentifier,0,3); | 6223 |
5645 | 6224 LteRrcSap::RrcConnectionReestablishment |
5646 // Serialize criticalExtensions choice | 6225 RrcConnectionReestablishmentHeader::GetMessage () const |
5647 SerializeChoice (2,0,false); | 6226 { |
5648 | 6227 LteRrcSap::RrcConnectionReestablishment msg; |
5649 // Serialize rrcConnectionReestablishmentComplete-r8 sequence | 6228 msg.rrcTransactionIdentifier = m_rrcTransactionIdentifier; |
5650 // 1 optional field (not present), no extension marker. | 6229 msg.radioResourceConfigDedicated = m_radioResourceConfigDedicated; |
5651 SerializeSequence (std::bitset<1> (0),false); | 6230 return msg; |
5652 | 6231 } |
5653 // Finish serialization | 6232 |
5654 FinalizeSerialization (); | 6233 uint8_t |
5655 } | 6234 RrcConnectionReestablishmentHeader::GetRrcTransactionIdentifier () const |
5656 | 6235 { |
5657 uint32_t | 6236 return m_rrcTransactionIdentifier; |
5658 RrcConnectionReestablishmentCompleteHeader::Deserialize (Buffer::Iterator bItera
tor) | 6237 } |
5659 { | 6238 |
5660 std::bitset<0> bitset0; | 6239 LteRrcSap::RadioResourceConfigDedicated |
5661 int n; | 6240 RrcConnectionReestablishmentHeader::GetRadioResourceConfigDedicated () const |
5662 | 6241 { |
5663 bIterator = DeserializeUlDcchMessage (bIterator); | 6242 return m_radioResourceConfigDedicated; |
5664 | 6243 } |
5665 // Deserialize RrcConnectionReestablishmentComplete sequence | 6244 |
5666 // 0 optional fields, no extension marker | 6245 //////////////////// RrcConnectionReestablishmentCompleteHeader class ////////
//////////////// |
5667 bIterator = DeserializeSequence (&bitset0,false,bIterator); | 6246 |
5668 | 6247 RrcConnectionReestablishmentCompleteHeader::RrcConnectionReestablishmentComple
teHeader () |
5669 // Deserialize rrc-TransactionIdentifier | 6248 { |
5670 bIterator = DeserializeInteger (&n,0,3,bIterator); | 6249 } |
5671 m_rrcTransactionIdentifier = n; | 6250 |
5672 | 6251 void |
5673 // Deserialize criticalExtensions choice | 6252 RrcConnectionReestablishmentCompleteHeader::PreSerialize () const |
5674 int criticalExtensionsChoice; | 6253 { |
5675 bIterator = DeserializeChoice (2,false,&criticalExtensionsChoice,bIterator); | 6254 m_serializationResult = Buffer (); |
5676 if (criticalExtensionsChoice == 1) | 6255 |
5677 { | 6256 // Serialize DCCH message |
5678 // Deserialize criticalExtensionsFuture | 6257 SerializeUlDcchMessage (3); |
5679 bIterator = DeserializeSequence (&bitset0,false,bIterator); | 6258 |
5680 } | 6259 // Serialize RrcConnectionReestablishmentComplete sequence: |
5681 else if (criticalExtensionsChoice == 0) | 6260 // no default or optional fields. Extension marker not present. |
5682 { | 6261 SerializeSequence (std::bitset<0> (),false); |
5683 // Deserialize rrcConnectionReestablishmentComplete-r8 | 6262 |
5684 std::bitset<1> opts; | 6263 // Serialize rrc-TransactionIdentifier |
5685 bIterator = DeserializeSequence (&opts,false,bIterator); | 6264 SerializeInteger (m_rrcTransactionIdentifier,0,3); |
5686 if (opts[0]) | 6265 |
5687 { | 6266 // Serialize criticalExtensions choice |
5688 // Deserialize RRCConnectionReestablishmentComplete-v920-IEs | 6267 SerializeChoice (2,0,false); |
5689 // ... | 6268 |
5690 } | 6269 // Serialize rrcConnectionReestablishmentComplete-r8 sequence |
5691 } | 6270 // 1 optional field (not present), no extension marker. |
5692 | 6271 SerializeSequence (std::bitset<1> (0),false); |
5693 return GetSerializedSize (); | 6272 |
5694 } | 6273 // Finish serialization |
5695 | 6274 FinalizeSerialization (); |
5696 void | 6275 } |
5697 RrcConnectionReestablishmentCompleteHeader::Print (std::ostream &os) const | 6276 |
5698 { | 6277 uint32_t |
5699 os << "rrcTransactionIdentifier: " << (int)m_rrcTransactionIdentifier << std::
endl; | 6278 RrcConnectionReestablishmentCompleteHeader::Deserialize (Buffer::Iterator bIte
rator) |
5700 } | 6279 { |
5701 | 6280 std::bitset<0> bitset0; |
5702 void | 6281 int n; |
5703 RrcConnectionReestablishmentCompleteHeader::SetMessage (LteRrcSap::RrcConnection
ReestablishmentComplete msg) | 6282 |
5704 { | 6283 bIterator = DeserializeUlDcchMessage (bIterator); |
5705 m_rrcTransactionIdentifier = msg.rrcTransactionIdentifier; | 6284 |
5706 m_isDataSerialized = false; | 6285 // Deserialize RrcConnectionReestablishmentComplete sequence |
5707 } | 6286 // 0 optional fields, no extension marker |
5708 | 6287 bIterator = DeserializeSequence (&bitset0,false,bIterator); |
5709 LteRrcSap::RrcConnectionReestablishmentComplete | 6288 |
5710 RrcConnectionReestablishmentCompleteHeader::GetMessage () const | 6289 // Deserialize rrc-TransactionIdentifier |
5711 { | 6290 bIterator = DeserializeInteger (&n,0,3,bIterator); |
5712 LteRrcSap::RrcConnectionReestablishmentComplete msg; | 6291 m_rrcTransactionIdentifier = n; |
5713 msg.rrcTransactionIdentifier = m_rrcTransactionIdentifier; | 6292 |
5714 return msg; | 6293 // Deserialize criticalExtensions choice |
5715 } | 6294 int criticalExtensionsChoice; |
5716 | 6295 bIterator = DeserializeChoice (2,false,&criticalExtensionsChoice,bIterator); |
5717 uint8_t | 6296 if (criticalExtensionsChoice == 1) |
5718 RrcConnectionReestablishmentCompleteHeader::GetRrcTransactionIdentifier () const | 6297 { |
5719 { | 6298 // Deserialize criticalExtensionsFuture |
5720 return m_rrcTransactionIdentifier; | 6299 bIterator = DeserializeSequence (&bitset0,false,bIterator); |
5721 } | 6300 } |
5722 | 6301 else if (criticalExtensionsChoice == 0) |
5723 //////////////////// RrcConnectionReestablishmentRejectHeader class ////////////
//////////// | 6302 { |
5724 | 6303 // Deserialize rrcConnectionReestablishmentComplete-r8 |
5725 RrcConnectionReestablishmentRejectHeader::RrcConnectionReestablishmentRejectHead
er () | 6304 std::bitset<1> opts; |
5726 { | 6305 bIterator = DeserializeSequence (&opts,false,bIterator); |
5727 } | 6306 if (opts[0]) |
5728 | 6307 { |
5729 RrcConnectionReestablishmentRejectHeader::~RrcConnectionReestablishmentRejectHea
der () | 6308 // Deserialize RRCConnectionReestablishmentComplete-v920-IEs |
5730 { | 6309 // ... |
5731 } | 6310 } |
5732 | 6311 } |
5733 void | 6312 |
5734 RrcConnectionReestablishmentRejectHeader::PreSerialize () const | 6313 return GetSerializedSize (); |
5735 { | 6314 } |
5736 m_serializationResult = Buffer (); | 6315 |
5737 | 6316 void |
5738 // Serialize CCCH message | 6317 RrcConnectionReestablishmentCompleteHeader::Print (std::ostream &os) const |
5739 SerializeDlCcchMessage (1); | 6318 { |
5740 | 6319 os << "rrcTransactionIdentifier: " << (int)m_rrcTransactionIdentifier << std
::endl; |
5741 // Serialize RrcConnectionReestablishmentReject sequence: | 6320 } |
5742 // no default or optional fields. Extension marker not present. | 6321 |
5743 SerializeSequence (std::bitset<0> (),false); | 6322 void |
5744 | 6323 RrcConnectionReestablishmentCompleteHeader::SetMessage (LteRrcSap::RrcConnecti
onReestablishmentComplete msg) |
5745 // Serialize criticalExtensions choice | 6324 { |
5746 SerializeChoice (2,0,false); | 6325 m_rrcTransactionIdentifier = msg.rrcTransactionIdentifier; |
5747 | 6326 m_isDataSerialized = false; |
5748 // Serialize RRCConnectionReestablishmentReject-r8-IEs sequence | 6327 } |
5749 // 1 optional field (not present), no extension marker. | 6328 |
5750 SerializeSequence (std::bitset<1> (0),false); | 6329 LteRrcSap::RrcConnectionReestablishmentComplete |
5751 | 6330 RrcConnectionReestablishmentCompleteHeader::GetMessage () const |
5752 // Finish serialization | 6331 { |
5753 FinalizeSerialization (); | 6332 LteRrcSap::RrcConnectionReestablishmentComplete msg; |
5754 } | 6333 msg.rrcTransactionIdentifier = m_rrcTransactionIdentifier; |
5755 | 6334 return msg; |
5756 uint32_t | 6335 } |
5757 RrcConnectionReestablishmentRejectHeader::Deserialize (Buffer::Iterator bIterato
r) | 6336 |
5758 { | 6337 uint8_t |
5759 std::bitset<0> bitset0; | 6338 RrcConnectionReestablishmentCompleteHeader::GetRrcTransactionIdentifier () con
st |
5760 | 6339 { |
5761 bIterator = DeserializeDlCcchMessage (bIterator); | 6340 return m_rrcTransactionIdentifier; |
5762 | 6341 } |
5763 // Deserialize RrcConnectionReestablishmentReject sequence | 6342 |
5764 // 0 optional fields, no extension marker | 6343 //////////////////// RrcConnectionReestablishmentRejectHeader class //////////
////////////// |
5765 bIterator = DeserializeSequence (&bitset0,false,bIterator); | 6344 |
5766 | 6345 RrcConnectionReestablishmentRejectHeader::RrcConnectionReestablishmentRejectHe
ader () |
5767 // Deserialize criticalExtensions choice | 6346 { |
5768 int criticalExtensionsChoice; | 6347 } |
5769 bIterator = DeserializeChoice (2,false,&criticalExtensionsChoice,bIterator); | 6348 |
5770 if (criticalExtensionsChoice == 1) | 6349 RrcConnectionReestablishmentRejectHeader::~RrcConnectionReestablishmentRejectH
eader () |
5771 { | 6350 { |
5772 // Deserialize criticalExtensionsFuture | 6351 } |
5773 bIterator = DeserializeSequence (&bitset0,false,bIterator); | 6352 |
5774 } | 6353 void |
5775 else if (criticalExtensionsChoice == 0) | 6354 RrcConnectionReestablishmentRejectHeader::PreSerialize () const |
5776 { | 6355 { |
5777 // Deserialize rrcConnectionReestablishmentReject-r8 | 6356 m_serializationResult = Buffer (); |
5778 std::bitset<1> opts; | 6357 |
5779 bIterator = DeserializeSequence (&opts,false,bIterator); | 6358 // Serialize CCCH message |
5780 if (opts[0]) | 6359 SerializeDlCcchMessage (1); |
5781 { | 6360 |
5782 // Deserialize RRCConnectionReestablishmentReject-v8a0-IEs | 6361 // Serialize RrcConnectionReestablishmentReject sequence: |
5783 // ... | 6362 // no default or optional fields. Extension marker not present. |
5784 } | 6363 SerializeSequence (std::bitset<0> (),false); |
5785 } | 6364 |
5786 | 6365 // Serialize criticalExtensions choice |
5787 return GetSerializedSize (); | 6366 SerializeChoice (2,0,false); |
5788 } | 6367 |
5789 | 6368 // Serialize RRCConnectionReestablishmentReject-r8-IEs sequence |
5790 void | 6369 // 1 optional field (not present), no extension marker. |
5791 RrcConnectionReestablishmentRejectHeader::Print (std::ostream &os) const | 6370 SerializeSequence (std::bitset<1> (0),false); |
5792 { | 6371 |
5793 } | 6372 // Finish serialization |
5794 | 6373 FinalizeSerialization (); |
5795 void | 6374 } |
5796 RrcConnectionReestablishmentRejectHeader::SetMessage (LteRrcSap::RrcConnectionRe
establishmentReject msg) | 6375 |
5797 { | 6376 uint32_t |
5798 m_rrcConnectionReestablishmentReject = msg; | 6377 RrcConnectionReestablishmentRejectHeader::Deserialize (Buffer::Iterator bItera
tor) |
5799 m_isDataSerialized = false; | 6378 { |
5800 } | 6379 std::bitset<0> bitset0; |
5801 | 6380 |
5802 LteRrcSap::RrcConnectionReestablishmentReject | 6381 bIterator = DeserializeDlCcchMessage (bIterator); |
5803 RrcConnectionReestablishmentRejectHeader::GetMessage () const | 6382 |
5804 { | 6383 // Deserialize RrcConnectionReestablishmentReject sequence |
5805 return m_rrcConnectionReestablishmentReject; | 6384 // 0 optional fields, no extension marker |
5806 } | 6385 bIterator = DeserializeSequence (&bitset0,false,bIterator); |
5807 | 6386 |
5808 //////////////////// RrcConnectionReleaseHeader class //////////////////////// | 6387 // Deserialize criticalExtensions choice |
5809 | 6388 int criticalExtensionsChoice; |
5810 RrcConnectionReleaseHeader::RrcConnectionReleaseHeader () | 6389 bIterator = DeserializeChoice (2,false,&criticalExtensionsChoice,bIterator); |
5811 { | 6390 if (criticalExtensionsChoice == 1) |
5812 } | 6391 { |
5813 | 6392 // Deserialize criticalExtensionsFuture |
5814 RrcConnectionReleaseHeader::~RrcConnectionReleaseHeader () | 6393 bIterator = DeserializeSequence (&bitset0,false,bIterator); |
5815 { | 6394 } |
5816 } | 6395 else if (criticalExtensionsChoice == 0) |
5817 | 6396 { |
5818 void | 6397 // Deserialize rrcConnectionReestablishmentReject-r8 |
5819 RrcConnectionReleaseHeader::PreSerialize () const | 6398 std::bitset<1> opts; |
5820 { | 6399 bIterator = DeserializeSequence (&opts,false,bIterator); |
5821 m_serializationResult = Buffer (); | 6400 if (opts[0]) |
5822 | 6401 { |
5823 // Serialize DCCH message | 6402 // Deserialize RRCConnectionReestablishmentReject-v8a0-IEs |
5824 SerializeDlDcchMessage (5); | 6403 // ... |
5825 | 6404 } |
5826 // Serialize RrcConnectionRelease sequence: | 6405 } |
5827 // no default or optional fields. Extension marker not present. | 6406 |
5828 SerializeSequence (std::bitset<0> (),false); | 6407 return GetSerializedSize (); |
5829 | 6408 } |
5830 // Serialize rrc-TransactionIdentifier | 6409 |
5831 SerializeInteger (m_rrcConnectionRelease.rrcTransactionIdentifier,0,3); | 6410 void |
5832 | 6411 RrcConnectionReestablishmentRejectHeader::Print (std::ostream &os) const |
5833 // Serialize criticalExtensions choice | 6412 { |
5834 SerializeChoice (2,0,false); | 6413 } |
5835 | 6414 |
5836 // Serialize c1 choice | 6415 void |
5837 SerializeChoice (4,0,false); | 6416 RrcConnectionReestablishmentRejectHeader::SetMessage (LteRrcSap::RrcConnection
ReestablishmentReject msg) |
5838 | 6417 { |
5839 // Serialize RRCConnectionRelease-r8-IEs sequence | 6418 m_rrcConnectionReestablishmentReject = msg; |
5840 // 3 optional field (not present), no extension marker. | 6419 m_isDataSerialized = false; |
5841 SerializeSequence (std::bitset<3> (0),false); | 6420 } |
5842 | 6421 |
5843 // Serialize ReleaseCause | 6422 LteRrcSap::RrcConnectionReestablishmentReject |
5844 SerializeEnum (4,1); | 6423 RrcConnectionReestablishmentRejectHeader::GetMessage () const |
5845 | 6424 { |
5846 // Finish serialization | 6425 return m_rrcConnectionReestablishmentReject; |
5847 FinalizeSerialization (); | 6426 } |
5848 } | 6427 |
5849 | 6428 //////////////////// RrcConnectionReleaseHeader class //////////////////////// |
5850 uint32_t | 6429 |
5851 RrcConnectionReleaseHeader::Deserialize (Buffer::Iterator bIterator) | 6430 RrcConnectionReleaseHeader::RrcConnectionReleaseHeader () |
5852 { | 6431 { |
5853 std::bitset<0> bitset0; | 6432 } |
5854 int n; | 6433 |
5855 | 6434 RrcConnectionReleaseHeader::~RrcConnectionReleaseHeader () |
5856 bIterator = DeserializeDlDcchMessage (bIterator); | 6435 { |
5857 | 6436 } |
5858 // Deserialize RrcConnectionRelease sequence | 6437 |
5859 // 0 optional fields, no extension marker | 6438 void |
5860 bIterator = DeserializeSequence (&bitset0,false,bIterator); | 6439 RrcConnectionReleaseHeader::PreSerialize () const |
5861 | 6440 { |
5862 // Deserialize rrc-TransactionIdentifier | 6441 m_serializationResult = Buffer (); |
5863 bIterator = DeserializeInteger (&n,0,3,bIterator); | 6442 |
5864 m_rrcConnectionRelease.rrcTransactionIdentifier = n; | 6443 // Serialize DCCH message |
5865 | 6444 SerializeDlDcchMessage (5); |
5866 // Deserialize criticalExtensions choice | 6445 |
5867 int criticalExtensionsChoice; | 6446 // Serialize RrcConnectionRelease sequence: |
5868 bIterator = DeserializeChoice (2,false,&criticalExtensionsChoice,bIterator); | 6447 // no default or optional fields. Extension marker not present. |
5869 if (criticalExtensionsChoice == 1) | 6448 SerializeSequence (std::bitset<0> (),false); |
5870 { | 6449 |
5871 // Deserialize criticalExtensionsFuture | 6450 // Serialize rrc-TransactionIdentifier |
5872 bIterator = DeserializeSequence (&bitset0,false,bIterator); | 6451 SerializeInteger (m_rrcConnectionRelease.rrcTransactionIdentifier,0,3); |
5873 } | 6452 |
5874 else if (criticalExtensionsChoice == 0) | 6453 // Serialize criticalExtensions choice |
5875 { | 6454 SerializeChoice (2,0,false); |
5876 // Deserialize c1 | 6455 |
5877 int c1Choice; | 6456 // Serialize c1 choice |
5878 bIterator = DeserializeChoice (4,false,&c1Choice,bIterator); | 6457 SerializeChoice (4,0,false); |
5879 | 6458 |
5880 if (c1Choice == 0) | 6459 // Serialize RRCConnectionRelease-r8-IEs sequence |
5881 { | 6460 // 3 optional field (not present), no extension marker. |
5882 // Deserialize RRCConnectionRelease-r8-IEs | 6461 SerializeSequence (std::bitset<3> (0),false); |
5883 std::bitset<3> opts; | 6462 |
5884 bIterator = DeserializeSequence (&opts,false,bIterator); | 6463 // Serialize ReleaseCause |
5885 | 6464 SerializeEnum (4,1); |
5886 // Deserialize releaseCause | 6465 |
5887 bIterator = DeserializeEnum (4,&n,bIterator); | 6466 // Finish serialization |
5888 | 6467 FinalizeSerialization (); |
5889 if (opts[2]) | 6468 } |
5890 { | 6469 |
5891 // Deserialize redirectedCarrierInfo | 6470 uint32_t |
5892 // ... | 6471 RrcConnectionReleaseHeader::Deserialize (Buffer::Iterator bIterator) |
5893 } | 6472 { |
5894 if (opts[1]) | 6473 std::bitset<0> bitset0; |
5895 { | 6474 int n; |
5896 // Deserialize idleModeMobilityControlInfo | 6475 |
5897 // ... | 6476 bIterator = DeserializeDlDcchMessage (bIterator); |
5898 } | 6477 |
5899 if (opts[0]) | 6478 // Deserialize RrcConnectionRelease sequence |
5900 { | 6479 // 0 optional fields, no extension marker |
5901 // Deserialize nonCriticalExtension | 6480 bIterator = DeserializeSequence (&bitset0,false,bIterator); |
5902 // ... | 6481 |
5903 } | 6482 // Deserialize rrc-TransactionIdentifier |
5904 } | 6483 bIterator = DeserializeInteger (&n,0,3,bIterator); |
5905 | 6484 m_rrcConnectionRelease.rrcTransactionIdentifier = n; |
5906 else | 6485 |
5907 { | 6486 // Deserialize criticalExtensions choice |
5908 bIterator = DeserializeNull (bIterator); | 6487 int criticalExtensionsChoice; |
5909 } | 6488 bIterator = DeserializeChoice (2,false,&criticalExtensionsChoice,bIterator); |
5910 } | 6489 if (criticalExtensionsChoice == 1) |
5911 | 6490 { |
5912 return GetSerializedSize (); | 6491 // Deserialize criticalExtensionsFuture |
5913 } | 6492 bIterator = DeserializeSequence (&bitset0,false,bIterator); |
5914 | 6493 } |
5915 void | 6494 else if (criticalExtensionsChoice == 0) |
5916 RrcConnectionReleaseHeader::Print (std::ostream &os) const | 6495 { |
5917 { | 6496 // Deserialize c1 |
5918 } | 6497 int c1Choice; |
5919 | 6498 bIterator = DeserializeChoice (4,false,&c1Choice,bIterator); |
5920 void | 6499 |
5921 RrcConnectionReleaseHeader::SetMessage (LteRrcSap::RrcConnectionRelease msg) | 6500 if (c1Choice == 0) |
5922 { | 6501 { |
5923 m_rrcConnectionRelease = msg; | 6502 // Deserialize RRCConnectionRelease-r8-IEs |
5924 m_isDataSerialized = false; | 6503 std::bitset<3> opts; |
5925 } | 6504 bIterator = DeserializeSequence (&opts,false,bIterator); |
5926 | 6505 |
5927 LteRrcSap::RrcConnectionRelease | 6506 // Deserialize releaseCause |
5928 RrcConnectionReleaseHeader::GetMessage () const | 6507 bIterator = DeserializeEnum (4,&n,bIterator); |
5929 { | 6508 |
5930 return m_rrcConnectionRelease; | 6509 if (opts[2]) |
5931 } | 6510 { |
5932 | 6511 // Deserialize redirectedCarrierInfo |
5933 //////////////////// RrcConnectionRejectHeader class //////////////////////// | 6512 // ... |
5934 | 6513 } |
5935 RrcConnectionRejectHeader::RrcConnectionRejectHeader () | 6514 if (opts[1]) |
5936 { | 6515 { |
5937 } | 6516 // Deserialize idleModeMobilityControlInfo |
5938 | 6517 // ... |
5939 RrcConnectionRejectHeader::~RrcConnectionRejectHeader () | 6518 } |
5940 { | 6519 if (opts[0]) |
5941 } | 6520 { |
5942 | 6521 // Deserialize nonCriticalExtension |
5943 void | 6522 // ... |
5944 RrcConnectionRejectHeader::PreSerialize () const | 6523 } |
5945 { | 6524 } |
5946 m_serializationResult = Buffer (); | 6525 |
5947 | 6526 else |
5948 // Serialize CCCH message | 6527 { |
5949 SerializeDlCcchMessage (2); | 6528 bIterator = DeserializeNull (bIterator); |
5950 | 6529 } |
5951 // Serialize RrcConnectionReject sequence: | 6530 } |
5952 // no default or optional fields. Extension marker not present. | 6531 |
5953 SerializeSequence (std::bitset<0> (),false); | 6532 return GetSerializedSize (); |
5954 | 6533 } |
5955 // Serialize criticalExtensions choice | 6534 |
5956 SerializeChoice (2,0,false); | 6535 void |
5957 | 6536 RrcConnectionReleaseHeader::Print (std::ostream &os) const |
5958 // Serialize c1 choice | 6537 { |
5959 SerializeChoice (4,0,false); | 6538 } |
5960 | 6539 |
5961 // Serialize rrcConnectionReject-r8 sequence | 6540 void |
5962 // 1 optional field (not present), no extension marker. | 6541 RrcConnectionReleaseHeader::SetMessage (LteRrcSap::RrcConnectionRelease msg) |
5963 SerializeSequence (std::bitset<1> (0),false); | 6542 { |
5964 | 6543 m_rrcConnectionRelease = msg; |
5965 // Serialize waitTime | 6544 m_isDataSerialized = false; |
5966 SerializeInteger (m_rrcConnectionReject.waitTime, 1, 16); | 6545 } |
5967 | 6546 |
5968 // Finish serialization | 6547 LteRrcSap::RrcConnectionRelease |
5969 FinalizeSerialization (); | 6548 RrcConnectionReleaseHeader::GetMessage () const |
5970 } | 6549 { |
5971 | 6550 return m_rrcConnectionRelease; |
5972 uint32_t | 6551 } |
5973 RrcConnectionRejectHeader::Deserialize (Buffer::Iterator bIterator) | 6552 |
5974 { | 6553 //////////////////// RrcConnectionRejectHeader class //////////////////////// |
5975 std::bitset<0> bitset0; | 6554 |
5976 int n; | 6555 RrcConnectionRejectHeader::RrcConnectionRejectHeader () |
5977 | 6556 { |
5978 bIterator = DeserializeDlCcchMessage (bIterator); | 6557 } |
5979 | 6558 |
5980 // Deserialize RrcConnectionReject sequence | 6559 RrcConnectionRejectHeader::~RrcConnectionRejectHeader () |
5981 // 0 optional fields, no extension marker | 6560 { |
5982 bIterator = DeserializeSequence (&bitset0,false,bIterator); | 6561 } |
5983 | 6562 |
5984 // Deserialize criticalExtensions choice | 6563 void |
5985 int criticalExtensionsChoice; | 6564 RrcConnectionRejectHeader::PreSerialize () const |
5986 bIterator = DeserializeChoice (2,false,&criticalExtensionsChoice,bIterator); | 6565 { |
5987 if (criticalExtensionsChoice == 1) | 6566 m_serializationResult = Buffer (); |
5988 { | 6567 |
5989 // Deserialize criticalExtensionsFuture | 6568 // Serialize CCCH message |
5990 bIterator = DeserializeSequence (&bitset0,false,bIterator); | 6569 SerializeDlCcchMessage (2); |
5991 } | 6570 |
5992 else if (criticalExtensionsChoice == 0) | 6571 // Serialize RrcConnectionReject sequence: |
5993 { | 6572 // no default or optional fields. Extension marker not present. |
5994 // Deserialize c1 choice | 6573 SerializeSequence (std::bitset<0> (),false); |
5995 int c1Choice; | 6574 |
5996 bIterator = DeserializeChoice (4,false,&c1Choice,bIterator); | 6575 // Serialize criticalExtensions choice |
5997 | 6576 SerializeChoice (2,0,false); |
5998 if (c1Choice > 0) | 6577 |
5999 { | 6578 // Serialize c1 choice |
6000 bIterator = DeserializeNull (bIterator); | 6579 SerializeChoice (4,0,false); |
6001 } | 6580 |
6002 else if (c1Choice == 0) | 6581 // Serialize rrcConnectionReject-r8 sequence |
6003 { | 6582 // 1 optional field (not present), no extension marker. |
6004 // Deserialize rrcConnectionReject-r8 | 6583 SerializeSequence (std::bitset<1> (0),false); |
6005 std::bitset<1> opts; | 6584 |
6006 bIterator = DeserializeSequence (&opts,false,bIterator); | 6585 // Serialize waitTime |
6007 | 6586 SerializeInteger (m_rrcConnectionReject.waitTime, 1, 16); |
6008 bIterator = DeserializeInteger (&n,1,16,bIterator); | 6587 |
6009 m_rrcConnectionReject.waitTime = n; | 6588 // Finish serialization |
6010 | 6589 FinalizeSerialization (); |
6011 if (opts[0]) | 6590 } |
6012 { | 6591 |
6013 // Deserialize RRCConnectionReject-v8a0-IEs | 6592 uint32_t |
6014 // ... | 6593 RrcConnectionRejectHeader::Deserialize (Buffer::Iterator bIterator) |
6015 } | 6594 { |
6016 } | 6595 std::bitset<0> bitset0; |
6017 } | 6596 int n; |
6018 | 6597 |
6019 return GetSerializedSize (); | 6598 bIterator = DeserializeDlCcchMessage (bIterator); |
6020 } | 6599 |
6021 | 6600 // Deserialize RrcConnectionReject sequence |
6022 void | 6601 // 0 optional fields, no extension marker |
6023 RrcConnectionRejectHeader::Print (std::ostream &os) const | 6602 bIterator = DeserializeSequence (&bitset0,false,bIterator); |
6024 { | 6603 |
6025 os << "wait time: " << (int)m_rrcConnectionReject.waitTime << std::endl; | 6604 // Deserialize criticalExtensions choice |
6026 } | 6605 int criticalExtensionsChoice; |
6027 | 6606 bIterator = DeserializeChoice (2,false,&criticalExtensionsChoice,bIterator); |
6028 void | 6607 if (criticalExtensionsChoice == 1) |
6029 RrcConnectionRejectHeader::SetMessage (LteRrcSap::RrcConnectionReject msg) | 6608 { |
6030 { | 6609 // Deserialize criticalExtensionsFuture |
6031 m_rrcConnectionReject = msg; | 6610 bIterator = DeserializeSequence (&bitset0,false,bIterator); |
6032 m_isDataSerialized = false; | 6611 } |
6033 } | 6612 else if (criticalExtensionsChoice == 0) |
6034 | 6613 { |
6035 LteRrcSap::RrcConnectionReject | 6614 // Deserialize c1 choice |
6036 RrcConnectionRejectHeader::GetMessage () const | 6615 int c1Choice; |
6037 { | 6616 bIterator = DeserializeChoice (4,false,&c1Choice,bIterator); |
6038 return m_rrcConnectionReject; | 6617 |
6039 } | 6618 if (c1Choice > 0) |
6040 | 6619 { |
6041 //////////////////// MeasurementReportHeader class //////////////////////// | 6620 bIterator = DeserializeNull (bIterator); |
6042 | 6621 } |
6043 MeasurementReportHeader::MeasurementReportHeader () | 6622 else if (c1Choice == 0) |
6044 { | 6623 { |
6045 } | 6624 // Deserialize rrcConnectionReject-r8 |
6046 | 6625 std::bitset<1> opts; |
6047 MeasurementReportHeader::~MeasurementReportHeader () | 6626 bIterator = DeserializeSequence (&opts,false,bIterator); |
6048 { | 6627 |
6049 } | 6628 bIterator = DeserializeInteger (&n,1,16,bIterator); |
6050 | 6629 m_rrcConnectionReject.waitTime = n; |
6051 void | 6630 |
6052 MeasurementReportHeader::PreSerialize () const | 6631 if (opts[0]) |
6053 { | 6632 { |
6054 m_serializationResult = Buffer (); | 6633 // Deserialize RRCConnectionReject-v8a0-IEs |
6055 | 6634 // ... |
6056 // Serialize DCCH message | 6635 } |
6057 SerializeUlDcchMessage (1); | 6636 } |
6058 | 6637 } |
6059 // Serialize MeasurementReport sequence: | 6638 |
6060 // no default or optional fields. Extension marker not present. | 6639 return GetSerializedSize (); |
6061 SerializeSequence (std::bitset<0> (),false); | 6640 } |
6062 | 6641 |
6063 // Serialize criticalExtensions choice: | 6642 void |
6064 // c1 chosen | 6643 RrcConnectionRejectHeader::Print (std::ostream &os) const |
6065 SerializeChoice (2,0,false); | 6644 { |
6066 | 6645 os << "wait time: " << (int)m_rrcConnectionReject.waitTime << std::endl; |
6067 // Serialize c1 choice | 6646 } |
6068 // measurementReport-r8 chosen | 6647 |
6069 SerializeChoice (8,0,false); | 6648 void |
6070 | 6649 RrcConnectionRejectHeader::SetMessage (LteRrcSap::RrcConnectionReject msg) |
6071 // Serialize MeasurementReport-r8-IEs sequence: | 6650 { |
6072 // 1 optional fields, not present. Extension marker not present. | 6651 m_rrcConnectionReject = msg; |
6073 SerializeSequence (std::bitset<1> (0),false); | 6652 m_isDataSerialized = false; |
6074 | 6653 } |
6075 // Serialize measResults | 6654 |
6076 SerializeMeasResults (m_measurementReport.measResults); | 6655 LteRrcSap::RrcConnectionReject |
6077 | 6656 RrcConnectionRejectHeader::GetMessage () const |
6078 // Finish serialization | 6657 { |
6079 FinalizeSerialization (); | 6658 return m_rrcConnectionReject; |
6080 } | 6659 } |
6081 | 6660 |
6082 uint32_t | 6661 //////////////////// MeasurementReportHeader class //////////////////////// |
6083 MeasurementReportHeader::Deserialize (Buffer::Iterator bIterator) | 6662 |
6084 { | 6663 MeasurementReportHeader::MeasurementReportHeader () |
6085 std::bitset<0> bitset0; | 6664 { |
6086 | 6665 } |
6087 bIterator = DeserializeSequence (&bitset0,false,bIterator); | 6666 |
6088 | 6667 MeasurementReportHeader::~MeasurementReportHeader () |
6089 bIterator = DeserializeUlDcchMessage (bIterator); | 6668 { |
6090 | 6669 } |
6091 int criticalExtensionsChoice; | 6670 |
6092 bIterator = DeserializeChoice (2,false,&criticalExtensionsChoice,bIterator); | 6671 void |
6093 | 6672 MeasurementReportHeader::PreSerialize () const |
6094 if (criticalExtensionsChoice == 1) | 6673 { |
6095 { | 6674 m_serializationResult = Buffer (); |
6096 // Deserialize criticalExtensionsFuture | 6675 |
6097 bIterator = DeserializeSequence (&bitset0,false,bIterator); | 6676 // Serialize DCCH message |
6098 } | 6677 SerializeUlDcchMessage (1); |
6099 else if (criticalExtensionsChoice == 0) | 6678 |
6100 { | 6679 // Serialize MeasurementReport sequence: |
6101 // Deserialize c1 | 6680 // no default or optional fields. Extension marker not present. |
6102 int c1Choice; | 6681 SerializeSequence (std::bitset<0> (),false); |
6103 bIterator = DeserializeChoice (8,false,&c1Choice,bIterator); | 6682 |
6104 | 6683 // Serialize criticalExtensions choice: |
6105 if (c1Choice > 0) | 6684 // c1 chosen |
6106 { | 6685 SerializeChoice (2,0,false); |
6107 bIterator = DeserializeNull (bIterator); | 6686 |
6108 } | 6687 // Serialize c1 choice |
6109 else | 6688 // measurementReport-r8 chosen |
6110 { | 6689 SerializeChoice (8,0,false); |
6111 // Deserialize measurementReport-r8 | 6690 |
6112 std::bitset<1> isNonCriticalExtensionPresent; | 6691 // Serialize MeasurementReport-r8-IEs sequence: |
6113 bIterator = DeserializeSequence (&isNonCriticalExtensionPresent,false,
bIterator); | 6692 // 1 optional fields, not present. Extension marker not present. |
6114 | 6693 SerializeSequence (std::bitset<1> (0),false); |
6115 // Deserialize measResults | 6694 |
6116 bIterator = DeserializeMeasResults (&m_measurementReport.measResults,
bIterator); | 6695 // Serialize measResults |
6117 | 6696 SerializeMeasResults (m_measurementReport.measResults); |
6118 if (isNonCriticalExtensionPresent[0]) | 6697 |
6119 { | 6698 // Finish serialization |
6120 // Deserialize nonCriticalExtension MeasurementReport-v8a0-IEs | 6699 FinalizeSerialization (); |
6121 // ... | 6700 } |
6122 } | 6701 |
6123 | 6702 uint32_t |
6124 } | 6703 MeasurementReportHeader::Deserialize (Buffer::Iterator bIterator) |
6125 } | 6704 { |
6126 | 6705 std::bitset<0> bitset0; |
6127 return GetSerializedSize (); | 6706 |
6128 } | 6707 bIterator = DeserializeSequence (&bitset0,false,bIterator); |
6129 | 6708 |
6130 void | 6709 bIterator = DeserializeUlDcchMessage (bIterator); |
6131 MeasurementReportHeader::Print (std::ostream &os) const | 6710 |
6132 { | 6711 int criticalExtensionsChoice; |
6133 os << "measId = " << (int)m_measurementReport.measResults.measId << std::endl; | 6712 bIterator = DeserializeChoice (2,false,&criticalExtensionsChoice,bIterator); |
6134 os << "rsrpResult = " << (int)m_measurementReport.measResults.rsrpResult << st
d::endl; | 6713 |
6135 os << "rsrqResult = " << (int)m_measurementReport.measResults.rsrqResult << st
d::endl; | 6714 if (criticalExtensionsChoice == 1) |
6136 os << "haveMeasResultNeighCells = " << (int)m_measurementReport.measResults.ha
veMeasResultNeighCells << std::endl; | 6715 { |
6137 | 6716 // Deserialize criticalExtensionsFuture |
6138 if (m_measurementReport.measResults.haveMeasResultNeighCells) | 6717 bIterator = DeserializeSequence (&bitset0,false,bIterator); |
6139 { | 6718 } |
6140 std::list<LteRrcSap::MeasResultEutra> measResultListEutra = m_measurementR
eport.measResults.measResultListEutra; | 6719 else if (criticalExtensionsChoice == 0) |
6141 std::list<LteRrcSap::MeasResultEutra>::iterator it = measResultListEutra.b
egin (); | 6720 { |
6142 for (; it != measResultListEutra.end (); it++) | 6721 // Deserialize c1 |
6143 { | 6722 int c1Choice; |
6144 os << " physCellId =" << (int) it->physCellId << std::endl; | 6723 bIterator = DeserializeChoice (8,false,&c1Choice,bIterator); |
6145 os << " haveCgiInfo =" << it->haveCgiInfo << std::endl; | 6724 |
6146 if (it->haveCgiInfo) | 6725 if (c1Choice > 0) |
6147 { | 6726 { |
6148 os << " plmnIdentity = " << (int) it->cgiInfo.plmnIdentity <<
std::endl; | 6727 bIterator = DeserializeNull (bIterator); |
6149 os << " cellIdentity = " << (int) it->cgiInfo.cellIdentity <<
std::endl; | 6728 } |
6150 os << " trackingAreaCode = " << (int) it->cgiInfo.trackingAre
aCode << std::endl; | 6729 else |
6151 os << " havePlmnIdentityList = " << !it->cgiInfo.plmnIdentity
List.empty () << std::endl; | 6730 { |
6152 if (!it->cgiInfo.plmnIdentityList.empty ()) | 6731 // Deserialize measurementReport-r8 |
6153 { | 6732 std::bitset<1> isNonCriticalExtensionPresent; |
6154 for (std::list<uint32_t>::iterator it2 = it->cgiInfo.plmnIdent
ityList.begin (); it2 != it->cgiInfo.plmnIdentityList.begin (); it2++) | 6733 bIterator = DeserializeSequence (&isNonCriticalExtensionPresent,fals
e,bIterator); |
6155 { | 6734 |
6156 os << " plmnId : " << *it2 << std::endl; | 6735 // Deserialize measResults |
6157 } | 6736 bIterator = DeserializeMeasResults (&m_measurementReport.measResults
, bIterator); |
6158 } | 6737 |
6159 } | 6738 if (isNonCriticalExtensionPresent[0]) |
6160 | 6739 { |
6161 os << " haveRsrpResult =" << it->haveRsrpResult << std::endl; | 6740 // Deserialize nonCriticalExtension MeasurementReport-v8a0-IEs |
6162 if (it->haveRsrpResult) | 6741 // ... |
6163 { | 6742 } |
6164 os << " rsrpResult =" << (int) it->rsrpResult << std::endl; | 6743 |
6165 } | 6744 } |
6166 | 6745 } |
6167 os << " haveRsrqResult =" << it->haveRsrqResult << std::endl; | 6746 |
6168 if (it->haveRsrqResult) | 6747 return GetSerializedSize (); |
6169 { | 6748 } |
6170 os << " rsrqResult =" << (int) it->rsrqResult << std::endl; | 6749 |
6171 } | 6750 void |
6172 | 6751 MeasurementReportHeader::Print (std::ostream &os) const |
6173 } | 6752 { |
6174 } | 6753 os << "measId = " << (int)m_measurementReport.measResults.measId << std::end
l; |
6175 } | 6754 os << "rsrpResult = " << (int)m_measurementReport.measResults.rsrpResult <<
std::endl; |
6176 | 6755 os << "rsrqResult = " << (int)m_measurementReport.measResults.rsrqResult <<
std::endl; |
6177 void | 6756 os << "haveMeasResultNeighCells = " << (int)m_measurementReport.measResults.
haveMeasResultNeighCells << std::endl; |
6178 MeasurementReportHeader::SetMessage (LteRrcSap::MeasurementReport msg) | 6757 |
6179 { | 6758 if (m_measurementReport.measResults.haveMeasResultNeighCells) |
6180 m_measurementReport = msg; | 6759 { |
6181 m_isDataSerialized = false; | 6760 std::list<LteRrcSap::MeasResultEutra> measResultListEutra = m_measuremen
tReport.measResults.measResultListEutra; |
6182 } | 6761 std::list<LteRrcSap::MeasResultEutra>::iterator it = measResultListEutra
.begin (); |
6183 | 6762 for (; it != measResultListEutra.end (); it++) |
6184 LteRrcSap::MeasurementReport | 6763 { |
6185 MeasurementReportHeader::GetMessage () const | 6764 os << " physCellId =" << (int) it->physCellId << std::endl; |
6186 { | 6765 os << " haveCgiInfo =" << it->haveCgiInfo << std::endl; |
6187 LteRrcSap::MeasurementReport msg; | 6766 if (it->haveCgiInfo) |
6188 msg = m_measurementReport; | 6767 { |
6189 return msg; | 6768 os << " plmnIdentity = " << (int) it->cgiInfo.plmnIdentity
<< std::endl; |
6190 } | 6769 os << " cellIdentity = " << (int) it->cgiInfo.cellIdentity
<< std::endl; |
6191 | 6770 os << " trackingAreaCode = " << (int) it->cgiInfo.trackingA
reaCode << std::endl; |
6192 /////////////////// RrcUlDcchMessage ////////////////////////////////// | 6771 os << " havePlmnIdentityList = " << !it->cgiInfo.plmnIdenti
tyList.empty () << std::endl; |
6193 RrcUlDcchMessage::RrcUlDcchMessage () : RrcAsn1Header () | 6772 if (!it->cgiInfo.plmnIdentityList.empty ()) |
6194 { | 6773 { |
6195 } | 6774 for (std::list<uint32_t>::iterator it2 = it->cgiInfo.plmnIde
ntityList.begin (); it2 != it->cgiInfo.plmnIdentityList.begin (); it2++) |
6196 | 6775 { |
6197 RrcUlDcchMessage::~RrcUlDcchMessage () | 6776 os << " plmnId : " << *it2 << std::endl; |
6198 { | 6777 } |
6199 } | 6778 } |
6200 | 6779 } |
6201 uint32_t | 6780 |
6202 RrcUlDcchMessage::Deserialize (Buffer::Iterator bIterator) | 6781 os << " haveRsrpResult =" << it->haveRsrpResult << std::endl; |
6203 { | 6782 if (it->haveRsrpResult) |
6204 DeserializeUlDcchMessage (bIterator); | 6783 { |
6205 return 1; | 6784 os << " rsrpResult =" << (int) it->rsrpResult << std::endl; |
6206 } | 6785 } |
6207 | 6786 |
6208 void | 6787 os << " haveRsrqResult =" << it->haveRsrqResult << std::endl; |
6209 RrcUlDcchMessage::Print (std::ostream &os) const | 6788 if (it->haveRsrqResult) |
6210 { | 6789 { |
6211 std::cout << "UL DCCH MSG TYPE: " << m_messageType << std::endl; | 6790 os << " rsrqResult =" << (int) it->rsrqResult << std::endl; |
6212 } | 6791 } |
6213 | 6792 |
6214 void | 6793 } |
6215 RrcUlDcchMessage::PreSerialize () const | 6794 } |
6216 { | 6795 } |
6217 SerializeUlDcchMessage (m_messageType); | 6796 |
6218 } | 6797 void |
6219 | 6798 MeasurementReportHeader::SetMessage (LteRrcSap::MeasurementReport msg) |
6220 Buffer::Iterator | 6799 { |
6221 RrcUlDcchMessage::DeserializeUlDcchMessage (Buffer::Iterator bIterator) | 6800 m_measurementReport = msg; |
6222 { | 6801 m_isDataSerialized = false; |
6223 std::bitset<0> bitset0; | 6802 } |
6224 int n; | 6803 |
6225 | 6804 LteRrcSap::MeasurementReport |
6226 bIterator = DeserializeSequence (&bitset0,false,bIterator); | 6805 MeasurementReportHeader::GetMessage () const |
6227 bIterator = DeserializeChoice (2,false,&n,bIterator); | 6806 { |
6228 if (n == 1) | 6807 LteRrcSap::MeasurementReport msg; |
6229 { | 6808 msg = m_measurementReport; |
6230 // Deserialize messageClassExtension | 6809 return msg; |
6231 bIterator = DeserializeSequence (&bitset0,false,bIterator); | 6810 } |
6232 m_messageType = -1; | 6811 |
6233 } | 6812 /////////////////// RrcUlDcchMessage ////////////////////////////////// |
6234 else if (n == 0) | 6813 RrcUlDcchMessage::RrcUlDcchMessage () : RrcAsn1Header () |
6235 { | 6814 { |
6236 // Deserialize c1 | 6815 } |
6237 bIterator = DeserializeChoice (16,false,&m_messageType,bIterator); | 6816 |
6238 } | 6817 RrcUlDcchMessage::~RrcUlDcchMessage () |
6239 | 6818 { |
6240 return bIterator; | 6819 } |
6241 } | 6820 |
6242 | 6821 uint32_t |
6243 void | 6822 RrcUlDcchMessage::Deserialize (Buffer::Iterator bIterator) |
6244 RrcUlDcchMessage::SerializeUlDcchMessage (int messageType) const | 6823 { |
6245 { | 6824 DeserializeUlDcchMessage (bIterator); |
6246 SerializeSequence (std::bitset<0> (),false); | 6825 return 1; |
6247 // Choose c1 | 6826 } |
6248 SerializeChoice (2,0,false); | 6827 |
6249 // Choose message type | 6828 void |
6250 SerializeChoice (16,messageType,false); | 6829 RrcUlDcchMessage::Print (std::ostream &os) const |
6251 } | 6830 { |
6252 | 6831 std::cout << "UL DCCH MSG TYPE: " << m_messageType << std::endl; |
6253 /////////////////// RrcDlDcchMessage ////////////////////////////////// | 6832 } |
6254 RrcDlDcchMessage::RrcDlDcchMessage () : RrcAsn1Header () | 6833 |
6255 { | 6834 void |
6256 } | 6835 RrcUlDcchMessage::PreSerialize () const |
6257 | 6836 { |
6258 RrcDlDcchMessage::~RrcDlDcchMessage () | 6837 SerializeUlDcchMessage (m_messageType); |
6259 { | 6838 } |
6260 } | 6839 |
6261 | 6840 Buffer::Iterator |
6262 uint32_t | 6841 RrcUlDcchMessage::DeserializeUlDcchMessage (Buffer::Iterator bIterator) |
6263 RrcDlDcchMessage::Deserialize (Buffer::Iterator bIterator) | 6842 { |
6264 { | 6843 std::bitset<0> bitset0; |
6265 DeserializeDlDcchMessage (bIterator); | 6844 int n; |
6266 return 1; | 6845 |
6267 } | 6846 bIterator = DeserializeSequence (&bitset0,false,bIterator); |
6268 | 6847 bIterator = DeserializeChoice (2,false,&n,bIterator); |
6269 void | 6848 if (n == 1) |
6270 RrcDlDcchMessage::Print (std::ostream &os) const | 6849 { |
6271 { | 6850 // Deserialize messageClassExtension |
6272 std::cout << "DL DCCH MSG TYPE: " << m_messageType << std::endl; | 6851 bIterator = DeserializeSequence (&bitset0,false,bIterator); |
6273 } | 6852 m_messageType = -1; |
6274 | 6853 } |
6275 void | 6854 else if (n == 0) |
6276 RrcDlDcchMessage::PreSerialize () const | 6855 { |
6277 { | 6856 // Deserialize c1 |
6278 SerializeDlDcchMessage (m_messageType); | 6857 bIterator = DeserializeChoice (16,false,&m_messageType,bIterator); |
6279 } | 6858 } |
6280 | 6859 |
6281 Buffer::Iterator | 6860 return bIterator; |
6282 RrcDlDcchMessage::DeserializeDlDcchMessage (Buffer::Iterator bIterator) | 6861 } |
6283 { | 6862 |
6284 std::bitset<0> bitset0; | 6863 void |
6285 int n; | 6864 RrcUlDcchMessage::SerializeUlDcchMessage (int messageType) const |
6286 | 6865 { |
6287 bIterator = DeserializeSequence (&bitset0,false,bIterator); | 6866 SerializeSequence (std::bitset<0> (),false); |
6288 bIterator = DeserializeChoice (2,false,&n,bIterator); | 6867 // Choose c1 |
6289 if (n == 1) | 6868 SerializeChoice (2,0,false); |
6290 { | 6869 // Choose message type |
6291 // Deserialize messageClassExtension | 6870 SerializeChoice (16,messageType,false); |
6292 bIterator = DeserializeSequence (&bitset0,false,bIterator); | 6871 } |
6293 m_messageType = -1; | 6872 |
6294 } | 6873 /////////////////// RrcDlDcchMessage ////////////////////////////////// |
6295 else if (n == 0) | 6874 RrcDlDcchMessage::RrcDlDcchMessage () : RrcAsn1Header () |
6296 { | 6875 { |
6297 // Deserialize c1 | 6876 } |
6298 bIterator = DeserializeChoice (16,false,&m_messageType,bIterator); | 6877 |
6299 } | 6878 RrcDlDcchMessage::~RrcDlDcchMessage () |
6300 | 6879 { |
6301 return bIterator; | 6880 } |
6302 } | 6881 |
6303 | 6882 uint32_t |
6304 void | 6883 RrcDlDcchMessage::Deserialize (Buffer::Iterator bIterator) |
6305 RrcDlDcchMessage::SerializeDlDcchMessage (int messageType) const | 6884 { |
6306 { | 6885 DeserializeDlDcchMessage (bIterator); |
6307 SerializeSequence (std::bitset<0> (),false); | 6886 return 1; |
6308 // Choose c1 | 6887 } |
6309 SerializeChoice (2,0,false); | 6888 |
6310 // Choose message type | 6889 void |
6311 SerializeChoice (16,messageType,false); | 6890 RrcDlDcchMessage::Print (std::ostream &os) const |
6312 } | 6891 { |
6313 | 6892 std::cout << "DL DCCH MSG TYPE: " << m_messageType << std::endl; |
6314 /////////////////// RrcUlCcchMessage ////////////////////////////////// | 6893 } |
6315 RrcUlCcchMessage::RrcUlCcchMessage () : RrcAsn1Header () | 6894 |
6316 { | 6895 void |
6317 } | 6896 RrcDlDcchMessage::PreSerialize () const |
6318 | 6897 { |
6319 RrcUlCcchMessage::~RrcUlCcchMessage () | 6898 SerializeDlDcchMessage (m_messageType); |
6320 { | 6899 } |
6321 } | 6900 |
6322 | 6901 Buffer::Iterator |
6323 uint32_t | 6902 RrcDlDcchMessage::DeserializeDlDcchMessage (Buffer::Iterator bIterator) |
6324 RrcUlCcchMessage::Deserialize (Buffer::Iterator bIterator) | 6903 { |
6325 { | 6904 std::bitset<0> bitset0; |
6326 DeserializeUlCcchMessage (bIterator); | 6905 int n; |
6327 return 1; | 6906 |
6328 } | 6907 bIterator = DeserializeSequence (&bitset0,false,bIterator); |
6329 | 6908 bIterator = DeserializeChoice (2,false,&n,bIterator); |
6330 void | 6909 if (n == 1) |
6331 RrcUlCcchMessage::Print (std::ostream &os) const | 6910 { |
6332 { | 6911 // Deserialize messageClassExtension |
6333 std::cout << "UL CCCH MSG TYPE: " << m_messageType << std::endl; | 6912 bIterator = DeserializeSequence (&bitset0,false,bIterator); |
6334 } | 6913 m_messageType = -1; |
6335 | 6914 } |
6336 void | 6915 else if (n == 0) |
6337 RrcUlCcchMessage::PreSerialize () const | 6916 { |
6338 { | 6917 // Deserialize c1 |
6339 SerializeUlCcchMessage (m_messageType); | 6918 bIterator = DeserializeChoice (16,false,&m_messageType,bIterator); |
6340 } | 6919 } |
6341 | 6920 |
6342 Buffer::Iterator | 6921 return bIterator; |
6343 RrcUlCcchMessage::DeserializeUlCcchMessage (Buffer::Iterator bIterator) | 6922 } |
6344 { | 6923 |
6345 std::bitset<0> bitset0; | 6924 void |
6346 int n; | 6925 RrcDlDcchMessage::SerializeDlDcchMessage (int messageType) const |
6347 | 6926 { |
6348 bIterator = DeserializeSequence (&bitset0,false,bIterator); | 6927 SerializeSequence (std::bitset<0> (),false); |
6349 bIterator = DeserializeChoice (2,false,&n,bIterator); | 6928 // Choose c1 |
6350 if (n == 1) | 6929 SerializeChoice (2,0,false); |
6351 { | 6930 // Choose message type |
6352 // Deserialize messageClassExtension | 6931 SerializeChoice (16,messageType,false); |
6353 bIterator = DeserializeSequence (&bitset0,false,bIterator); | 6932 } |
6354 m_messageType = -1; | 6933 |
6355 } | 6934 /////////////////// RrcUlCcchMessage ////////////////////////////////// |
6356 else if (n == 0) | 6935 RrcUlCcchMessage::RrcUlCcchMessage () : RrcAsn1Header () |
6357 { | 6936 { |
6358 // Deserialize c1 | 6937 } |
6359 bIterator = DeserializeChoice (2,false,&m_messageType,bIterator); | 6938 |
6360 } | 6939 RrcUlCcchMessage::~RrcUlCcchMessage () |
6361 | 6940 { |
6362 return bIterator; | 6941 } |
6363 } | 6942 |
6364 | 6943 uint32_t |
6365 void | 6944 RrcUlCcchMessage::Deserialize (Buffer::Iterator bIterator) |
6366 RrcUlCcchMessage::SerializeUlCcchMessage (int messageType) const | 6945 { |
6367 { | 6946 DeserializeUlCcchMessage (bIterator); |
6368 SerializeSequence (std::bitset<0> (),false); | 6947 return 1; |
6369 // Choose c1 | 6948 } |
6370 SerializeChoice (2,0,false); | 6949 |
6371 // Choose message type | 6950 void |
6372 SerializeChoice (2,messageType,false); | 6951 RrcUlCcchMessage::Print (std::ostream &os) const |
6373 } | 6952 { |
6374 | 6953 std::cout << "UL CCCH MSG TYPE: " << m_messageType << std::endl; |
6375 /////////////////// RrcDlCcchMessage ////////////////////////////////// | 6954 } |
6376 RrcDlCcchMessage::RrcDlCcchMessage () : RrcAsn1Header () | 6955 |
6377 { | 6956 void |
6378 } | 6957 RrcUlCcchMessage::PreSerialize () const |
6379 | 6958 { |
6380 RrcDlCcchMessage::~RrcDlCcchMessage () | 6959 SerializeUlCcchMessage (m_messageType); |
6381 { | 6960 } |
6382 } | 6961 |
6383 | 6962 Buffer::Iterator |
6384 uint32_t | 6963 RrcUlCcchMessage::DeserializeUlCcchMessage (Buffer::Iterator bIterator) |
6385 RrcDlCcchMessage::Deserialize (Buffer::Iterator bIterator) | 6964 { |
6386 { | 6965 std::bitset<0> bitset0; |
6387 DeserializeDlCcchMessage (bIterator); | 6966 int n; |
6388 return 1; | 6967 |
6389 } | 6968 bIterator = DeserializeSequence (&bitset0,false,bIterator); |
6390 | 6969 bIterator = DeserializeChoice (2,false,&n,bIterator); |
6391 void | 6970 if (n == 1) |
6392 RrcDlCcchMessage::Print (std::ostream &os) const | 6971 { |
6393 { | 6972 // Deserialize messageClassExtension |
6394 std::cout << "DL CCCH MSG TYPE: " << m_messageType << std::endl; | 6973 bIterator = DeserializeSequence (&bitset0,false,bIterator); |
6395 } | 6974 m_messageType = -1; |
6396 | 6975 } |
6397 void | 6976 else if (n == 0) |
6398 RrcDlCcchMessage::PreSerialize () const | 6977 { |
6399 { | 6978 // Deserialize c1 |
6400 SerializeDlCcchMessage (m_messageType); | 6979 bIterator = DeserializeChoice (2,false,&m_messageType,bIterator); |
6401 } | 6980 } |
6402 | 6981 |
6403 Buffer::Iterator | 6982 return bIterator; |
6404 RrcDlCcchMessage::DeserializeDlCcchMessage (Buffer::Iterator bIterator) | 6983 } |
6405 { | 6984 |
6406 std::bitset<0> bitset0; | 6985 void |
6407 int n; | 6986 RrcUlCcchMessage::SerializeUlCcchMessage (int messageType) const |
6408 | 6987 { |
6409 bIterator = DeserializeSequence (&bitset0,false,bIterator); | 6988 SerializeSequence (std::bitset<0> (),false); |
6410 bIterator = DeserializeChoice (2,false,&n,bIterator); | 6989 // Choose c1 |
6411 if (n == 1) | 6990 SerializeChoice (2,0,false); |
6412 { | 6991 // Choose message type |
6413 // Deserialize messageClassExtension | 6992 SerializeChoice (2,messageType,false); |
6414 bIterator = DeserializeSequence (&bitset0,false,bIterator); | 6993 } |
6415 m_messageType = -1; | 6994 |
6416 } | 6995 /////////////////// RrcDlCcchMessage ////////////////////////////////// |
6417 else if (n == 0) | 6996 RrcDlCcchMessage::RrcDlCcchMessage () : RrcAsn1Header () |
6418 { | 6997 { |
6419 // Deserialize c1 | 6998 } |
6420 bIterator = DeserializeChoice (4,false,&m_messageType,bIterator); | 6999 |
6421 } | 7000 RrcDlCcchMessage::~RrcDlCcchMessage () |
6422 | 7001 { |
6423 return bIterator; | 7002 } |
6424 } | 7003 |
6425 | 7004 uint32_t |
6426 void | 7005 RrcDlCcchMessage::Deserialize (Buffer::Iterator bIterator) |
6427 RrcDlCcchMessage::SerializeDlCcchMessage (int messageType) const | 7006 { |
6428 { | 7007 DeserializeDlCcchMessage (bIterator); |
6429 SerializeSequence (std::bitset<0> (),false); | 7008 return 1; |
6430 // Choose c1 | 7009 } |
6431 SerializeChoice (2,0,false); | 7010 |
6432 // Choose message type | 7011 void |
6433 SerializeChoice (4,messageType,false); | 7012 RrcDlCcchMessage::Print (std::ostream &os) const |
6434 } | 7013 { |
| 7014 std::cout << "DL CCCH MSG TYPE: " << m_messageType << std::endl; |
| 7015 } |
| 7016 |
| 7017 void |
| 7018 RrcDlCcchMessage::PreSerialize () const |
| 7019 { |
| 7020 SerializeDlCcchMessage (m_messageType); |
| 7021 } |
| 7022 |
| 7023 Buffer::Iterator |
| 7024 RrcDlCcchMessage::DeserializeDlCcchMessage (Buffer::Iterator bIterator) |
| 7025 { |
| 7026 std::bitset<0> bitset0; |
| 7027 int n; |
| 7028 |
| 7029 bIterator = DeserializeSequence (&bitset0,false,bIterator); |
| 7030 bIterator = DeserializeChoice (2,false,&n,bIterator); |
| 7031 if (n == 1) |
| 7032 { |
| 7033 // Deserialize messageClassExtension |
| 7034 bIterator = DeserializeSequence (&bitset0,false,bIterator); |
| 7035 m_messageType = -1; |
| 7036 } |
| 7037 else if (n == 0) |
| 7038 { |
| 7039 // Deserialize c1 |
| 7040 bIterator = DeserializeChoice (4,false,&m_messageType,bIterator); |
| 7041 } |
| 7042 |
| 7043 return bIterator; |
| 7044 } |
| 7045 |
| 7046 void |
| 7047 RrcDlCcchMessage::SerializeDlCcchMessage (int messageType) const |
| 7048 { |
| 7049 SerializeSequence (std::bitset<0> (),false); |
| 7050 // Choose c1 |
| 7051 SerializeChoice (2,0,false); |
| 7052 // Choose message type |
| 7053 SerializeChoice (4,messageType,false); |
| 7054 } |
6435 | 7055 |
6436 } // namespace ns3 | 7056 } // namespace ns3 |
6437 | 7057 |
OLD | NEW |