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 * | 4 * |
5 * This program is free software; you can redistribute it and/or modify | 5 * This program is free software; you can redistribute it and/or modify |
6 * it under the terms of the GNU General Public License version 2 as | 6 * it under the terms of the GNU General Public License version 2 as |
7 * published by the Free Software Foundation; | 7 * published by the Free Software Foundation; |
8 * | 8 * |
9 * This program is distributed in the hope that it will be useful, | 9 * This program is distributed in the hope that it will be useful, |
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of | 10 * but WITHOUT ANY WARRANTY; without even the implied warranty of |
(...skipping 758 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
769 { | 769 { |
770 // plmn-Identity sequence, mcc is optional, no extension marker | 770 // plmn-Identity sequence, mcc is optional, no extension marker |
771 SerializeSequence (std::bitset<1> (0), false); | 771 SerializeSequence (std::bitset<1> (0), false); |
772 | 772 |
773 // Serialize mnc | 773 // Serialize mnc |
774 int nDig = (plmnId > 99) ? 3 : 2; | 774 int nDig = (plmnId > 99) ? 3 : 2; |
775 | 775 |
776 SerializeSequenceOf (nDig,3,2); | 776 SerializeSequenceOf (nDig,3,2); |
777 for (int i = nDig - 1; i >= 0; i--) | 777 for (int i = nDig - 1; i >= 0; i--) |
778 { | 778 { |
779 int n = floor (plmnId / pow (10,i)); | 779 int n = static_cast<int> (floor (plmnId / pow (10,i))); |
780 SerializeInteger (n,0,9); | 780 SerializeInteger (n,0,9); |
781 plmnId -= n * pow (10,i); | 781 plmnId -= static_cast<uint32_t> (n * pow (10,i)); |
782 } | 782 } |
783 | 783 |
784 // cellReservedForOperatorUse· | 784 // cellReservedForOperatorUse· |
785 SerializeEnum (2,0); | 785 SerializeEnum (2,0); |
786 } | 786 } |
787 | 787 |
788 void· | 788 void· |
789 RrcAsn1Header::SerializeRachConfigCommon (LteRrcSap::RachConfigCommon rachConfig
Common) const | 789 RrcAsn1Header::SerializeRachConfigCommon (LteRrcSap::RachConfigCommon rachConfig
Common) const |
790 { | 790 { |
791 // rach-ConfigCommon | 791 // rach-ConfigCommon |
(...skipping 911 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1703 SerializeEnum (4, 3); | 1703 SerializeEnum (4, 3); |
1704 } | 1704 } |
1705 } | 1705 } |
1706 } | 1706 } |
1707 } | 1707 } |
1708 void | 1708 void |
1709 RrcAsn1Header::SerializeNonCriticalExtensionConfiguration (LteRrcSap::NonCriti
calExtensionConfiguration nonCriticalExtension) const | 1709 RrcAsn1Header::SerializeNonCriticalExtensionConfiguration (LteRrcSap::NonCriti
calExtensionConfiguration nonCriticalExtension) const |
1710 { | 1710 { |
1711 // 3 optional fields. Extension marker not present. | 1711 // 3 optional fields. Extension marker not present. |
1712 std::bitset<3> noncriticalExtension_v1020; | 1712 std::bitset<3> noncriticalExtension_v1020; |
1713 noncriticalExtension_v1020.set (2,0); // No sCellToRealeaseList-r10 | 1713 noncriticalExtension_v1020.set (2,0); // No sCellToReleaseList-r10 |
1714 noncriticalExtension_v1020.set (1,1); // sCellToAddModList-r10 | 1714 noncriticalExtension_v1020.set (1,1); // sCellToAddModList-r10 |
1715 noncriticalExtension_v1020.set (0,0); // No nonCriticalExtension RRCConnecti
onReconfiguration-v1130-IEs | 1715 noncriticalExtension_v1020.set (0,0); // No nonCriticalExtension RRCConnecti
onReconfiguration-v1130-IEs |
1716 SerializeSequence (noncriticalExtension_v1020,false); | 1716 SerializeSequence (noncriticalExtension_v1020,false); |
1717 if (!nonCriticalExtension.sCellsToAddModList.empty ()) | 1717 if (!nonCriticalExtension.sCellsToAddModList.empty ()) |
1718 { | 1718 { |
1719 SerializeSequenceOf (nonCriticalExtension.sCellsToAddModList.size (),MAX
_OBJECT_ID,1); | 1719 SerializeSequenceOf (nonCriticalExtension.sCellsToAddModList.size (),MAX
_OBJECT_ID,1); |
1720 for (std::list<LteRrcSap::SCellToAddMod>::iterator it = nonCriticalExten
sion.sCellsToAddModList.begin (); it != nonCriticalExtension.sCellsToAddModList.
end (); it++) | 1720 for (std::list<LteRrcSap::SCellToAddMod>::iterator it = nonCriticalExten
sion.sCellsToAddModList.begin (); it != nonCriticalExtension.sCellsToAddModList.
end (); it++) |
1721 { | 1721 { |
1722 std::bitset<4> sCellToAddMod_r10; | 1722 std::bitset<4> sCellToAddMod_r10; |
1723 sCellToAddMod_r10.set (3,1); // sCellIndex | 1723 sCellToAddMod_r10.set (3,1); // sCellIndex |
(...skipping 261 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1985 RrcAsn1Header::DeserializeThresholdEutra (LteRrcSap::ThresholdEutra * thresholdE
utra, Buffer::Iterator bIterator) | 1985 RrcAsn1Header::DeserializeThresholdEutra (LteRrcSap::ThresholdEutra * thresholdE
utra, Buffer::Iterator bIterator) |
1986 { | 1986 { |
1987 int thresholdEutraChoice, range; | 1987 int thresholdEutraChoice, range; |
1988 bIterator = DeserializeChoice (2, false, &thresholdEutraChoice, bIterator); | 1988 bIterator = DeserializeChoice (2, false, &thresholdEutraChoice, bIterator); |
1989 | 1989 |
1990 switch (thresholdEutraChoice) | 1990 switch (thresholdEutraChoice) |
1991 { | 1991 { |
1992 case 0: | 1992 case 0: |
1993 thresholdEutra->choice = LteRrcSap::ThresholdEutra::THRESHOLD_RSRP; | 1993 thresholdEutra->choice = LteRrcSap::ThresholdEutra::THRESHOLD_RSRP; |
1994 bIterator = DeserializeInteger (&range, 0, 97, bIterator); | 1994 bIterator = DeserializeInteger (&range, 0, 97, bIterator); |
1995 thresholdEutra->range = range; | 1995 thresholdEutra->range = static_cast<uint8_t> (range); |
1996 break; | 1996 break; |
1997 case 1: | 1997 case 1: |
1998 default: | 1998 default: |
1999 thresholdEutra->choice = LteRrcSap::ThresholdEutra::THRESHOLD_RSRQ; | 1999 thresholdEutra->choice = LteRrcSap::ThresholdEutra::THRESHOLD_RSRQ; |
2000 bIterator = DeserializeInteger (&range, 0, 34, bIterator); | 2000 bIterator = DeserializeInteger (&range, 0, 34, bIterator); |
2001 thresholdEutra->range = range; | 2001 thresholdEutra->range = static_cast<uint8_t> (range); |
2002 } | 2002 } |
2003 | 2003 |
2004 return bIterator; | 2004 return bIterator; |
2005 } | 2005 } |
2006 | 2006 |
2007 Buffer::Iterator | 2007 Buffer::Iterator |
2008 RrcAsn1Header::DeserializeQoffsetRange (int8_t * qOffsetRange, Buffer::Iterator
bIterator) | 2008 RrcAsn1Header::DeserializeQoffsetRange (int8_t * qOffsetRange, Buffer::Iterator
bIterator) |
2009 { | 2009 { |
2010 int n; | 2010 int n; |
2011 bIterator = DeserializeEnum (31, &n, bIterator); | 2011 bIterator = DeserializeEnum (31, &n, bIterator); |
(...skipping 117 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2129 | 2129 |
2130 if (optionalFieldsPresent[3]) | 2130 if (optionalFieldsPresent[3]) |
2131 { | 2131 { |
2132 // Deserialize drb-ToReleaseList | 2132 // Deserialize drb-ToReleaseList |
2133 int n; | 2133 int n; |
2134 int val; | 2134 int val; |
2135 bIterator = DeserializeSequenceOf (&n,MAX_DRB,1,bIterator); | 2135 bIterator = DeserializeSequenceOf (&n,MAX_DRB,1,bIterator); |
2136 for (int i = 0; i < n; i++) | 2136 for (int i = 0; i < n; i++) |
2137 { | 2137 { |
2138 bIterator = DeserializeInteger (&val,1,32,bIterator); | 2138 bIterator = DeserializeInteger (&val,1,32,bIterator); |
2139 radioResourceConfigDedicated->drbToReleaseList.push_back (val); | 2139 radioResourceConfigDedicated->drbToReleaseList.push_back (static_cast<
uint8_t> (val)); |
2140 } | 2140 } |
2141 } | 2141 } |
2142 | 2142 |
2143 if (optionalFieldsPresent[2]) | 2143 if (optionalFieldsPresent[2]) |
2144 { | 2144 { |
2145 // Deserialize mac-MainConfig | 2145 // Deserialize mac-MainConfig |
2146 // ... | 2146 // ... |
2147 } | 2147 } |
2148 | 2148 |
2149 if (optionalFieldsPresent[1]) | 2149 if (optionalFieldsPresent[1]) |
(...skipping 25 matching lines...) Expand all Loading... |
2175 { | 2175 { |
2176 LteRrcSap::SrbToAddMod srbToAddMod; | 2176 LteRrcSap::SrbToAddMod srbToAddMod; |
2177 // Deserialize SRB-ToAddMod sequence | 2177 // Deserialize SRB-ToAddMod sequence |
2178 // 2 optional fields, extension marker present | 2178 // 2 optional fields, extension marker present |
2179 std::bitset<2> optionalFields; | 2179 std::bitset<2> optionalFields; |
2180 bIterator = DeserializeSequence (&optionalFields,true,bIterator); | 2180 bIterator = DeserializeSequence (&optionalFields,true,bIterator); |
2181 | 2181 |
2182 // Deserialize srbIdentity | 2182 // Deserialize srbIdentity |
2183 int n; | 2183 int n; |
2184 bIterator = DeserializeInteger (&n,1,2,bIterator); | 2184 bIterator = DeserializeInteger (&n,1,2,bIterator); |
2185 srbToAddMod.srbIdentity = n; | 2185 srbToAddMod.srbIdentity = static_cast<uint8_t> (n); |
2186 | 2186 |
2187 if (optionalFields[1]) | 2187 if (optionalFields[1]) |
2188 { | 2188 { |
2189 // Deserialize rlcConfig choice | 2189 // Deserialize rlcConfig choice |
2190 // ... | 2190 // ... |
2191 } | 2191 } |
2192 | 2192 |
2193 if (optionalFields[0]) | 2193 if (optionalFields[0]) |
2194 { | 2194 { |
2195 // Deserialize logicalChannelConfig choice | 2195 // Deserialize logicalChannelConfig choice |
(...skipping 31 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2227 { | 2227 { |
2228 LteRrcSap::DrbToAddMod drbToAddMod; | 2228 LteRrcSap::DrbToAddMod drbToAddMod; |
2229 | 2229 |
2230 std::bitset<5> optionalFields; | 2230 std::bitset<5> optionalFields; |
2231 bIterator = DeserializeSequence (&optionalFields,true,bIterator); | 2231 bIterator = DeserializeSequence (&optionalFields,true,bIterator); |
2232 | 2232 |
2233 if (optionalFields[4]) | 2233 if (optionalFields[4]) |
2234 { | 2234 { |
2235 // Deserialize epsBearerIdentity | 2235 // Deserialize epsBearerIdentity |
2236 bIterator = DeserializeInteger (&val,0,15,bIterator); | 2236 bIterator = DeserializeInteger (&val,0,15,bIterator); |
2237 drbToAddMod.epsBearerIdentity = val; | 2237 drbToAddMod.epsBearerIdentity = static_cast<uint8_t> (val); |
2238 } | 2238 } |
2239 | 2239 |
2240 bIterator = DeserializeInteger (&val,1,32,bIterator); | 2240 bIterator = DeserializeInteger (&val,1,32,bIterator); |
2241 drbToAddMod.drbIdentity = val; | 2241 drbToAddMod.drbIdentity = static_cast<uint8_t> (val); |
2242 | 2242 |
2243 if (optionalFields[3]) | 2243 if (optionalFields[3]) |
2244 { | 2244 { |
2245 // Deserialize pdcp-Config | 2245 // Deserialize pdcp-Config |
2246 // ... | 2246 // ... |
2247 } | 2247 } |
2248 | 2248 |
2249 if (optionalFields[2]) | 2249 if (optionalFields[2]) |
2250 { | 2250 { |
2251 // Deserialize RLC-Config | 2251 // Deserialize RLC-Config |
(...skipping 49 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2301 bIterator = DeserializeEnum (2,&sel, bIterator); // sn-FieldLength | 2301 bIterator = DeserializeEnum (2,&sel, bIterator); // sn-FieldLength |
2302 bIterator = DeserializeEnum (32,&sel, bIterator); // t-Reordering | 2302 bIterator = DeserializeEnum (32,&sel, bIterator); // t-Reordering |
2303 break; | 2303 break; |
2304 } | 2304 } |
2305 | 2305 |
2306 } | 2306 } |
2307 | 2307 |
2308 if (optionalFields[1]) | 2308 if (optionalFields[1]) |
2309 { | 2309 { |
2310 bIterator = DeserializeInteger (&val,3,10,bIterator); | 2310 bIterator = DeserializeInteger (&val,3,10,bIterator); |
2311 drbToAddMod.logicalChannelIdentity = val; | 2311 drbToAddMod.logicalChannelIdentity = static_cast<uint8_t> (val); |
2312 } | 2312 } |
2313 | 2313 |
2314 if (optionalFields[0]) | 2314 if (optionalFields[0]) |
2315 { | 2315 { |
2316 bIterator = DeserializeLogicalChannelConfig (&drbToAddMod.logicalChann
elConfig,bIterator); | 2316 bIterator = DeserializeLogicalChannelConfig (&drbToAddMod.logicalChann
elConfig,bIterator); |
2317 } | 2317 } |
2318 | 2318 |
2319 drbToAddModList->insert (drbToAddModList->end (),drbToAddMod); | 2319 drbToAddModList->insert (drbToAddModList->end (),drbToAddMod); |
2320 } | 2320 } |
2321 return bIterator; | 2321 return bIterator; |
2322 } | 2322 } |
2323 | 2323 |
2324 Buffer::Iterator | 2324 Buffer::Iterator |
2325 RrcAsn1Header::DeserializeLogicalChannelConfig (LteRrcSap::LogicalChannelConfig
*logicalChannelConfig, Buffer::Iterator bIterator) | 2325 RrcAsn1Header::DeserializeLogicalChannelConfig (LteRrcSap::LogicalChannelConfig
*logicalChannelConfig, Buffer::Iterator bIterator) |
2326 { | 2326 { |
2327 int n; | 2327 int n; |
2328 | 2328 |
2329 // Deserialize LogicalChannelConfig sequence | 2329 // Deserialize LogicalChannelConfig sequence |
2330 // 1 optional field, extension marker is present. | 2330 // 1 optional field, extension marker is present. |
2331 std::bitset<1> bitset1; | 2331 std::bitset<1> bitset1; |
2332 bIterator = DeserializeSequence (&bitset1,true,bIterator); | 2332 bIterator = DeserializeSequence (&bitset1,true,bIterator); |
2333 | 2333 |
2334 if (bitset1[0]) | 2334 if (bitset1[0]) |
2335 { | 2335 { |
2336 // Deserialize ul-SpecificParameters sequence | 2336 // Deserialize ul-SpecificParameters sequence |
2337 bIterator = DeserializeSequence (&bitset1,false,bIterator); | 2337 bIterator = DeserializeSequence (&bitset1,false,bIterator); |
2338 | 2338 |
2339 // Deserialize priority | 2339 // Deserialize priority |
2340 bIterator = DeserializeInteger (&n,1,16,bIterator); | 2340 bIterator = DeserializeInteger (&n,1,16,bIterator); |
2341 logicalChannelConfig->priority = n; | 2341 logicalChannelConfig->priority = static_cast<uint8_t> (n); |
2342 | 2342 |
2343 // Deserialize prioritisedBitRate | 2343 // Deserialize prioritisedBitRate |
2344 bIterator = DeserializeEnum (16,&n,bIterator); | 2344 bIterator = DeserializeEnum (16,&n,bIterator); |
2345 uint16_t prioritizedBitRateKbps; | 2345 uint16_t prioritizedBitRateKbps; |
2346 | 2346 |
2347 switch (n) | 2347 switch (n) |
2348 { | 2348 { |
2349 case 0: | 2349 case 0: |
2350 prioritizedBitRateKbps = 0; | 2350 prioritizedBitRateKbps = 0; |
2351 break; | 2351 break; |
(...skipping 48 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2400 break; | 2400 break; |
2401 default: | 2401 default: |
2402 bucketSizeDurationMs = 1000; | 2402 bucketSizeDurationMs = 1000; |
2403 } | 2403 } |
2404 logicalChannelConfig->bucketSizeDurationMs = bucketSizeDurationMs; | 2404 logicalChannelConfig->bucketSizeDurationMs = bucketSizeDurationMs; |
2405 | 2405 |
2406 if (bitset1[0]) | 2406 if (bitset1[0]) |
2407 { | 2407 { |
2408 // Deserialize logicalChannelGroup | 2408 // Deserialize logicalChannelGroup |
2409 bIterator = DeserializeInteger (&n,0,3,bIterator); | 2409 bIterator = DeserializeInteger (&n,0,3,bIterator); |
2410 logicalChannelConfig->logicalChannelGroup = n; | 2410 logicalChannelConfig->logicalChannelGroup = static_cast<uint8_t> (n); |
2411 } | 2411 } |
2412 } | 2412 } |
2413 return bIterator; | 2413 return bIterator; |
2414 } | 2414 } |
2415 | 2415 |
2416 Buffer::Iterator | 2416 Buffer::Iterator |
2417 RrcAsn1Header::DeserializePhysicalConfigDedicated (LteRrcSap::PhysicalConfigDedi
cated *physicalConfigDedicated, Buffer::Iterator bIterator) | 2417 RrcAsn1Header::DeserializePhysicalConfigDedicated (LteRrcSap::PhysicalConfigDedi
cated *physicalConfigDedicated, Buffer::Iterator bIterator) |
2418 { | 2418 { |
2419 std::bitset<10> optionalFieldPresent; | 2419 std::bitset<10> optionalFieldPresent; |
2420 bIterator = DeserializeSequence (&optionalFieldPresent,true,bIterator); | 2420 bIterator = DeserializeSequence (&optionalFieldPresent,true,bIterator); |
2421 | 2421 |
2422 physicalConfigDedicated->havePdschConfigDedicated = optionalFieldPresent[9]; | 2422 physicalConfigDedicated->havePdschConfigDedicated = optionalFieldPresent[9]; |
2423 if (optionalFieldPresent[9]) | 2423 if (optionalFieldPresent[9]) |
2424 { | 2424 { |
2425 // Deserialize pdsch-ConfigDedicated | 2425 // Deserialize pdsch-ConfigDedicated |
2426 std::bitset<0> bitset0; | 2426 std::bitset<0> bitset0; |
2427 bIterator = DeserializeSequence (&bitset0,false,bIterator); | 2427 bIterator = DeserializeSequence (&bitset0,false,bIterator); |
2428 | 2428 |
2429 int slct; | 2429 int slct; |
2430 | 2430 |
2431 // Deserialize p-a | 2431 // Deserialize p-a |
2432 bIterator = DeserializeEnum (8,&slct,bIterator); | 2432 bIterator = DeserializeEnum (8,&slct,bIterator); |
2433 physicalConfigDedicated->pdschConfigDedicated.pa = slct; | 2433 physicalConfigDedicated->pdschConfigDedicated.pa = static_cast<uint8_t> (s
lct); |
2434 | 2434 |
2435 bIterator = DeserializeNull (bIterator); | 2435 bIterator = DeserializeNull (bIterator); |
2436 | 2436 |
2437 } | 2437 } |
2438 if (optionalFieldPresent[8]) | 2438 if (optionalFieldPresent[8]) |
2439 { | 2439 { |
2440 // Deserialize pucch-ConfigDedicated | 2440 // Deserialize pucch-ConfigDedicated |
2441 // ... | 2441 // ... |
2442 } | 2442 } |
2443 if (optionalFieldPresent[7]) | 2443 if (optionalFieldPresent[7]) |
(...skipping 39 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2483 { | 2483 { |
2484 physicalConfigDedicated->soundingRsUlConfigDedicated.type = LteRrcSap:
:SoundingRsUlConfigDedicated::SETUP; | 2484 physicalConfigDedicated->soundingRsUlConfigDedicated.type = LteRrcSap:
:SoundingRsUlConfigDedicated::SETUP; |
2485 | 2485 |
2486 std::bitset<0> bitset0; | 2486 std::bitset<0> bitset0; |
2487 bIterator = DeserializeSequence (&bitset0,false,bIterator); | 2487 bIterator = DeserializeSequence (&bitset0,false,bIterator); |
2488 | 2488 |
2489 int slct; | 2489 int slct; |
2490 | 2490 |
2491 // Deserialize srs-Bandwidth | 2491 // Deserialize srs-Bandwidth |
2492 bIterator = DeserializeEnum (4,&slct,bIterator); | 2492 bIterator = DeserializeEnum (4,&slct,bIterator); |
2493 physicalConfigDedicated->soundingRsUlConfigDedicated.srsBandwidth = sl
ct; | 2493 physicalConfigDedicated->soundingRsUlConfigDedicated.srsBandwidth = st
atic_cast<uint8_t> (slct); |
2494 | 2494 |
2495 // Deserialize srs-HoppingBandwidth | 2495 // Deserialize srs-HoppingBandwidth |
2496 bIterator = DeserializeEnum (4,&slct,bIterator); | 2496 bIterator = DeserializeEnum (4,&slct,bIterator); |
2497 | 2497 |
2498 // Deserialize freqDomainPosition | 2498 // Deserialize freqDomainPosition |
2499 bIterator = DeserializeInteger (&slct,0,23,bIterator); | 2499 bIterator = DeserializeInteger (&slct,0,23,bIterator); |
2500 | 2500 |
2501 // Deserialize duration | 2501 // Deserialize duration |
2502 bool duration; | 2502 bool duration; |
2503 bIterator = DeserializeBoolean (&duration,bIterator); | 2503 bIterator = DeserializeBoolean (&duration,bIterator); |
2504 | 2504 |
2505 // Deserialize srs-ConfigIndex | 2505 // Deserialize srs-ConfigIndex |
2506 bIterator = DeserializeInteger (&slct,0,1023,bIterator); | 2506 bIterator = DeserializeInteger (&slct,0,1023,bIterator); |
2507 physicalConfigDedicated->soundingRsUlConfigDedicated.srsConfigIndex =
slct; | 2507 physicalConfigDedicated->soundingRsUlConfigDedicated.srsConfigIndex =
static_cast<uint16_t> (slct); |
2508 | 2508 |
2509 // Deserialize transmissionComb | 2509 // Deserialize transmissionComb |
2510 bIterator = DeserializeInteger (&slct,0,1,bIterator); | 2510 bIterator = DeserializeInteger (&slct,0,1,bIterator); |
2511 | 2511 |
2512 // Deserialize cyclicShift | 2512 // Deserialize cyclicShift |
2513 bIterator = DeserializeEnum (8,&slct,bIterator); | 2513 bIterator = DeserializeEnum (8,&slct,bIterator); |
2514 } | 2514 } |
2515 } | 2515 } |
2516 physicalConfigDedicated->haveAntennaInfoDedicated = optionalFieldPresent[1]; | 2516 physicalConfigDedicated->haveAntennaInfoDedicated = optionalFieldPresent[1]; |
2517 if (optionalFieldPresent[1]) | 2517 if (optionalFieldPresent[1]) |
2518 { | 2518 { |
2519 // Deserialize antennaInfo | 2519 // Deserialize antennaInfo |
2520 int sel; | 2520 int sel; |
2521 bIterator = DeserializeChoice (2,false,&sel,bIterator); | 2521 bIterator = DeserializeChoice (2,false,&sel,bIterator); |
2522 if (sel == 1) | 2522 if (sel == 1) |
2523 { | 2523 { |
2524 bIterator = DeserializeNull (bIterator); | 2524 bIterator = DeserializeNull (bIterator); |
2525 } | 2525 } |
2526 else if (sel == 0) | 2526 else if (sel == 0) |
2527 { | 2527 { |
2528 std::bitset<1> codebookSubsetRestrictionPresent; | 2528 std::bitset<1> codebookSubsetRestrictionPresent; |
2529 bIterator = DeserializeSequence (&codebookSubsetRestrictionPresent,fal
se,bIterator); | 2529 bIterator = DeserializeSequence (&codebookSubsetRestrictionPresent,fal
se,bIterator); |
2530 | 2530 |
2531 int txmode; | 2531 int txmode; |
2532 bIterator = DeserializeEnum (8,&txmode,bIterator); | 2532 bIterator = DeserializeEnum (8,&txmode,bIterator); |
2533 physicalConfigDedicated->antennaInfo.transmissionMode = txmode; | 2533 physicalConfigDedicated->antennaInfo.transmissionMode = static_cast<ui
nt8_t> (txmode); |
2534 | 2534 |
2535 if (codebookSubsetRestrictionPresent[0]) | 2535 if (codebookSubsetRestrictionPresent[0]) |
2536 { | 2536 { |
2537 // Deserialize codebookSubsetRestriction | 2537 // Deserialize codebookSubsetRestriction |
2538 // ... | 2538 // ... |
2539 } | 2539 } |
2540 | 2540 |
2541 int txantennaselchosen; | 2541 int txantennaselchosen; |
2542 bIterator = DeserializeChoice (2,false,&txantennaselchosen,bIterator); | 2542 bIterator = DeserializeChoice (2,false,&txantennaselchosen,bIterator); |
2543 if (txantennaselchosen == 0) | 2543 if (txantennaselchosen == 0) |
(...skipping 106 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2650 std::bitset<2> radioResourceConfigCommonSCell_r10; | 2650 std::bitset<2> radioResourceConfigCommonSCell_r10; |
2651 bIterator = DeserializeSequence (&radioResourceConfigCommonSCell_r10,false,b
Iterator); | 2651 bIterator = DeserializeSequence (&radioResourceConfigCommonSCell_r10,false,b
Iterator); |
2652 rrccsc->haveNonUlConfiguration = radioResourceConfigCommonSCell_r10[1]; | 2652 rrccsc->haveNonUlConfiguration = radioResourceConfigCommonSCell_r10[1]; |
2653 rrccsc->haveUlConfiguration = radioResourceConfigCommonSCell_r10[0]; | 2653 rrccsc->haveUlConfiguration = radioResourceConfigCommonSCell_r10[0]; |
2654 if (rrccsc->haveNonUlConfiguration) | 2654 if (rrccsc->haveNonUlConfiguration) |
2655 { | 2655 { |
2656 std::bitset<5> nonUlConfiguration_r10; | 2656 std::bitset<5> nonUlConfiguration_r10; |
2657 bIterator = DeserializeSequence (&nonUlConfiguration_r10,false,bIterator
); | 2657 bIterator = DeserializeSequence (&nonUlConfiguration_r10,false,bIterator
); |
2658 int n; | 2658 int n; |
2659 bIterator = DeserializeInteger (&n,6,100,bIterator); | 2659 bIterator = DeserializeInteger (&n,6,100,bIterator); |
2660 rrccsc->nonUlConfiguration.dlBandwidth = n; | 2660 rrccsc->nonUlConfiguration.dlBandwidth = static_cast<uint16_t> (n); |
2661 | 2661 |
2662 std::bitset<1> antennaInfoCommon_r10; | 2662 std::bitset<1> antennaInfoCommon_r10; |
2663 bIterator = DeserializeSequence (&antennaInfoCommon_r10,false,bIterator)
; | 2663 bIterator = DeserializeSequence (&antennaInfoCommon_r10,false,bIterator)
; |
2664 bIterator = DeserializeInteger (&n,0,65536,bIterator); | 2664 bIterator = DeserializeInteger (&n,0,65536,bIterator); |
2665 rrccsc->nonUlConfiguration.antennaInfoCommon.antennaPortsCount = n; | 2665 rrccsc->nonUlConfiguration.antennaInfoCommon.antennaPortsCount = static_
cast<uint16_t> (n); |
2666 | 2666 |
2667 std::bitset<2> pdschConfigCommon_r10; | 2667 std::bitset<2> pdschConfigCommon_r10; |
2668 bIterator = DeserializeSequence (&pdschConfigCommon_r10,false,bIterator)
; | 2668 bIterator = DeserializeSequence (&pdschConfigCommon_r10,false,bIterator)
; |
2669 bIterator = DeserializeInteger (&n,-60,50,bIterator); | 2669 bIterator = DeserializeInteger (&n,-60,50,bIterator); |
2670 rrccsc->nonUlConfiguration.pdschConfigCommon.referenceSignalPower = n; | 2670 rrccsc->nonUlConfiguration.pdschConfigCommon.referenceSignalPower = stat
ic_cast<int8_t>(n); |
2671 bIterator = DeserializeInteger (&n,0,3,bIterator); | 2671 bIterator = DeserializeInteger (&n,0,3,bIterator); |
2672 rrccsc->nonUlConfiguration.pdschConfigCommon.pb = n; | 2672 rrccsc->nonUlConfiguration.pdschConfigCommon.pb = static_cast<int8_t>(n)
; |
2673 } | 2673 } |
2674 if (rrccsc->haveUlConfiguration) | 2674 if (rrccsc->haveUlConfiguration) |
2675 { | 2675 { |
2676 std::bitset<7> UlConfiguration_r10; | 2676 std::bitset<7> UlConfiguration_r10; |
2677 bIterator = DeserializeSequence (&UlConfiguration_r10,true,bIterator); | 2677 bIterator = DeserializeSequence (&UlConfiguration_r10,true,bIterator); |
2678 ········ | 2678 ········ |
2679 std::bitset<3> FreqInfo_r10; | 2679 std::bitset<3> FreqInfo_r10; |
2680 bIterator = DeserializeSequence (&FreqInfo_r10,false,bIterator); | 2680 bIterator = DeserializeSequence (&FreqInfo_r10,false,bIterator); |
2681 int n; | 2681 int n; |
2682 bIterator = DeserializeInteger (&n,0,MAX_EARFCN,bIterator); | 2682 bIterator = DeserializeInteger (&n,0,MAX_EARFCN,bIterator); |
2683 rrccsc->ulConfiguration.ulFreqInfo.ulCarrierFreq = n; | 2683 rrccsc->ulConfiguration.ulFreqInfo.ulCarrierFreq = n; |
2684 bIterator = DeserializeInteger (&n,6,100,bIterator); | 2684 bIterator = DeserializeInteger (&n,6,100,bIterator); |
2685 rrccsc->ulConfiguration.ulFreqInfo.ulBandwidth = n; | 2685 rrccsc->ulConfiguration.ulFreqInfo.ulBandwidth = static_cast<int8_t>(n); |
2686 | 2686 |
2687 std::bitset<2> UlPowerControlCommonSCell_r10; | 2687 std::bitset<2> UlPowerControlCommonSCell_r10; |
2688 bIterator = DeserializeSequence (&UlPowerControlCommonSCell_r10,false,bI
terator); | 2688 bIterator = DeserializeSequence (&UlPowerControlCommonSCell_r10,false,bI
terator); |
2689 bIterator = DeserializeInteger (&n,0,65536,bIterator); | 2689 bIterator = DeserializeInteger (&n,0,65536,bIterator); |
2690 rrccsc->ulConfiguration.ulPowerControlCommonSCell.alpha = n; | 2690 rrccsc->ulConfiguration.ulPowerControlCommonSCell.alpha = static_cast<ui
nt16_t> (n); |
2691 ········· | 2691 ········· |
2692 std::bitset<1> prachConfigSCell_r10; | 2692 std::bitset<1> prachConfigSCell_r10; |
2693 bIterator = DeserializeSequence (&prachConfigSCell_r10,false,bIterator); | 2693 bIterator = DeserializeSequence (&prachConfigSCell_r10,false,bIterator); |
2694 bIterator = DeserializeInteger (&n,0,256,bIterator); | 2694 bIterator = DeserializeInteger (&n,0,256,bIterator); |
2695 rrccsc->ulConfiguration.prachConfigSCell.index = n; | 2695 rrccsc->ulConfiguration.prachConfigSCell.index = static_cast<uint16_t> (
n); |
2696 }···· | 2696 }···· |
2697 ···· | 2697 ···· |
2698 return bIterator; | 2698 return bIterator; |
2699 } | 2699 } |
2700 | 2700 |
2701 Buffer::Iterator· | 2701 Buffer::Iterator· |
2702 RrcAsn1Header::DeserializeRadioResourceConfigDedicatedSCell (LteRrcSap::RadioR
esourceConfigDedicatedSCell *rrcdsc, Buffer::Iterator bIterator) | 2702 RrcAsn1Header::DeserializeRadioResourceConfigDedicatedSCell (LteRrcSap::RadioR
esourceConfigDedicatedSCell *rrcdsc, Buffer::Iterator bIterator) |
2703 { | 2703 { |
2704 NS_LOG_FUNCTION (this); | 2704 NS_LOG_FUNCTION (this); |
2705 std::bitset<1> RadioResourceConfigDedicatedSCell_r10; | 2705 std::bitset<1> RadioResourceConfigDedicatedSCell_r10; |
(...skipping 29 matching lines...) Expand all Loading... |
2735 { | 2735 { |
2736 bIterator = DeserializeNull (bIterator); | 2736 bIterator = DeserializeNull (bIterator); |
2737 } | 2737 } |
2738 else if (sel == 0) | 2738 else if (sel == 0) |
2739 { | 2739 { |
2740 std::bitset<1> codebookSubsetRestrictionPresent; | 2740 std::bitset<1> codebookSubsetRestrictionPresent; |
2741 bIterator = DeserializeSequence (&codebookSubsetRestrictionPres
ent,false,bIterator); | 2741 bIterator = DeserializeSequence (&codebookSubsetRestrictionPres
ent,false,bIterator); |
2742 | 2742 |
2743 int txmode; | 2743 int txmode; |
2744 bIterator = DeserializeEnum (8,&txmode,bIterator); | 2744 bIterator = DeserializeEnum (8,&txmode,bIterator); |
2745 pcdsc->antennaInfo.transmissionMode = txmode; | 2745 pcdsc->antennaInfo.transmissionMode = static_cast<uint8_t> (txm
ode); |
2746 | 2746 |
2747 if (codebookSubsetRestrictionPresent[0]) | 2747 if (codebookSubsetRestrictionPresent[0]) |
2748 { | 2748 { |
2749 // Deserialize codebookSubsetRestriction | 2749 // Deserialize codebookSubsetRestriction |
2750 NS_FATAL_ERROR ("Not implemented yet"); | 2750 NS_FATAL_ERROR ("Not implemented yet"); |
2751 // ... | 2751 // ... |
2752 } | 2752 } |
2753 | 2753 |
2754 int txantennaselchosen; | 2754 int txantennaselchosen; |
2755 bIterator = DeserializeChoice (2,false,&txantennaselchosen,bIte
rator); | 2755 bIterator = DeserializeChoice (2,false,&txantennaselchosen,bIte
rator); |
(...skipping 13 matching lines...) Expand all Loading... |
2769 if (pcdsc->havePdschConfigDedicated) | 2769 if (pcdsc->havePdschConfigDedicated) |
2770 { | 2770 { |
2771 // Deserialize pdsch-ConfigDedicated | 2771 // Deserialize pdsch-ConfigDedicated |
2772 std::bitset<0> bitset0; | 2772 std::bitset<0> bitset0; |
2773 bIterator = DeserializeSequence (&bitset0,false,bIterator); | 2773 bIterator = DeserializeSequence (&bitset0,false,bIterator); |
2774 | 2774 |
2775 int slct; | 2775 int slct; |
2776 | 2776 |
2777 // Deserialize p-a | 2777 // Deserialize p-a |
2778 bIterator = DeserializeEnum (8,&slct,bIterator); | 2778 bIterator = DeserializeEnum (8,&slct,bIterator); |
2779 pcdsc->pdschConfigDedicated.pa = slct; | 2779 pcdsc->pdschConfigDedicated.pa = static_cast<uint8_t> (slct); |
2780 | 2780 |
2781 bIterator = DeserializeNull (bIterator); | 2781 bIterator = DeserializeNull (bIterator); |
2782 } | 2782 } |
2783 ········ | 2783 ········ |
2784 } | 2784 } |
2785 if (pcdsc->haveUlConfiguration) | 2785 if (pcdsc->haveUlConfiguration) |
2786 { | 2786 { |
2787 std::bitset<7> ulOpt; | 2787 std::bitset<7> ulOpt; |
2788 bIterator = DeserializeSequence (&ulOpt,false,bIterator); | 2788 bIterator = DeserializeSequence (&ulOpt,false,bIterator); |
2789 pcdsc->haveAntennaInfoUlDedicated = ulOpt[6]; | 2789 pcdsc->haveAntennaInfoUlDedicated = ulOpt[6]; |
(...skipping 13 matching lines...) Expand all Loading... |
2803 { | 2803 { |
2804 bIterator = DeserializeNull (bIterator); | 2804 bIterator = DeserializeNull (bIterator); |
2805 } | 2805 } |
2806 else if (sel == 0) | 2806 else if (sel == 0) |
2807 { | 2807 { |
2808 std::bitset<1> codebookSubsetRestrictionPresent; | 2808 std::bitset<1> codebookSubsetRestrictionPresent; |
2809 bIterator = DeserializeSequence (&codebookSubsetRestrictionPres
ent,false,bIterator); | 2809 bIterator = DeserializeSequence (&codebookSubsetRestrictionPres
ent,false,bIterator); |
2810 | 2810 |
2811 int txmode; | 2811 int txmode; |
2812 bIterator = DeserializeEnum (8,&txmode,bIterator); | 2812 bIterator = DeserializeEnum (8,&txmode,bIterator); |
2813 pcdsc->antennaInfoUl.transmissionMode = txmode; | 2813 pcdsc->antennaInfo.transmissionMode = static_cast<uint8_t> (txm
ode); |
2814 | 2814 |
2815 if (codebookSubsetRestrictionPresent[0]) | 2815 if (codebookSubsetRestrictionPresent[0]) |
2816 { | 2816 { |
2817 // Deserialize codebookSubsetRestriction | 2817 // Deserialize codebookSubsetRestriction |
2818 NS_FATAL_ERROR ("Not implemented yet"); | 2818 NS_FATAL_ERROR ("Not implemented yet"); |
2819 // ... | 2819 // ... |
2820 } | 2820 } |
2821 | 2821 |
2822 int txantennaselchosen; | 2822 int txantennaselchosen; |
2823 bIterator = DeserializeChoice (2,false,&txantennaselchosen,bIte
rator); | 2823 bIterator = DeserializeChoice (2,false,&txantennaselchosen,bIte
rator); |
(...skipping 27 matching lines...) Expand all Loading... |
2851 { | 2851 { |
2852 pcdsc->soundingRsUlConfigDedicated.type = LteRrcSap::SoundingRs
UlConfigDedicated::SETUP; | 2852 pcdsc->soundingRsUlConfigDedicated.type = LteRrcSap::SoundingRs
UlConfigDedicated::SETUP; |
2853 | 2853 |
2854 std::bitset<0> bitset0; | 2854 std::bitset<0> bitset0; |
2855 bIterator = DeserializeSequence (&bitset0,false,bIterator); | 2855 bIterator = DeserializeSequence (&bitset0,false,bIterator); |
2856 | 2856 |
2857 int slct; | 2857 int slct; |
2858 | 2858 |
2859 // Deserialize srs-Bandwidth | 2859 // Deserialize srs-Bandwidth |
2860 bIterator = DeserializeEnum (4,&slct,bIterator); | 2860 bIterator = DeserializeEnum (4,&slct,bIterator); |
2861 pcdsc->soundingRsUlConfigDedicated.srsBandwidth = slct; | 2861 pcdsc->soundingRsUlConfigDedicated.srsBandwidth = static_cast<u
int8_t> (slct); |
2862 | 2862 |
2863 // Deserialize srs-HoppingBandwidth | 2863 // Deserialize srs-HoppingBandwidth |
2864 bIterator = DeserializeEnum (4,&slct,bIterator); | 2864 bIterator = DeserializeEnum (4,&slct,bIterator); |
2865 | 2865 |
2866 // Deserialize freqDomainPosition | 2866 // Deserialize freqDomainPosition |
2867 bIterator = DeserializeInteger (&slct,0,23,bIterator); | 2867 bIterator = DeserializeInteger (&slct,0,23,bIterator); |
2868 | 2868 |
2869 // Deserialize duration | 2869 // Deserialize duration |
2870 bool duration; | 2870 bool duration; |
2871 bIterator = DeserializeBoolean (&duration,bIterator); | 2871 bIterator = DeserializeBoolean (&duration,bIterator); |
2872 | 2872 |
2873 // Deserialize srs-ConfigIndex | 2873 // Deserialize srs-ConfigIndex |
2874 bIterator = DeserializeInteger (&slct,0,1023,bIterator); | 2874 bIterator = DeserializeInteger (&slct,0,1023,bIterator); |
2875 pcdsc->soundingRsUlConfigDedicated.srsConfigIndex = slct; | 2875 pcdsc->soundingRsUlConfigDedicated.srsConfigIndex = static_cast
<uint16_t> (slct); |
2876 | 2876 |
2877 // Deserialize transmissionComb | 2877 // Deserialize transmissionComb |
2878 bIterator = DeserializeInteger (&slct,0,1,bIterator); | 2878 bIterator = DeserializeInteger (&slct,0,1,bIterator); |
2879 | 2879 |
2880 // Deserialize cyclicShift | 2880 // Deserialize cyclicShift |
2881 bIterator = DeserializeEnum (8,&slct,bIterator); | 2881 bIterator = DeserializeEnum (8,&slct,bIterator); |
2882 } | 2882 } |
2883 } | 2883 } |
2884 | 2884 |
2885 | 2885 |
(...skipping 614 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
3500 RrcAsn1Header::DeserializeMeasResults (LteRrcSap::MeasResults *measResults, Buff
er::Iterator bIterator) | 3500 RrcAsn1Header::DeserializeMeasResults (LteRrcSap::MeasResults *measResults, Buff
er::Iterator bIterator) |
3501 { | 3501 { |
3502 int n; | 3502 int n; |
3503 std::bitset<0> b0; | 3503 std::bitset<0> b0; |
3504 std::bitset<4> measResultOptionalPresent; | 3504 std::bitset<4> measResultOptionalPresent; |
3505 // bIterator = DeserializeSequence (&measResultNeighCellsPresent,true,bIter
ator); | 3505 // bIterator = DeserializeSequence (&measResultNeighCellsPresent,true,bIter
ator); |
3506 bIterator = DeserializeSequence (&measResultOptionalPresent,true,bIterator); | 3506 bIterator = DeserializeSequence (&measResultOptionalPresent,true,bIterator); |
3507 | 3507 |
3508 // Deserialize measId | 3508 // Deserialize measId |
3509 bIterator = DeserializeInteger (&n, 1, MAX_MEAS_ID, bIterator); | 3509 bIterator = DeserializeInteger (&n, 1, MAX_MEAS_ID, bIterator); |
3510 measResults->measId = n; | 3510 measResults->measId = static_cast<uint8_t> (n); |
3511 | 3511 |
3512 // Deserialize measResultServCell | 3512 // Deserialize measResultServCell |
3513 bIterator = DeserializeSequence (&b0,false,bIterator); | 3513 bIterator = DeserializeSequence (&b0,false,bIterator); |
3514 | 3514 |
3515 // Deserialize rsrpResult | 3515 // Deserialize rsrpResult |
3516 bIterator = DeserializeInteger (&n, 0, 97, bIterator); | 3516 bIterator = DeserializeInteger (&n, 0, 97, bIterator); |
3517 measResults->rsrpResult = n; | 3517 measResults->rsrpResult = static_cast<uint8_t> (n); |
3518 | 3518 |
3519 // Deserialize rsrqResult | 3519 // Deserialize rsrqResult |
3520 bIterator = DeserializeInteger (&n, 0, 34, bIterator); | 3520 bIterator = DeserializeInteger (&n, 0, 34, bIterator); |
3521 measResults->rsrqResult = n; | 3521 measResults->rsrqResult = static_cast<uint8_t> (n); |
3522 | 3522 |
3523 measResults->haveMeasResultNeighCells = measResultOptionalPresent[0]; | 3523 measResults->haveMeasResultNeighCells = measResultOptionalPresent[0]; |
3524 measResults->haveScellsMeas = measResultOptionalPresent[3]; | 3524 measResults->haveScellsMeas = measResultOptionalPresent[3]; |
3525 if ( measResults->haveMeasResultNeighCells) | 3525 if ( measResults->haveMeasResultNeighCells) |
3526 { | 3526 { |
3527 int measResultNeighCellsChoice; | 3527 int measResultNeighCellsChoice; |
3528 | 3528 |
3529 // Deserialize measResultNeighCells | 3529 // Deserialize measResultNeighCells |
3530 bIterator = DeserializeChoice (4,false,&measResultNeighCellsChoice,bIterat
or); | 3530 bIterator = DeserializeChoice (4,false,&measResultNeighCellsChoice,bIterat
or); |
3531 | 3531 |
3532 if (measResultNeighCellsChoice == 0) | 3532 if (measResultNeighCellsChoice == 0) |
3533 { | 3533 { |
3534 // Deserialize measResultListEUTRA | 3534 // Deserialize measResultListEUTRA |
3535 int numElems; | 3535 int numElems; |
3536 bIterator = DeserializeSequenceOf (&numElems,MAX_CELL_REPORT,1,bIterat
or); | 3536 bIterator = DeserializeSequenceOf (&numElems,MAX_CELL_REPORT,1,bIterat
or); |
3537 | 3537 |
3538 for (int i = 0; i < numElems; i++) | 3538 for (int i = 0; i < numElems; i++) |
3539 { | 3539 { |
3540 LteRrcSap::MeasResultEutra measResultEutra; | 3540 LteRrcSap::MeasResultEutra measResultEutra; |
3541 | 3541 |
3542 std::bitset<1> isCgiInfoPresent; | 3542 std::bitset<1> isCgiInfoPresent; |
3543 bIterator = DeserializeSequence (&isCgiInfoPresent,false,bIterator
); | 3543 bIterator = DeserializeSequence (&isCgiInfoPresent,false,bIterator
); |
3544 | 3544 |
3545 // PhysCellId | 3545 // PhysCellId |
3546 bIterator = DeserializeInteger (&n,0,503,bIterator); | 3546 bIterator = DeserializeInteger (&n,0,503,bIterator); |
3547 measResultEutra.physCellId = n; | 3547 measResultEutra.physCellId = static_cast<uint16_t> (n); |
3548 | 3548 |
3549 measResultEutra.haveCgiInfo = isCgiInfoPresent[0]; | 3549 measResultEutra.haveCgiInfo = isCgiInfoPresent[0]; |
3550 if (isCgiInfoPresent[0]) | 3550 if (isCgiInfoPresent[0]) |
3551 { | 3551 { |
3552 std::bitset<1> havePlmnIdentityList; | 3552 std::bitset<1> havePlmnIdentityList; |
3553 bIterator = DeserializeSequence (&havePlmnIdentityList,false,b
Iterator); | 3553 bIterator = DeserializeSequence (&havePlmnIdentityList,false,b
Iterator); |
3554 | 3554 |
3555 // Deserialize cellGlobalId | 3555 // Deserialize cellGlobalId |
3556 bIterator = DeserializeSequence (&b0,false,bIterator); | 3556 bIterator = DeserializeSequence (&b0,false,bIterator); |
3557 | 3557 |
3558 // Deserialize plmn-Identity | 3558 // Deserialize plmn-Identity |
3559 bIterator = DeserializePlmnIdentity (&measResultEutra.cgiInfo.
plmnIdentity,bIterator); | 3559 bIterator = DeserializePlmnIdentity (&measResultEutra.cgiInfo.
plmnIdentity,bIterator); |
3560 | 3560 |
3561 // Deserialize CellIdentity | 3561 // Deserialize CellIdentity |
3562 std::bitset<28> cellId; | 3562 std::bitset<28> cellId; |
3563 bIterator = DeserializeBitstring (&cellId,bIterator); | 3563 bIterator = DeserializeBitstring (&cellId,bIterator); |
3564 measResultEutra.cgiInfo.cellIdentity = cellId.to_ulong (); | 3564 measResultEutra.cgiInfo.cellIdentity = cellId.to_ulong (); |
3565 | 3565 |
3566 // Deserialize trackingAreaCode | 3566 // Deserialize trackingAreaCode |
3567 std::bitset<16> trArCo; | 3567 std::bitset<16> trArCo; |
3568 bIterator = DeserializeBitstring (&trArCo,bIterator); | 3568 bIterator = DeserializeBitstring (&trArCo,bIterator); |
3569 measResultEutra.cgiInfo.trackingAreaCode = trArCo.to_ulong (); | 3569 measResultEutra.cgiInfo.trackingAreaCode = static_cast<uint16_
t> (trArCo.to_ulong ()); |
3570 | 3570 |
3571 // Deserialize plmn-IdentityList | 3571 // Deserialize plmn-IdentityList |
3572 if (havePlmnIdentityList[0]) | 3572 if (havePlmnIdentityList[0]) |
3573 { | 3573 { |
3574 int numPlmnElems; | 3574 int numPlmnElems; |
3575 bIterator = DeserializeSequenceOf (&numPlmnElems, 5, 1, bI
terator); | 3575 bIterator = DeserializeSequenceOf (&numPlmnElems, 5, 1, bI
terator); |
3576 | 3576 |
3577 for ( int j = 0; j < numPlmnElems; j++) | 3577 for ( int j = 0; j < numPlmnElems; j++) |
3578 { | 3578 { |
3579 uint32_t plmnId; | 3579 uint32_t plmnId; |
3580 bIterator = DeserializePlmnIdentity (&plmnId,bIterator
); | 3580 bIterator = DeserializePlmnIdentity (&plmnId,bIterator
); |
3581 measResultEutra.cgiInfo.plmnIdentityList.push_back (pl
mnId); | 3581 measResultEutra.cgiInfo.plmnIdentityList.push_back (pl
mnId); |
3582 } | 3582 } |
3583 } | 3583 } |
3584 } | 3584 } |
3585 | 3585 |
3586 // Deserialize measResult | 3586 // Deserialize measResult |
3587 std::bitset<2> measResultOpts; | 3587 std::bitset<2> measResultOpts; |
3588 bIterator = DeserializeSequence (&measResultOpts, true, bIterator)
; | 3588 bIterator = DeserializeSequence (&measResultOpts, true, bIterator)
; |
3589 | 3589 |
3590 measResultEutra.haveRsrpResult = measResultOpts[1]; | 3590 measResultEutra.haveRsrpResult = measResultOpts[1]; |
3591 if (measResultOpts[1]) | 3591 if (measResultOpts[1]) |
3592 { | 3592 { |
3593 // Deserialize rsrpResult | 3593 // Deserialize rsrpResult |
3594 bIterator = DeserializeInteger (&n,0,97,bIterator); | 3594 bIterator = DeserializeInteger (&n,0,97,bIterator); |
3595 measResultEutra.rsrpResult = n; | 3595 measResultEutra.rsrpResult = static_cast<uint8_t> (n); |
3596 } | 3596 } |
3597 | 3597 |
3598 measResultEutra.haveRsrqResult = measResultOpts[0]; | 3598 measResultEutra.haveRsrqResult = measResultOpts[0]; |
3599 if (measResultOpts[0]) | 3599 if (measResultOpts[0]) |
3600 { | 3600 { |
3601 // Deserialize rsrqResult | 3601 // Deserialize rsrqResult |
3602 bIterator = DeserializeInteger (&n,0,34,bIterator); | 3602 bIterator = DeserializeInteger (&n,0,34,bIterator); |
3603 measResultEutra.rsrqResult = n; | 3603 measResultEutra.rsrqResult = static_cast<uint8_t> (n); |
3604 } | 3604 } |
3605 | 3605 |
3606 measResults->measResultListEutra.push_back (measResultEutra); | 3606 measResults->measResultListEutra.push_back (measResultEutra); |
3607 } | 3607 } |
3608 } | 3608 } |
3609 | 3609 |
3610 if (measResultNeighCellsChoice == 1) | 3610 if (measResultNeighCellsChoice == 1) |
3611 { | 3611 { |
3612 // Deserialize measResultListUTRA | 3612 // Deserialize measResultListUTRA |
3613 // ... | 3613 // ... |
(...skipping 14 matching lines...) Expand all Loading... |
3628 { | 3628 { |
3629 | 3629 |
3630 int numElems; | 3630 int numElems; |
3631 bIterator = DeserializeSequenceOf (&numElems,MAX_SCELL_REPORT,1,bIterato
r); | 3631 bIterator = DeserializeSequenceOf (&numElems,MAX_SCELL_REPORT,1,bIterato
r); |
3632 for (int i = 0; i < numElems; i++) | 3632 for (int i = 0; i < numElems; i++) |
3633 { | 3633 { |
3634 LteRrcSap::MeasResultScell measResultScell; | 3634 LteRrcSap::MeasResultScell measResultScell; |
3635 int measScellId; | 3635 int measScellId; |
3636 // Deserialize measId | 3636 // Deserialize measId |
3637 bIterator = DeserializeInteger (&measScellId, 1,MAX_SCELL_REPORT,bIt
erator); | 3637 bIterator = DeserializeInteger (&measScellId, 1,MAX_SCELL_REPORT,bIt
erator); |
3638 measResultScell.servFreqId = measScellId; | 3638 measResultScell.servFreqId = static_cast<uint16_t> (measScellId); |
3639 std::bitset<2> measResultScellPresent; | 3639 std::bitset<2> measResultScellPresent; |
3640 bIterator = DeserializeSequence (&measResultScellPresent,true,bItera
tor); | 3640 bIterator = DeserializeSequence (&measResultScellPresent,true,bItera
tor); |
3641 measResults->measScellResultList.haveMeasurementResultsServingSCells
= measResultScellPresent[0]; | 3641 measResults->measScellResultList.haveMeasurementResultsServingSCells
= measResultScellPresent[0]; |
3642 measResults->measScellResultList.haveMeasurementResultsNeighCell = me
asResultScellPresent[1]; | 3642 measResults->measScellResultList.haveMeasurementResultsNeighCell = me
asResultScellPresent[1]; |
3643 if (measResults->measScellResultList.haveMeasurementResultsServingSCe
lls) | 3643 if (measResults->measScellResultList.haveMeasurementResultsServingSCe
lls) |
3644 { | 3644 { |
3645 // Deserialize measResult | 3645 // Deserialize measResult |
3646 std::bitset<2> measResultOpts; | 3646 std::bitset<2> measResultOpts; |
3647 bIterator = DeserializeSequence (&measResultOpts, true, bIterator
); | 3647 bIterator = DeserializeSequence (&measResultOpts, true, bIterator
); |
3648 | 3648 |
3649 measResultScell.haveRsrpResult = measResultOpts[1]; | 3649 measResultScell.haveRsrpResult = measResultOpts[1]; |
3650 if (measResultOpts[1]) | 3650 if (measResultOpts[1]) |
3651 { | 3651 { |
3652 // Deserialize rsrpResult | 3652 // Deserialize rsrpResult |
3653 bIterator = DeserializeInteger (&n,0,97,bIterator); | 3653 bIterator = DeserializeInteger (&n,0,97,bIterator); |
3654 measResultScell.rsrpResult = n; | 3654 measResultScell.rsrpResult = static_cast<uint8_t> (n); |
3655 } | 3655 } |
3656 | 3656 |
3657 measResultScell.haveRsrqResult = measResultOpts[0]; | 3657 measResultScell.haveRsrqResult = measResultOpts[0]; |
3658 if (measResultOpts[0]) | 3658 if (measResultOpts[0]) |
3659 { | 3659 { |
3660 // Deserialize rsrqResult | 3660 // Deserialize rsrqResult |
3661 bIterator = DeserializeInteger (&n,0,34,bIterator); | 3661 bIterator = DeserializeInteger (&n,0,34,bIterator); |
3662 measResultScell.rsrqResult = n; | 3662 measResultScell.rsrqResult = static_cast<uint8_t> (n); |
3663 } | 3663 } |
3664 } | 3664 } |
3665 if (measResults->measScellResultList.haveMeasurementResultsNeighCell) | 3665 if (measResults->measScellResultList.haveMeasurementResultsNeighCell) |
3666 { | 3666 { |
3667 // Deserialize measResultBestNeighCell | 3667 // Deserialize measResultBestNeighCell |
3668 } | 3668 } |
3669 measResults->measScellResultList.measResultScell.push_back (measResul
tScell); | 3669 measResults->measScellResultList.measResultScell.push_back (measResul
tScell); |
3670 } | 3670 } |
3671 ········ | 3671 ········ |
3672 } | 3672 } |
(...skipping 14 matching lines...) Expand all Loading... |
3687 } | 3687 } |
3688 | 3688 |
3689 // Deserialize mnc | 3689 // Deserialize mnc |
3690 int mncDigits; | 3690 int mncDigits; |
3691 int mnc = 0; | 3691 int mnc = 0; |
3692 bIterator = DeserializeSequenceOf (&mncDigits,3,2,bIterator); | 3692 bIterator = DeserializeSequenceOf (&mncDigits,3,2,bIterator); |
3693 | 3693 |
3694 for (int j = mncDigits - 1; j >= 0; j--) | 3694 for (int j = mncDigits - 1; j >= 0; j--) |
3695 { | 3695 { |
3696 bIterator = DeserializeInteger (&n,0,9,bIterator); | 3696 bIterator = DeserializeInteger (&n,0,9,bIterator); |
3697 mnc += n * pow (10,j); | 3697 mnc += static_cast<int> (n * pow (10,j)); |
3698 } | 3698 } |
3699 | 3699 |
3700 *plmnId = mnc; | 3700 *plmnId = mnc; |
3701 | 3701 |
3702 // cellReservedForOperatorUse | 3702 // cellReservedForOperatorUse |
3703 bIterator = DeserializeEnum (2,&n,bIterator); | 3703 bIterator = DeserializeEnum (2,&n,bIterator); |
3704 return bIterator; | 3704 return bIterator; |
3705 } | 3705 } |
3706 | 3706 |
3707 Buffer::Iterator | 3707 Buffer::Iterator |
3708 RrcAsn1Header::DeserializeMeasConfig (LteRrcSap::MeasConfig * measConfig, Buffer
::Iterator bIterator) | 3708 RrcAsn1Header::DeserializeMeasConfig (LteRrcSap::MeasConfig * measConfig, Buffer
::Iterator bIterator) |
3709 { | 3709 { |
3710 std::bitset<0> bitset0; | 3710 std::bitset<0> bitset0; |
3711 std::bitset<2> bitset2; | 3711 std::bitset<2> bitset2; |
3712 std::bitset<11> bitset11; | 3712 std::bitset<11> bitset11; |
3713 int n; | 3713 int n; |
3714 | 3714 |
3715 // measConfig | 3715 // measConfig |
3716 bIterator = DeserializeSequence (&bitset11,true,bIterator); | 3716 bIterator = DeserializeSequence (&bitset11,true,bIterator); |
3717 | 3717 |
3718 if (bitset11[10]) | 3718 if (bitset11[10]) |
3719 { | 3719 { |
3720 // measObjectToRemoveList | 3720 // measObjectToRemoveList |
3721 int measObjectToRemoveListElems; | 3721 int measObjectToRemoveListElems; |
3722 bIterator = DeserializeSequenceOf (&measObjectToRemoveListElems, MAX_OBJEC
T_ID, 1, bIterator); | 3722 bIterator = DeserializeSequenceOf (&measObjectToRemoveListElems, MAX_OBJEC
T_ID, 1, bIterator); |
3723 | 3723 |
3724 for (int i = 0; i < measObjectToRemoveListElems; i++) | 3724 for (int i = 0; i < measObjectToRemoveListElems; i++) |
3725 { | 3725 { |
3726 bIterator = DeserializeInteger (&n, 1, MAX_OBJECT_ID, bIterator); | 3726 bIterator = DeserializeInteger (&n, 1, MAX_OBJECT_ID, bIterator); |
3727 measConfig->measObjectToRemoveList.push_back (n); | 3727 measConfig->measObjectToRemoveList.push_back (static_cast<uint8_t> (n)
); |
3728 } | 3728 } |
3729 } | 3729 } |
3730 | 3730 |
3731 if (bitset11[9]) | 3731 if (bitset11[9]) |
3732 { | 3732 { |
3733 // measObjectToAddModList | 3733 // measObjectToAddModList |
3734 int measObjectToAddModListElems; | 3734 int measObjectToAddModListElems; |
3735 bIterator = DeserializeSequenceOf (&measObjectToAddModListElems, MAX_OBJEC
T_ID, 1, bIterator); | 3735 bIterator = DeserializeSequenceOf (&measObjectToAddModListElems, MAX_OBJEC
T_ID, 1, bIterator); |
3736 | 3736 |
3737 for (int i = 0; i < measObjectToAddModListElems; i++) | 3737 for (int i = 0; i < measObjectToAddModListElems; i++) |
3738 { | 3738 { |
3739 LteRrcSap::MeasObjectToAddMod elem; | 3739 LteRrcSap::MeasObjectToAddMod elem; |
3740 | 3740 |
3741 bIterator = DeserializeSequence (&bitset0, false, bIterator); | 3741 bIterator = DeserializeSequence (&bitset0, false, bIterator); |
3742 | 3742 |
3743 bIterator = DeserializeInteger (&n, 1, MAX_OBJECT_ID, bIterator); | 3743 bIterator = DeserializeInteger (&n, 1, MAX_OBJECT_ID, bIterator); |
3744 elem.measObjectId = n; | 3744 elem.measObjectId = static_cast<uint8_t> (n); |
3745 | 3745 |
3746 int measObjectChoice; | 3746 int measObjectChoice; |
3747 bIterator = DeserializeChoice (4, true, &measObjectChoice, bIterator); | 3747 bIterator = DeserializeChoice (4, true, &measObjectChoice, bIterator); |
3748 | 3748 |
3749 switch (measObjectChoice) | 3749 switch (measObjectChoice) |
3750 { | 3750 { |
3751 case 1: | 3751 case 1: |
3752 // Deserialize measObjectUTRA | 3752 // Deserialize measObjectUTRA |
3753 // ... | 3753 // ... |
3754 break; | 3754 break; |
(...skipping 20 matching lines...) Expand all Loading... |
3775 | 3775 |
3776 // allowedMeasBandwidth | 3776 // allowedMeasBandwidth |
3777 bIterator = DeserializeEnum (6, &n, bIterator); | 3777 bIterator = DeserializeEnum (6, &n, bIterator); |
3778 elem.measObjectEutra.allowedMeasBandwidth = EnumToBandwidth (n); | 3778 elem.measObjectEutra.allowedMeasBandwidth = EnumToBandwidth (n); |
3779 | 3779 |
3780 // presenceAntennaPort1 | 3780 // presenceAntennaPort1 |
3781 bIterator = DeserializeBoolean (&elem.measObjectEutra.presenceAnte
nnaPort1, bIterator); | 3781 bIterator = DeserializeBoolean (&elem.measObjectEutra.presenceAnte
nnaPort1, bIterator); |
3782 | 3782 |
3783 // neighCellConfig | 3783 // neighCellConfig |
3784 bIterator = DeserializeBitstring (&bitset2, bIterator); | 3784 bIterator = DeserializeBitstring (&bitset2, bIterator); |
3785 elem.measObjectEutra.neighCellConfig = bitset2.to_ulong (); | 3785 elem.measObjectEutra.neighCellConfig = static_cast<uint8_t> (bitse
t2.to_ulong ()); |
3786 | 3786 |
3787 // offsetFreq | 3787 // offsetFreq |
3788 bIterator = DeserializeQoffsetRange (&elem.measObjectEutra.offsetF
req, bIterator); | 3788 bIterator = DeserializeQoffsetRange (&elem.measObjectEutra.offsetF
req, bIterator); |
3789 | 3789 |
3790 if (measObjectEutraOpts[4]) | 3790 if (measObjectEutraOpts[4]) |
3791 { | 3791 { |
3792 // cellsToRemoveList | 3792 // cellsToRemoveList |
3793 int numElems; | 3793 int numElems; |
3794 bIterator = DeserializeSequenceOf (&numElems, MAX_CELL_MEAS, 1
, bIterator); | 3794 bIterator = DeserializeSequenceOf (&numElems, MAX_CELL_MEAS, 1
, bIterator); |
3795 | 3795 |
3796 for (int i = 0; i < numElems; i++) | 3796 for (int j = 0; j < numElems; j++) |
3797 { | 3797 { |
3798 bIterator = DeserializeInteger (&n, 1, MAX_CELL_MEAS, bIte
rator); | 3798 bIterator = DeserializeInteger (&n, 1, MAX_CELL_MEAS, bIte
rator); |
3799 elem.measObjectEutra.cellsToRemoveList.push_back (n); | 3799 elem.measObjectEutra.cellsToRemoveList.push_back (static_c
ast<uint8_t> (n)); |
3800 } | 3800 } |
3801 } | 3801 } |
3802 | 3802 |
3803 if (measObjectEutraOpts[3]) | 3803 if (measObjectEutraOpts[3]) |
3804 { | 3804 { |
3805 // cellsToAddModList | 3805 // cellsToAddModList |
3806 int numElems; | 3806 int numElems; |
3807 bIterator = DeserializeSequenceOf (&numElems, MAX_CELL_MEAS, 1
, bIterator); | 3807 bIterator = DeserializeSequenceOf (&numElems, MAX_CELL_MEAS, 1
, bIterator); |
3808 | 3808 |
3809 for (int i = 0; i < numElems; i++) | 3809 for (int j = 0; j < numElems; j++) |
3810 { | 3810 { |
3811 LteRrcSap::CellsToAddMod cellsToAddMod; | 3811 LteRrcSap::CellsToAddMod cellsToAddMod; |
3812 | 3812 |
3813 bIterator = DeserializeSequence (&bitset0, false, bIterato
r); | 3813 bIterator = DeserializeSequence (&bitset0, false, bIterato
r); |
3814 | 3814 |
3815 // cellIndex | 3815 // cellIndex |
3816 bIterator = DeserializeInteger (&n, 1, MAX_CELL_MEAS, bIte
rator); | 3816 bIterator = DeserializeInteger (&n, 1, MAX_CELL_MEAS, bIte
rator); |
3817 cellsToAddMod.cellIndex = n; | 3817 cellsToAddMod.cellIndex = static_cast<uint8_t> (n); |
3818 | 3818 |
3819 // PhysCellId | 3819 // PhysCellId |
3820 bIterator = DeserializeInteger (&n, 0, 503, bIterator); | 3820 bIterator = DeserializeInteger (&n, 0, 503, bIterator); |
3821 cellsToAddMod.physCellId = n; | 3821 cellsToAddMod.physCellId = static_cast<uint16_t> (n); |
3822 | 3822 |
3823 // cellIndividualOffset | 3823 // cellIndividualOffset |
3824 bIterator = DeserializeQoffsetRange ( &cellsToAddMod.cellI
ndividualOffset, bIterator); | 3824 bIterator = DeserializeQoffsetRange ( &cellsToAddMod.cellI
ndividualOffset, bIterator); |
3825 | 3825 |
3826 elem.measObjectEutra.cellsToAddModList.push_back (cellsToA
ddMod); | 3826 elem.measObjectEutra.cellsToAddModList.push_back (cellsToA
ddMod); |
3827 } | 3827 } |
3828 } | 3828 } |
3829 | 3829 |
3830 if (measObjectEutraOpts[2]) | 3830 if (measObjectEutraOpts[2]) |
3831 { | 3831 { |
3832 // blackCellsToRemoveList | 3832 // blackCellsToRemoveList |
3833 int numElems; | 3833 int numElems; |
3834 bIterator = DeserializeSequenceOf (&numElems, MAX_CELL_MEAS, 1
, bIterator); | 3834 bIterator = DeserializeSequenceOf (&numElems, MAX_CELL_MEAS, 1
, bIterator); |
3835 | 3835 |
3836 for (int i = 0; i < numElems; i++) | 3836 for (int j = 0; j < numElems; j++) |
3837 { | 3837 { |
3838 bIterator = DeserializeInteger (&n, 1, MAX_CELL_MEAS, bIte
rator); | 3838 bIterator = DeserializeInteger (&n, 1, MAX_CELL_MEAS, bIte
rator); |
3839 elem.measObjectEutra.blackCellsToRemoveList.push_back (n); | 3839 elem.measObjectEutra.blackCellsToRemoveList.push_back (sta
tic_cast<uint8_t> (n)); |
3840 } | 3840 } |
3841 } | 3841 } |
3842 | 3842 |
3843 | 3843 |
3844 if (measObjectEutraOpts[1]) | 3844 if (measObjectEutraOpts[1]) |
3845 { | 3845 { |
3846 // blackCellsToAddModList | 3846 // blackCellsToAddModList |
3847 int numElems; | 3847 int numElems; |
3848 bIterator = DeserializeSequenceOf (&numElems, MAX_CELL_MEAS, 1
, bIterator); | 3848 bIterator = DeserializeSequenceOf (&numElems, MAX_CELL_MEAS, 1
, bIterator); |
3849 | 3849 |
3850 for (int i = 0; i < numElems; i++) | 3850 for (int j = 0; j < numElems; j++) |
3851 { | 3851 { |
3852 LteRrcSap::BlackCellsToAddMod blackCellsToAddMod; | 3852 LteRrcSap::BlackCellsToAddMod blackCellsToAddMod; |
3853 bIterator = DeserializeSequence (&bitset0, false, bIterato
r); | 3853 bIterator = DeserializeSequence (&bitset0, false, bIterato
r); |
3854 | 3854 |
3855 bIterator = DeserializeInteger (&n, 1, MAX_CELL_MEAS, bIte
rator); | 3855 bIterator = DeserializeInteger (&n, 1, MAX_CELL_MEAS, bIte
rator); |
3856 blackCellsToAddMod.cellIndex = n; | 3856 blackCellsToAddMod.cellIndex = static_cast<uint8_t> (n); |
3857 | 3857 |
3858 // PhysCellIdRange | 3858 // PhysCellIdRange |
3859 std::bitset<1> isRangePresent; | 3859 std::bitset<1> isRangePresent; |
3860 bIterator = DeserializeSequence (&isRangePresent, false, b
Iterator); | 3860 bIterator = DeserializeSequence (&isRangePresent, false, b
Iterator); |
3861 | 3861 |
3862 // start | 3862 // start |
3863 bIterator = DeserializeInteger (&n, 0, 503, bIterator); | 3863 bIterator = DeserializeInteger (&n, 0, 503, bIterator); |
3864 blackCellsToAddMod.physCellIdRange.start = n; | 3864 blackCellsToAddMod.physCellIdRange.start = static_cast<uin
t16_t> (n); |
3865 | 3865 |
3866 blackCellsToAddMod.physCellIdRange.haveRange = isRangePres
ent[0]; | 3866 blackCellsToAddMod.physCellIdRange.haveRange = isRangePres
ent[0]; |
3867 // initialize range to silence compiler warning | 3867 // initialize range to silence compiler warning |
3868 blackCellsToAddMod.physCellIdRange.range = 0; | 3868 blackCellsToAddMod.physCellIdRange.range = 0; |
3869 if (blackCellsToAddMod.physCellIdRange.haveRange) | 3869 if (blackCellsToAddMod.physCellIdRange.haveRange) |
3870 { | 3870 { |
3871 // range | 3871 // range |
3872 bIterator = DeserializeEnum (16, &n, bIterator); | 3872 bIterator = DeserializeEnum (16, &n, bIterator); |
3873 switch (n) | 3873 switch (n) |
3874 { | 3874 { |
(...skipping 46 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
3921 | 3921 |
3922 elem.measObjectEutra.blackCellsToAddModList.push_back (bla
ckCellsToAddMod); | 3922 elem.measObjectEutra.blackCellsToAddModList.push_back (bla
ckCellsToAddMod); |
3923 } | 3923 } |
3924 } | 3924 } |
3925 | 3925 |
3926 elem.measObjectEutra.haveCellForWhichToReportCGI = measObjectEutra
Opts[0]; | 3926 elem.measObjectEutra.haveCellForWhichToReportCGI = measObjectEutra
Opts[0]; |
3927 if (measObjectEutraOpts[0]) | 3927 if (measObjectEutraOpts[0]) |
3928 { | 3928 { |
3929 // cellForWhichToReportCGI | 3929 // cellForWhichToReportCGI |
3930 bIterator = DeserializeInteger (&n, 0, 503, bIterator); | 3930 bIterator = DeserializeInteger (&n, 0, 503, bIterator); |
3931 elem.measObjectEutra.cellForWhichToReportCGI = n; | 3931 elem.measObjectEutra.cellForWhichToReportCGI = static_cast<uin
t16_t> (n); |
3932 } | 3932 } |
3933 } | 3933 } |
3934 measConfig->measObjectToAddModList.push_back (elem); | 3934 measConfig->measObjectToAddModList.push_back (elem); |
3935 } | 3935 } |
3936 } | 3936 } |
3937 | 3937 |
3938 if (bitset11[8]) | 3938 if (bitset11[8]) |
3939 { | 3939 { |
3940 // reportConfigToRemoveList | 3940 // reportConfigToRemoveList |
3941 int reportConfigToRemoveListElems; | 3941 int reportConfigToRemoveListElems; |
3942 bIterator = DeserializeSequenceOf (&reportConfigToRemoveListElems, MAX_REP
ORT_CONFIG_ID, 1, bIterator); | 3942 bIterator = DeserializeSequenceOf (&reportConfigToRemoveListElems, MAX_REP
ORT_CONFIG_ID, 1, bIterator); |
3943 | 3943 |
3944 for (int i = 0; i < reportConfigToRemoveListElems; i++) | 3944 for (int i = 0; i < reportConfigToRemoveListElems; i++) |
3945 { | 3945 { |
3946 bIterator = DeserializeInteger (&n, 1, MAX_REPORT_CONFIG_ID, bIterator
); | 3946 bIterator = DeserializeInteger (&n, 1, MAX_REPORT_CONFIG_ID, bIterator
); |
3947 measConfig->reportConfigToRemoveList.push_back (n); | 3947 measConfig->reportConfigToRemoveList.push_back (static_cast<uint8_t> (
n)); |
3948 } | 3948 } |
3949 } | 3949 } |
3950 | 3950 |
3951 if (bitset11[7]) | 3951 if (bitset11[7]) |
3952 { | 3952 { |
3953 // reportConfigToAddModList | 3953 // reportConfigToAddModList |
3954 int reportConfigToAddModListElems; | 3954 int reportConfigToAddModListElems; |
3955 bIterator = DeserializeSequenceOf (&reportConfigToAddModListElems, MAX_REP
ORT_CONFIG_ID, 1, bIterator); | 3955 bIterator = DeserializeSequenceOf (&reportConfigToAddModListElems, MAX_REP
ORT_CONFIG_ID, 1, bIterator); |
3956 | 3956 |
3957 for (int i = 0; i < reportConfigToAddModListElems; i++) | 3957 for (int i = 0; i < reportConfigToAddModListElems; i++) |
3958 { | 3958 { |
3959 LteRrcSap::ReportConfigToAddMod elem; | 3959 LteRrcSap::ReportConfigToAddMod elem; |
3960 | 3960 |
3961 bIterator = DeserializeSequence (&bitset0, false, bIterator); | 3961 bIterator = DeserializeSequence (&bitset0, false, bIterator); |
3962 bIterator = DeserializeInteger (&n, 1, MAX_REPORT_CONFIG_ID, bIterator
); | 3962 bIterator = DeserializeInteger (&n, 1, MAX_REPORT_CONFIG_ID, bIterator
); |
3963 elem.reportConfigId = n; | 3963 elem.reportConfigId = static_cast<uint8_t> (n); |
3964 | 3964 |
3965 // Deserialize reportConfig | 3965 // Deserialize reportConfig |
3966 int reportConfigChoice; | 3966 int reportConfigChoice; |
3967 bIterator = DeserializeChoice (2, false, &reportConfigChoice, bIterato
r); | 3967 bIterator = DeserializeChoice (2, false, &reportConfigChoice, bIterato
r); |
3968 | 3968 |
3969 if (reportConfigChoice == 0) | 3969 if (reportConfigChoice == 0) |
3970 { | 3970 { |
3971 // reportConfigEUTRA | 3971 // reportConfigEUTRA |
3972 bIterator = DeserializeSequence (&bitset0, true, bIterator); | 3972 bIterator = DeserializeSequence (&bitset0, true, bIterator); |
3973 | 3973 |
(...skipping 22 matching lines...) Expand all Loading... |
3996 case 1: | 3996 case 1: |
3997 elem.reportConfigEutra.eventId = LteRrcSap::ReportConfigEu
tra::EVENT_A2; | 3997 elem.reportConfigEutra.eventId = LteRrcSap::ReportConfigEu
tra::EVENT_A2; |
3998 bIterator = DeserializeSequence (&bitset0, false, bIterato
r); | 3998 bIterator = DeserializeSequence (&bitset0, false, bIterato
r); |
3999 bIterator = DeserializeThresholdEutra (&elem.reportConfigE
utra.threshold1, bIterator); | 3999 bIterator = DeserializeThresholdEutra (&elem.reportConfigE
utra.threshold1, bIterator); |
4000 break; | 4000 break; |
4001 | 4001 |
4002 case 2: | 4002 case 2: |
4003 elem.reportConfigEutra.eventId = LteRrcSap::ReportConfigEu
tra::EVENT_A3; | 4003 elem.reportConfigEutra.eventId = LteRrcSap::ReportConfigEu
tra::EVENT_A3; |
4004 bIterator = DeserializeSequence (&bitset0, false, bIterato
r); | 4004 bIterator = DeserializeSequence (&bitset0, false, bIterato
r); |
4005 bIterator = DeserializeInteger (&n, -30, 30, bIterator); | 4005 bIterator = DeserializeInteger (&n, -30, 30, bIterator); |
4006 elem.reportConfigEutra.a3Offset = n; | 4006 elem.reportConfigEutra.a3Offset = static_cast<int8_t>(n); |
4007 bIterator = DeserializeBoolean (&elem.reportConfigEutra.re
portOnLeave, bIterator); | 4007 bIterator = DeserializeBoolean (&elem.reportConfigEutra.re
portOnLeave, bIterator); |
4008 break; | 4008 break; |
4009 | 4009 |
4010 case 3: | 4010 case 3: |
4011 elem.reportConfigEutra.eventId = LteRrcSap::ReportConfigEu
tra::EVENT_A4; | 4011 elem.reportConfigEutra.eventId = LteRrcSap::ReportConfigEu
tra::EVENT_A4; |
4012 bIterator = DeserializeSequence (&bitset0, false, bIterato
r); | 4012 bIterator = DeserializeSequence (&bitset0, false, bIterato
r); |
4013 bIterator = DeserializeThresholdEutra (&elem.reportConfigE
utra.threshold1, bIterator); | 4013 bIterator = DeserializeThresholdEutra (&elem.reportConfigE
utra.threshold1, bIterator); |
4014 break; | 4014 break; |
4015 | 4015 |
4016 case 4: | 4016 case 4: |
4017 default: | 4017 default: |
4018 elem.reportConfigEutra.eventId = LteRrcSap::ReportConfigEu
tra::EVENT_A5; | 4018 elem.reportConfigEutra.eventId = LteRrcSap::ReportConfigEu
tra::EVENT_A5; |
4019 bIterator = DeserializeSequence (&bitset0, false, bIterato
r); | 4019 bIterator = DeserializeSequence (&bitset0, false, bIterato
r); |
4020 bIterator = DeserializeThresholdEutra (&elem.reportConfigE
utra.threshold1, bIterator); | 4020 bIterator = DeserializeThresholdEutra (&elem.reportConfigE
utra.threshold1, bIterator); |
4021 bIterator = DeserializeThresholdEutra (&elem.reportConfigE
utra.threshold2, bIterator); | 4021 bIterator = DeserializeThresholdEutra (&elem.reportConfigE
utra.threshold2, bIterator); |
4022 } | 4022 } |
4023 | 4023 |
4024 bIterator = DeserializeInteger (&n, 0, 30, bIterator); | 4024 bIterator = DeserializeInteger (&n, 0, 30, bIterator); |
4025 elem.reportConfigEutra.hysteresis = n; | 4025 elem.reportConfigEutra.hysteresis = static_cast<uint8_t> (n); |
4026 | 4026 |
4027 bIterator = DeserializeEnum (16, &n, bIterator); | 4027 bIterator = DeserializeEnum (16, &n, bIterator); |
4028 switch (n) | 4028 switch (n) |
4029 { | 4029 { |
4030 case 0: | 4030 case 0: |
4031 elem.reportConfigEutra.timeToTrigger = 0; | 4031 elem.reportConfigEutra.timeToTrigger = 0; |
4032 break; | 4032 break; |
4033 case 1: | 4033 case 1: |
4034 elem.reportConfigEutra.timeToTrigger = 40; | 4034 elem.reportConfigEutra.timeToTrigger = 40; |
4035 break; | 4035 break; |
(...skipping 77 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
4113 { | 4113 { |
4114 elem.reportConfigEutra.reportQuantity = LteRrcSap::ReportConfi
gEutra::SAME_AS_TRIGGER_QUANTITY; | 4114 elem.reportConfigEutra.reportQuantity = LteRrcSap::ReportConfi
gEutra::SAME_AS_TRIGGER_QUANTITY; |
4115 } | 4115 } |
4116 else | 4116 else |
4117 { | 4117 { |
4118 elem.reportConfigEutra.reportQuantity = LteRrcSap::ReportConfi
gEutra::BOTH; | 4118 elem.reportConfigEutra.reportQuantity = LteRrcSap::ReportConfi
gEutra::BOTH; |
4119 } | 4119 } |
4120 | 4120 |
4121 // maxReportCells | 4121 // maxReportCells |
4122 bIterator = DeserializeInteger (&n, 1, MAX_CELL_REPORT, bIterator)
; | 4122 bIterator = DeserializeInteger (&n, 1, MAX_CELL_REPORT, bIterator)
; |
4123 elem.reportConfigEutra.maxReportCells = n; | 4123 elem.reportConfigEutra.maxReportCells = static_cast<int8_t>(n); |
4124 | 4124 |
4125 // reportInterval | 4125 // reportInterval |
4126 bIterator = DeserializeEnum (16, &n, bIterator); | 4126 bIterator = DeserializeEnum (16, &n, bIterator); |
4127 switch (n) | 4127 switch (n) |
4128 { | 4128 { |
4129 case 0: | 4129 case 0: |
4130 elem.reportConfigEutra.reportInterval = LteRrcSap::ReportConfi
gEutra::MS120; | 4130 elem.reportConfigEutra.reportInterval = LteRrcSap::ReportConfi
gEutra::MS120; |
4131 break; | 4131 break; |
4132 case 1: | 4132 case 1: |
4133 elem.reportConfigEutra.reportInterval = LteRrcSap::ReportConfi
gEutra::MS240; | 4133 elem.reportConfigEutra.reportInterval = LteRrcSap::ReportConfi
gEutra::MS240; |
(...skipping 84 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
4218 | 4218 |
4219 if (bitset11[6]) | 4219 if (bitset11[6]) |
4220 { | 4220 { |
4221 // measIdToRemoveList | 4221 // measIdToRemoveList |
4222 int measIdToRemoveListElems; | 4222 int measIdToRemoveListElems; |
4223 bIterator = DeserializeSequenceOf (&measIdToRemoveListElems, MAX_MEAS_ID,
1, bIterator); | 4223 bIterator = DeserializeSequenceOf (&measIdToRemoveListElems, MAX_MEAS_ID,
1, bIterator); |
4224 | 4224 |
4225 for (int i = 0; i < measIdToRemoveListElems; i++) | 4225 for (int i = 0; i < measIdToRemoveListElems; i++) |
4226 { | 4226 { |
4227 bIterator = DeserializeInteger (&n, 1, MAX_MEAS_ID, bIterator); | 4227 bIterator = DeserializeInteger (&n, 1, MAX_MEAS_ID, bIterator); |
4228 measConfig->measIdToRemoveList.push_back (n); | 4228 measConfig->measIdToRemoveList.push_back (static_cast<uint8_t> (n)); |
4229 } | 4229 } |
4230 } | 4230 } |
4231 | 4231 |
4232 if (bitset11[5]) | 4232 if (bitset11[5]) |
4233 { | 4233 { |
4234 // measIdToAddModList | 4234 // measIdToAddModList |
4235 int measIdToAddModListElems; | 4235 int measIdToAddModListElems; |
4236 bIterator = DeserializeSequenceOf (&measIdToAddModListElems, MAX_MEAS_ID,
1, bIterator); | 4236 bIterator = DeserializeSequenceOf (&measIdToAddModListElems, MAX_MEAS_ID,
1, bIterator); |
4237 | 4237 |
4238 for (int i = 0; i < measIdToAddModListElems; i++) | 4238 for (int i = 0; i < measIdToAddModListElems; i++) |
4239 { | 4239 { |
4240 LteRrcSap::MeasIdToAddMod elem; | 4240 LteRrcSap::MeasIdToAddMod elem; |
4241 | 4241 |
4242 bIterator = DeserializeSequence (&bitset0, false, bIterator); | 4242 bIterator = DeserializeSequence (&bitset0, false, bIterator); |
4243 | 4243 |
4244 bIterator = DeserializeInteger (&n, 1, MAX_MEAS_ID, bIterator); | 4244 bIterator = DeserializeInteger (&n, 1, MAX_MEAS_ID, bIterator); |
4245 elem.measId = n; | 4245 elem.measId = static_cast<uint8_t> (n); |
4246 | 4246 |
4247 bIterator = DeserializeInteger (&n, 1, MAX_OBJECT_ID, bIterator); | 4247 bIterator = DeserializeInteger (&n, 1, MAX_OBJECT_ID, bIterator); |
4248 elem.measObjectId = n; | 4248 elem.measObjectId = static_cast<uint8_t> (n); |
4249 | 4249 |
4250 bIterator = DeserializeInteger (&n, 1, MAX_REPORT_CONFIG_ID, bIterator
); | 4250 bIterator = DeserializeInteger (&n, 1, MAX_REPORT_CONFIG_ID, bIterator
); |
4251 elem.reportConfigId = n; | 4251 elem.reportConfigId = static_cast<uint8_t> (n); |
4252 | 4252 |
4253 measConfig->measIdToAddModList.push_back (elem); | 4253 measConfig->measIdToAddModList.push_back (elem); |
4254 } | 4254 } |
4255 } | 4255 } |
4256 | 4256 |
4257 measConfig->haveQuantityConfig = bitset11[4]; | 4257 measConfig->haveQuantityConfig = bitset11[4]; |
4258 if (measConfig->haveQuantityConfig) | 4258 if (measConfig->haveQuantityConfig) |
4259 { | 4259 { |
4260 // quantityConfig | 4260 // quantityConfig |
4261 std::bitset<4> quantityConfigOpts; | 4261 std::bitset<4> quantityConfigOpts; |
(...skipping 146 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
4408 measConfig->measGapConfig.type = LteRrcSap::MeasGapConfig::SETUP; | 4408 measConfig->measGapConfig.type = LteRrcSap::MeasGapConfig::SETUP; |
4409 bIterator = DeserializeSequence (&bitset0, false, bIterator); | 4409 bIterator = DeserializeSequence (&bitset0, false, bIterator); |
4410 | 4410 |
4411 int gapOffsetChoice; | 4411 int gapOffsetChoice; |
4412 bIterator = DeserializeChoice (2, true, &gapOffsetChoice, bIterator); | 4412 bIterator = DeserializeChoice (2, true, &gapOffsetChoice, bIterator); |
4413 switch (gapOffsetChoice) | 4413 switch (gapOffsetChoice) |
4414 { | 4414 { |
4415 case 0: | 4415 case 0: |
4416 measConfig->measGapConfig.gapOffsetChoice = LteRrcSap::MeasGapConf
ig::GP0; | 4416 measConfig->measGapConfig.gapOffsetChoice = LteRrcSap::MeasGapConf
ig::GP0; |
4417 bIterator = DeserializeInteger (&n, 0, 39, bIterator); | 4417 bIterator = DeserializeInteger (&n, 0, 39, bIterator); |
4418 measConfig->measGapConfig.gapOffsetValue = n; | 4418 measConfig->measGapConfig.gapOffsetValue = static_cast<uint8_t> (n
); |
4419 break; | 4419 break; |
4420 case 1: | 4420 case 1: |
4421 default: | 4421 default: |
4422 measConfig->measGapConfig.gapOffsetChoice = LteRrcSap::MeasGapConf
ig::GP1; | 4422 measConfig->measGapConfig.gapOffsetChoice = LteRrcSap::MeasGapConf
ig::GP1; |
4423 bIterator = DeserializeInteger (&n, 0, 79, bIterator); | 4423 bIterator = DeserializeInteger (&n, 0, 79, bIterator); |
4424 measConfig->measGapConfig.gapOffsetValue = n; | 4424 measConfig->measGapConfig.gapOffsetValue = static_cast<uint8_t> (n
); |
4425 } | 4425 } |
4426 } | 4426 } |
4427 } | 4427 } |
4428 | 4428 |
4429 measConfig->haveSmeasure = bitset11[2]; | 4429 measConfig->haveSmeasure = bitset11[2]; |
4430 if (measConfig->haveSmeasure) | 4430 if (measConfig->haveSmeasure) |
4431 { | 4431 { |
4432 // s-Measure | 4432 // s-Measure |
4433 bIterator = DeserializeInteger (&n, 0, 97, bIterator); | 4433 bIterator = DeserializeInteger (&n, 0, 97, bIterator); |
4434 measConfig->sMeasure = n; | 4434 measConfig->sMeasure = static_cast<uint8_t> (n); |
4435 } | 4435 } |
4436 | 4436 |
4437 if (bitset11[1]) | 4437 if (bitset11[1]) |
4438 { | 4438 { |
4439 // preRegistrationInfoHRPD | 4439 // preRegistrationInfoHRPD |
4440 // ... | 4440 // ... |
4441 } | 4441 } |
4442 | 4442 |
4443 measConfig->haveSpeedStatePars = bitset11[0]; | 4443 measConfig->haveSpeedStatePars = bitset11[0]; |
4444 if (measConfig->haveSpeedStatePars) | 4444 if (measConfig->haveSpeedStatePars) |
(...skipping 52 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
4497 measConfig->speedStatePars.mobilityStateParameters.tHystNormal = 1
80; | 4497 measConfig->speedStatePars.mobilityStateParameters.tHystNormal = 1
80; |
4498 break; | 4498 break; |
4499 case 4: | 4499 case 4: |
4500 measConfig->speedStatePars.mobilityStateParameters.tHystNormal = 2
40; | 4500 measConfig->speedStatePars.mobilityStateParameters.tHystNormal = 2
40; |
4501 break; | 4501 break; |
4502 default: | 4502 default: |
4503 measConfig->speedStatePars.mobilityStateParameters.tHystNormal = 0
; | 4503 measConfig->speedStatePars.mobilityStateParameters.tHystNormal = 0
; |
4504 } | 4504 } |
4505 | 4505 |
4506 bIterator = DeserializeInteger (&n, 1, 16, bIterator); | 4506 bIterator = DeserializeInteger (&n, 1, 16, bIterator); |
4507 measConfig->speedStatePars.mobilityStateParameters.nCellChangeMedium =
n; | 4507 measConfig->speedStatePars.mobilityStateParameters.nCellChangeMedium =
static_cast<uint8_t> (n); |
4508 | 4508 |
4509 bIterator = DeserializeInteger (&n, 1, 16, bIterator); | 4509 bIterator = DeserializeInteger (&n, 1, 16, bIterator); |
4510 measConfig->speedStatePars.mobilityStateParameters.nCellChangeHigh = n
; | 4510 measConfig->speedStatePars.mobilityStateParameters.nCellChangeHigh = s
tatic_cast<uint8_t> (n); |
4511 | 4511 |
4512 // Deserialize timeToTriggerSf | 4512 // Deserialize timeToTriggerSf |
4513 bIterator = DeserializeEnum (4, &n, bIterator); | 4513 bIterator = DeserializeEnum (4, &n, bIterator); |
4514 measConfig->speedStatePars.timeToTriggerSf.sfMedium = (n + 1) * 25; | 4514 measConfig->speedStatePars.timeToTriggerSf.sfMedium = static_cast<uint
8_t> ((n + 1) * 25); |
4515 bIterator = DeserializeEnum (4, &n, bIterator); | 4515 bIterator = DeserializeEnum (4, &n, bIterator); |
4516 measConfig->speedStatePars.timeToTriggerSf.sfHigh = (n + 1) * 25; | 4516 measConfig->speedStatePars.timeToTriggerSf.sfHigh = static_cast<uint8_
t> ((n + 1) * 25); |
4517 } | 4517 } |
4518 } | 4518 } |
4519 return bIterator; | 4519 return bIterator; |
4520 } | 4520 } |
4521 | 4521 |
4522 //////////////////// RrcConnectionRequest class //////////////////////// | 4522 //////////////////// RrcConnectionRequest class //////////////////////// |
4523 | 4523 |
4524 // Constructor | 4524 // Constructor |
4525 RrcConnectionRequestHeader::RrcConnectionRequestHeader () : RrcUlCcchMessage () | 4525 RrcConnectionRequestHeader::RrcConnectionRequestHeader () : RrcUlCcchMessage () |
4526 { | 4526 { |
(...skipping 207 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
4734 | 4734 |
4735 bIterator = DeserializeDlCcchMessage (bIterator); | 4735 bIterator = DeserializeDlCcchMessage (bIterator); |
4736 | 4736 |
4737 bIterator = DeserializeInteger (&n,0,15,bIterator); | 4737 bIterator = DeserializeInteger (&n,0,15,bIterator); |
4738 | 4738 |
4739 // Deserialize RRCConnectionSetup sequence | 4739 // Deserialize RRCConnectionSetup sequence |
4740 bIterator = DeserializeSequence (&bitset0,false,bIterator); | 4740 bIterator = DeserializeSequence (&bitset0,false,bIterator); |
4741 | 4741 |
4742 // Deserialize rrc-TransactionIdentifier ::=INTEGER (0..3) | 4742 // Deserialize rrc-TransactionIdentifier ::=INTEGER (0..3) |
4743 bIterator = DeserializeInteger (&n,0,3,bIterator); | 4743 bIterator = DeserializeInteger (&n,0,3,bIterator); |
4744 m_rrcTransactionIdentifier = n; | 4744 m_rrcTransactionIdentifier = static_cast<uint8_t> (n); |
4745 | 4745 |
4746 // Deserialize criticalExtensions choice | 4746 // Deserialize criticalExtensions choice |
4747 int criticalExtensionChoice; | 4747 int criticalExtensionChoice; |
4748 bIterator = DeserializeChoice (2,false,&criticalExtensionChoice,bIterator); | 4748 bIterator = DeserializeChoice (2,false,&criticalExtensionChoice,bIterator); |
4749 if (criticalExtensionChoice == 1) | 4749 if (criticalExtensionChoice == 1) |
4750 { | 4750 { |
4751 // Deserialize criticalExtensionsFuture | 4751 // Deserialize criticalExtensionsFuture |
4752 bIterator = DeserializeSequence (&bitset0,false,bIterator); | 4752 bIterator = DeserializeSequence (&bitset0,false,bIterator); |
4753 } | 4753 } |
4754 else if (criticalExtensionChoice == 0) | 4754 else if (criticalExtensionChoice == 0) |
(...skipping 132 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
4887 RrcConnectionSetupCompleteHeader::Deserialize (Buffer::Iterator bIterator) | 4887 RrcConnectionSetupCompleteHeader::Deserialize (Buffer::Iterator bIterator) |
4888 { | 4888 { |
4889 std::bitset<0> bitset0; | 4889 std::bitset<0> bitset0; |
4890 | 4890 |
4891 bIterator = DeserializeUlDcchMessage (bIterator); | 4891 bIterator = DeserializeUlDcchMessage (bIterator); |
4892 | 4892 |
4893 bIterator = DeserializeSequence (&bitset0,false,bIterator); | 4893 bIterator = DeserializeSequence (&bitset0,false,bIterator); |
4894 | 4894 |
4895 int n; | 4895 int n; |
4896 bIterator = DeserializeInteger (&n,0,3,bIterator); | 4896 bIterator = DeserializeInteger (&n,0,3,bIterator); |
4897 m_rrcTransactionIdentifier = n; | 4897 m_rrcTransactionIdentifier = static_cast<uint8_t> (n); |
4898 | 4898 |
4899 bIterator = DeserializeChoice (2,false,&n,bIterator); | 4899 bIterator = DeserializeChoice (2,false,&n,bIterator); |
4900 | 4900 |
4901 if (n == 1) | 4901 if (n == 1) |
4902 { | 4902 { |
4903 // Deserialize criticalExtensionsFuture | 4903 // Deserialize criticalExtensionsFuture |
4904 bIterator = DeserializeSequence (&bitset0,false,bIterator); | 4904 bIterator = DeserializeSequence (&bitset0,false,bIterator); |
4905 } | 4905 } |
4906 else if (n == 0) | 4906 else if (n == 0) |
4907 { | 4907 { |
(...skipping 81 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
4989 uint32_t | 4989 uint32_t |
4990 RrcConnectionReconfigurationCompleteHeader::Deserialize (Buffer::Iterator bItera
tor) | 4990 RrcConnectionReconfigurationCompleteHeader::Deserialize (Buffer::Iterator bItera
tor) |
4991 { | 4991 { |
4992 std::bitset<0> bitset0; | 4992 std::bitset<0> bitset0; |
4993 int n; | 4993 int n; |
4994 | 4994 |
4995 bIterator = DeserializeUlDcchMessage (bIterator); | 4995 bIterator = DeserializeUlDcchMessage (bIterator); |
4996 bIterator = DeserializeSequence (&bitset0,false,bIterator); | 4996 bIterator = DeserializeSequence (&bitset0,false,bIterator); |
4997 | 4997 |
4998 bIterator = DeserializeInteger (&n,0,3,bIterator); | 4998 bIterator = DeserializeInteger (&n,0,3,bIterator); |
4999 m_rrcTransactionIdentifier = n; | 4999 m_rrcTransactionIdentifier = static_cast<uint8_t> (n); |
5000 | 5000 |
5001 bIterator = DeserializeChoice (2,false,&n,bIterator); | 5001 bIterator = DeserializeChoice (2,false,&n,bIterator); |
5002 | 5002 |
5003 if (n == 1) | 5003 if (n == 1) |
5004 { | 5004 { |
5005 // Deserialize criticalExtensionsFuture | 5005 // Deserialize criticalExtensionsFuture |
5006 bIterator = DeserializeSequence (&bitset0,false,bIterator); | 5006 bIterator = DeserializeSequence (&bitset0,false,bIterator); |
5007 } | 5007 } |
5008 else if (n == 0) | 5008 else if (n == 0) |
5009 { | 5009 { |
(...skipping 167 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
5177 std::bitset<0> bitset0; | 5177 std::bitset<0> bitset0; |
5178 | 5178 |
5179 bIterator = DeserializeDlDcchMessage (bIterator); | 5179 bIterator = DeserializeDlDcchMessage (bIterator); |
5180 | 5180 |
5181 // RRCConnectionReconfiguration sequence | 5181 // RRCConnectionReconfiguration sequence |
5182 bIterator = DeserializeSequence (&bitset0,false,bIterator); | 5182 bIterator = DeserializeSequence (&bitset0,false,bIterator); |
5183 | 5183 |
5184 // rrc-TransactionIdentifier | 5184 // rrc-TransactionIdentifier |
5185 int n; | 5185 int n; |
5186 bIterator = DeserializeInteger (&n,0,3,bIterator); | 5186 bIterator = DeserializeInteger (&n,0,3,bIterator); |
5187 m_rrcTransactionIdentifier = n; | 5187 m_rrcTransactionIdentifier = static_cast<uint8_t> (n); |
5188 | 5188 |
5189 // criticalExtensions | 5189 // criticalExtensions |
5190 int sel; | 5190 int sel; |
5191 bIterator = DeserializeChoice (2,false,&sel,bIterator); | 5191 bIterator = DeserializeChoice (2,false,&sel,bIterator); |
5192 if (sel == 1) | 5192 if (sel == 1) |
5193 { | 5193 { |
5194 // criticalExtensionsFuture | 5194 // criticalExtensionsFuture |
5195 bIterator = DeserializeSequence (&bitset0,false,bIterator); | 5195 bIterator = DeserializeSequence (&bitset0,false,bIterator); |
5196 } | 5196 } |
5197 else if (sel == 0) | 5197 else if (sel == 0) |
(...skipping 19 matching lines...) Expand all Loading... |
5217 | 5217 |
5218 m_haveMobilityControlInfo = rrcConnRecOpts[4]; | 5218 m_haveMobilityControlInfo = rrcConnRecOpts[4]; |
5219 if (m_haveMobilityControlInfo) | 5219 if (m_haveMobilityControlInfo) |
5220 { | 5220 { |
5221 // mobilityControlInfo | 5221 // mobilityControlInfo |
5222 std::bitset<4> mobCtrlOpts; | 5222 std::bitset<4> mobCtrlOpts; |
5223 bIterator = DeserializeSequence (&mobCtrlOpts,true,bIterator); | 5223 bIterator = DeserializeSequence (&mobCtrlOpts,true,bIterator); |
5224 | 5224 |
5225 // PhysCellId | 5225 // PhysCellId |
5226 bIterator = DeserializeInteger (&n,0,503,bIterator); | 5226 bIterator = DeserializeInteger (&n,0,503,bIterator); |
5227 m_mobilityControlInfo.targetPhysCellId = n; | 5227 m_mobilityControlInfo.targetPhysCellId = static_cast<uint16_t> (n)
; |
5228 | 5228 |
5229 // carrierFreq | 5229 // carrierFreq |
5230 m_mobilityControlInfo.haveCarrierFreq = mobCtrlOpts[3]; | 5230 m_mobilityControlInfo.haveCarrierFreq = mobCtrlOpts[3]; |
5231 if (m_mobilityControlInfo.haveCarrierFreq) | 5231 if (m_mobilityControlInfo.haveCarrierFreq) |
5232 { | 5232 { |
5233 std::bitset<1> ulCarrierFreqPresent; | 5233 std::bitset<1> ulCarrierFreqPresent; |
5234 bIterator = DeserializeSequence (&ulCarrierFreqPresent,false,b
Iterator); | 5234 bIterator = DeserializeSequence (&ulCarrierFreqPresent,false,b
Iterator); |
5235 | 5235 |
5236 bIterator = DeserializeInteger (&n,0,MAX_EARFCN,bIterator); | 5236 bIterator = DeserializeInteger (&n,0,MAX_EARFCN,bIterator); |
5237 m_mobilityControlInfo.carrierFreq.dlCarrierFreq = n; | 5237 m_mobilityControlInfo.carrierFreq.dlCarrierFreq = n; |
(...skipping 27 matching lines...) Expand all Loading... |
5265 { | 5265 { |
5266 // ... | 5266 // ... |
5267 } | 5267 } |
5268 | 5268 |
5269 // t304 | 5269 // t304 |
5270 bIterator = DeserializeEnum (8,&n,bIterator); | 5270 bIterator = DeserializeEnum (8,&n,bIterator); |
5271 | 5271 |
5272 // newUE-Identity | 5272 // newUE-Identity |
5273 std::bitset<16> cRnti; | 5273 std::bitset<16> cRnti; |
5274 bIterator = DeserializeBitstring (&cRnti, bIterator); | 5274 bIterator = DeserializeBitstring (&cRnti, bIterator); |
5275 m_mobilityControlInfo.newUeIdentity = cRnti.to_ulong (); | 5275 m_mobilityControlInfo.newUeIdentity = static_cast<uint16_t> (cRnti
.to_ulong ()); |
5276 | 5276 |
5277 // radioResourceConfigCommon | 5277 // radioResourceConfigCommon |
5278 bIterator = DeserializeRadioResourceConfigCommon (&m_mobilityContr
olInfo.radioResourceConfigCommon, bIterator); | 5278 bIterator = DeserializeRadioResourceConfigCommon (&m_mobilityContr
olInfo.radioResourceConfigCommon, bIterator); |
5279 | 5279 |
5280 m_mobilityControlInfo.haveRachConfigDedicated = mobCtrlOpts[0]; | 5280 m_mobilityControlInfo.haveRachConfigDedicated = mobCtrlOpts[0]; |
5281 if (m_mobilityControlInfo.haveRachConfigDedicated) | 5281 if (m_mobilityControlInfo.haveRachConfigDedicated) |
5282 { | 5282 { |
5283 bIterator = DeserializeSequence (&bitset0, false, bIterator); | 5283 bIterator = DeserializeSequence (&bitset0, false, bIterator); |
5284 bIterator = DeserializeInteger (&n,0,63, bIterator); | 5284 bIterator = DeserializeInteger (&n,0,63, bIterator); |
5285 m_mobilityControlInfo.rachConfigDedicated.raPreambleIndex = n; | 5285 m_mobilityControlInfo.rachConfigDedicated.raPreambleIndex = st
atic_cast<uint8_t> (n); |
5286 bIterator = DeserializeInteger (&n,0,15, bIterator); | 5286 bIterator = DeserializeInteger (&n,0,15, bIterator); |
5287 m_mobilityControlInfo.rachConfigDedicated.raPrachMaskIndex = n
; | 5287 m_mobilityControlInfo.rachConfigDedicated.raPrachMaskIndex = s
tatic_cast<uint8_t> (n); |
5288 } | 5288 } |
5289 } | 5289 } |
5290 | 5290 |
5291 // dedicatedInfoNASList | 5291 // dedicatedInfoNASList |
5292 if (rrcConnRecOpts[3]) | 5292 if (rrcConnRecOpts[3]) |
5293 { | 5293 { |
5294 // ... | 5294 // ... |
5295 } | 5295 } |
5296 | 5296 |
5297 // radioResourceConfigDedicated | 5297 // radioResourceConfigDedicated |
(...skipping 74 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
5372 os << " carrierFreq: " << (int)it->measObjectEutra.carrierFreq
<< std::endl; | 5372 os << " carrierFreq: " << (int)it->measObjectEutra.carrierFreq
<< std::endl; |
5373 os << " allowedMeasBandwidth: " << (int)it->measObjectEutra.al
lowedMeasBandwidth << std::endl; | 5373 os << " allowedMeasBandwidth: " << (int)it->measObjectEutra.al
lowedMeasBandwidth << std::endl; |
5374 os << " presenceAntennaPort1: " << it->measObjectEutra.presenc
eAntennaPort1 << std::endl; | 5374 os << " presenceAntennaPort1: " << it->measObjectEutra.presenc
eAntennaPort1 << std::endl; |
5375 os << " neighCellConfig: " << (int) it->measObjectEutra.neighCe
llConfig << std::endl; | 5375 os << " neighCellConfig: " << (int) it->measObjectEutra.neighCe
llConfig << std::endl; |
5376 os << " offsetFreq: " << (int)it->measObjectEutra.offsetFreq
<< std::endl; | 5376 os << " offsetFreq: " << (int)it->measObjectEutra.offsetFreq
<< std::endl; |
5377 | 5377 |
5378 | 5378 |
5379 if (!it->measObjectEutra.cellsToRemoveList.empty ()) | 5379 if (!it->measObjectEutra.cellsToRemoveList.empty ()) |
5380 { | 5380 { |
5381 os << " cellsToRemoveList: "; | 5381 os << " cellsToRemoveList: "; |
5382 std::list<uint8_t> auxList = it->measObjectEutra.cellsToRemove
List; | 5382 std::list<uint8_t> auxList2 = it->measObjectEutra.cellsToRemov
eList; |
5383 std::list<uint8_t>::iterator it = auxList.begin (); | 5383 std::list<uint8_t>::iterator it2 = auxList2.begin (); |
5384 for (; it != auxList.end (); it++) | 5384 for (; it2 != auxList2.end (); it2++) |
5385 { | 5385 { |
5386 os << (int) *it << ", "; | 5386 os << (int) *it2 << ", "; |
5387 } | 5387 } |
5388 os << std::endl; | 5388 os << std::endl; |
5389 } | 5389 } |
5390 | 5390 |
5391 if (!it->measObjectEutra.blackCellsToRemoveList.empty ()) | 5391 if (!it->measObjectEutra.blackCellsToRemoveList.empty ()) |
5392 { | 5392 { |
5393 os << " blackCellsToRemoveList: "; | 5393 os << " blackCellsToRemoveList: "; |
5394 std::list<uint8_t> auxList = it->measObjectEutra.blackCellsToR
emoveList; | 5394 std::list<uint8_t> auxList2 = it->measObjectEutra.blackCellsTo
RemoveList; |
5395 std::list<uint8_t>::iterator it = auxList.begin (); | 5395 std::list<uint8_t>::iterator it2 = auxList2.begin (); |
5396 for (; it != auxList.end (); it++) | 5396 for (; it2 != auxList2.end (); it2++) |
5397 { | 5397 { |
5398 os << (int) *it << ", "; | 5398 os << (int) *it2 << ", "; |
5399 } | 5399 } |
5400 os << std::endl; | 5400 os << std::endl; |
5401 } | 5401 } |
5402 | 5402 |
5403 if (!it->measObjectEutra.cellsToAddModList.empty ()) | 5403 if (!it->measObjectEutra.cellsToAddModList.empty ()) |
5404 { | 5404 { |
5405 os << " cellsToAddModList: " << std::endl; | 5405 os << " cellsToAddModList: " << std::endl; |
5406 std::list<LteRrcSap::CellsToAddMod> auxList = it->measObjectEu
tra.cellsToAddModList; | 5406 std::list<LteRrcSap::CellsToAddMod> auxList2 = it->measObjectE
utra.cellsToAddModList; |
5407 std::list<LteRrcSap::CellsToAddMod>::iterator it = auxList.beg
in (); | 5407 std::list<LteRrcSap::CellsToAddMod>::iterator it2 = auxList2.b
egin (); |
5408 for (; it != auxList.end (); it++) | 5408 for (; it2 != auxList2.end (); it2++) |
5409 { | 5409 { |
5410 os << " cellIndex: " << (int)it->cellIndex << std::e
ndl; | 5410 os << " cellIndex: " << (int)it2->cellIndex << std::
endl; |
5411 os << " physCellId: " << (int)it->physCellId << std
::endl; | 5411 os << " physCellId: " << (int)it2->physCellId << st
d::endl; |
5412 os << " cellIndividualOffset: " << (int)it->cellIndi
vidualOffset << std::endl; | 5412 os << " cellIndividualOffset: " << (int)it2->cellInd
ividualOffset << std::endl; |
5413 os << " ------ " << std::endl; | 5413 os << " ------ " << std::endl; |
5414 } | 5414 } |
5415 } | 5415 } |
5416 | 5416 |
5417 if (!it->measObjectEutra.blackCellsToAddModList.empty ()) | 5417 if (!it->measObjectEutra.blackCellsToAddModList.empty ()) |
5418 { | 5418 { |
5419 os << " blackCellsToAddModList: " << std::endl; | 5419 os << " blackCellsToAddModList: " << std::endl; |
5420 std::list<LteRrcSap::BlackCellsToAddMod> auxList = it->measObj
ectEutra.blackCellsToAddModList; | 5420 std::list<LteRrcSap::BlackCellsToAddMod> auxList2 = it->measOb
jectEutra.blackCellsToAddModList; |
5421 std::list<LteRrcSap::BlackCellsToAddMod>::iterator it = auxLis
t.begin (); | 5421 std::list<LteRrcSap::BlackCellsToAddMod>::iterator it2 = auxLi
st2.begin (); |
5422 for (; it != auxList.end (); it++) | 5422 for (; it2 != auxList2.end (); it2++) |
5423 { | 5423 { |
5424 os << " cellIndex: " << (int)it->cellIndex << std::e
ndl; | 5424 os << " cellIndex: " << (int)it2->cellIndex << std::
endl; |
5425 os << " physCellIdRange.start: " << (int)it->physCel
lIdRange.start << std::endl; | 5425 os << " physCellIdRange.start: " << (int)it2->physCe
llIdRange.start << std::endl; |
5426 os << " physCellIdRange.haveRange: " << it->physCell
IdRange.haveRange << std::endl; | 5426 os << " physCellIdRange.haveRange: " << it2->physCel
lIdRange.haveRange << std::endl; |
5427 os << " physCellIdRange.range: " << (int)it->physCel
lIdRange.range << std::endl; | 5427 os << " physCellIdRange.range: " << (int)it2->physCe
llIdRange.range << std::endl; |
5428 os << " ------ " << std::endl; | 5428 os << " ------ " << std::endl; |
5429 } | 5429 } |
5430 } | 5430 } |
5431 | 5431 |
5432 os << " haveCellForWhichToReportCGI: " << it->measObjectEutra.
haveCellForWhichToReportCGI << std::endl; | 5432 os << " haveCellForWhichToReportCGI: " << it->measObjectEutra.
haveCellForWhichToReportCGI << std::endl; |
5433 os << " cellForWhichToReportCGI: " << (int)it->measObjectEutra
.cellForWhichToReportCGI << std::endl; | 5433 os << " cellForWhichToReportCGI: " << (int)it->measObjectEutra
.cellForWhichToReportCGI << std::endl; |
5434 os << " ------------- " << std::endl; | 5434 os << " ------------- " << std::endl; |
5435 } | 5435 } |
5436 | 5436 |
5437 } | 5437 } |
(...skipping 372 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
5810 bIterator = DeserializeRadioResourceConfigDedicated (&m_asConfig.s
ourceRadioResourceConfig,bIterator); | 5810 bIterator = DeserializeRadioResourceConfigDedicated (&m_asConfig.s
ourceRadioResourceConfig,bIterator); |
5811 | 5811 |
5812 // Deserialize sourceSecurityAlgorithmConfig | 5812 // Deserialize sourceSecurityAlgorithmConfig |
5813 bIterator = DeserializeSequence (&bitset0,false,bIterator); | 5813 bIterator = DeserializeSequence (&bitset0,false,bIterator); |
5814 bIterator = DeserializeEnum (8,&n,bIterator); // cipheringAlgorith
m | 5814 bIterator = DeserializeEnum (8,&n,bIterator); // cipheringAlgorith
m |
5815 bIterator = DeserializeEnum (8,&n,bIterator); // integrityProtAlgo
rithm | 5815 bIterator = DeserializeEnum (8,&n,bIterator); // integrityProtAlgo
rithm |
5816 | 5816 |
5817 // Deserialize sourceUE-Identity | 5817 // Deserialize sourceUE-Identity |
5818 std::bitset<16> cRnti; | 5818 std::bitset<16> cRnti; |
5819 bIterator = DeserializeBitstring (&cRnti,bIterator); | 5819 bIterator = DeserializeBitstring (&cRnti,bIterator); |
5820 m_asConfig.sourceUeIdentity = cRnti.to_ulong (); | 5820 m_asConfig.sourceUeIdentity = static_cast<uint16_t> (cRnti.to_ulon
g ()); |
5821 | 5821 |
5822 // Deserialize sourceMasterInformationBlock | 5822 // Deserialize sourceMasterInformationBlock |
5823 bIterator = DeserializeSequence (&bitset0,false,bIterator); | 5823 bIterator = DeserializeSequence (&bitset0,false,bIterator); |
5824 bIterator = DeserializeEnum (6,&n,bIterator); // dl-Bandwidth | 5824 bIterator = DeserializeEnum (6,&n,bIterator); // dl-Bandwidth |
5825 m_asConfig.sourceMasterInformationBlock.dlBandwidth = EnumToBandwi
dth (n); | 5825 m_asConfig.sourceMasterInformationBlock.dlBandwidth = EnumToBandwi
dth (n); |
5826 | 5826 |
5827 // phich-Config | 5827 // phich-Config |
5828 bIterator = DeserializeSequence (&bitset0,false,bIterator); | 5828 bIterator = DeserializeSequence (&bitset0,false,bIterator); |
5829 bIterator = DeserializeEnum (2,&n,bIterator); // phich-Duration | 5829 bIterator = DeserializeEnum (2,&n,bIterator); // phich-Duration |
5830 bIterator = DeserializeEnum (4,&n,bIterator); // phich-Resource | 5830 bIterator = DeserializeEnum (4,&n,bIterator); // phich-Resource |
5831 | 5831 |
5832 // systemFrameNumber | 5832 // systemFrameNumber |
5833 std::bitset<8> systemFrameNumber; | 5833 std::bitset<8> systemFrameNumber; |
5834 bIterator = DeserializeBitstring (&systemFrameNumber,bIterator); | 5834 bIterator = DeserializeBitstring (&systemFrameNumber,bIterator); |
5835 m_asConfig.sourceMasterInformationBlock.systemFrameNumber = system
FrameNumber.to_ulong (); | 5835 m_asConfig.sourceMasterInformationBlock.systemFrameNumber = static
_cast<uint8_t> (systemFrameNumber.to_ulong ()); |
5836 // spare | 5836 // spare |
5837 std::bitset<10> spare; | 5837 std::bitset<10> spare; |
5838 bIterator = DeserializeBitstring (&spare,bIterator); | 5838 bIterator = DeserializeBitstring (&spare,bIterator); |
5839 | 5839 |
5840 // Deserialize sourceSystemInformationBlockType1 | 5840 // Deserialize sourceSystemInformationBlockType1 |
5841 bIterator = DeserializeSystemInformationBlockType1 (&m_asConfig.so
urceSystemInformationBlockType1,bIterator); | 5841 bIterator = DeserializeSystemInformationBlockType1 (&m_asConfig.so
urceSystemInformationBlockType1,bIterator); |
5842 | 5842 |
5843 // Deserialize sourceSystemInformationBlockType2 | 5843 // Deserialize sourceSystemInformationBlockType2 |
5844 bIterator = DeserializeSystemInformationBlockType2 (&m_asConfig.so
urceSystemInformationBlockType2,bIterator); | 5844 bIterator = DeserializeSystemInformationBlockType2 (&m_asConfig.so
urceSystemInformationBlockType2,bIterator); |
5845 | 5845 |
(...skipping 146 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
5992 { | 5992 { |
5993 // Deserialize RRCConnectionReestablishmentRequest-r8-IEs | 5993 // Deserialize RRCConnectionReestablishmentRequest-r8-IEs |
5994 bIterator = DeserializeSequence (&bitset0,false,bIterator); | 5994 bIterator = DeserializeSequence (&bitset0,false,bIterator); |
5995 | 5995 |
5996 // Deserialize ReestabUE-Identity sequence | 5996 // Deserialize ReestabUE-Identity sequence |
5997 bIterator = DeserializeSequence (&bitset0,false,bIterator); | 5997 bIterator = DeserializeSequence (&bitset0,false,bIterator); |
5998 | 5998 |
5999 // Deserialize c-RNTI | 5999 // Deserialize c-RNTI |
6000 std::bitset<16> cRnti; | 6000 std::bitset<16> cRnti; |
6001 bIterator = DeserializeBitstring (&cRnti,bIterator); | 6001 bIterator = DeserializeBitstring (&cRnti,bIterator); |
6002 m_ueIdentity.cRnti = cRnti.to_ulong (); | 6002 m_ueIdentity.cRnti = static_cast<uint16_t> (cRnti.to_ulong ()); |
6003 | 6003 |
6004 // Deserialize physCellId | 6004 // Deserialize physCellId |
6005 int physCellId; | 6005 int physCellId; |
6006 bIterator = DeserializeInteger (&physCellId,0,503,bIterator); | 6006 bIterator = DeserializeInteger (&physCellId,0,503,bIterator); |
6007 m_ueIdentity.physCellId = physCellId; | 6007 m_ueIdentity.physCellId = static_cast<uint16_t> (physCellId); |
6008 | 6008 |
6009 // Deserialize shortMAC-I | 6009 // Deserialize shortMAC-I |
6010 std::bitset<16> shortMacI; | 6010 std::bitset<16> shortMacI; |
6011 bIterator = DeserializeBitstring (&shortMacI,bIterator); | 6011 bIterator = DeserializeBitstring (&shortMacI,bIterator); |
6012 | 6012 |
6013 // Deserialize ReestablishmentCause | 6013 // Deserialize ReestablishmentCause |
6014 int reestCs; | 6014 int reestCs; |
6015 bIterator = DeserializeEnum (4,&reestCs,bIterator); | 6015 bIterator = DeserializeEnum (4,&reestCs,bIterator); |
6016 switch (reestCs) | 6016 switch (reestCs) |
6017 { | 6017 { |
(...skipping 107 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
6125 int n; | 6125 int n; |
6126 | 6126 |
6127 bIterator = DeserializeDlCcchMessage (bIterator); | 6127 bIterator = DeserializeDlCcchMessage (bIterator); |
6128 | 6128 |
6129 // Deserialize RrcConnectionReestablishment sequence | 6129 // Deserialize RrcConnectionReestablishment sequence |
6130 // 0 optional fields, no extension marker | 6130 // 0 optional fields, no extension marker |
6131 bIterator = DeserializeSequence (&bitset0,false,bIterator); | 6131 bIterator = DeserializeSequence (&bitset0,false,bIterator); |
6132 | 6132 |
6133 // Deserialize rrc-TransactionIdentifier | 6133 // Deserialize rrc-TransactionIdentifier |
6134 bIterator = DeserializeInteger (&n,0,3,bIterator); | 6134 bIterator = DeserializeInteger (&n,0,3,bIterator); |
6135 m_rrcTransactionIdentifier = n; | 6135 m_rrcTransactionIdentifier = static_cast<uint8_t> (n); |
6136 | 6136 |
6137 // Deserialize criticalExtensions choice | 6137 // Deserialize criticalExtensions choice |
6138 int criticalExtensionsChoice; | 6138 int criticalExtensionsChoice; |
6139 bIterator = DeserializeChoice (2,false,&criticalExtensionsChoice,bIterator); | 6139 bIterator = DeserializeChoice (2,false,&criticalExtensionsChoice,bIterator); |
6140 if (criticalExtensionsChoice == 1) | 6140 if (criticalExtensionsChoice == 1) |
6141 { | 6141 { |
6142 // Deserialize criticalExtensionsFuture | 6142 // Deserialize criticalExtensionsFuture |
6143 bIterator = DeserializeSequence (&bitset0,false,bIterator); | 6143 bIterator = DeserializeSequence (&bitset0,false,bIterator); |
6144 } | 6144 } |
6145 else if (criticalExtensionsChoice == 0) | 6145 else if (criticalExtensionsChoice == 0) |
(...skipping 99 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
6245 int n; | 6245 int n; |
6246 | 6246 |
6247 bIterator = DeserializeUlDcchMessage (bIterator); | 6247 bIterator = DeserializeUlDcchMessage (bIterator); |
6248 | 6248 |
6249 // Deserialize RrcConnectionReestablishmentComplete sequence | 6249 // Deserialize RrcConnectionReestablishmentComplete sequence |
6250 // 0 optional fields, no extension marker | 6250 // 0 optional fields, no extension marker |
6251 bIterator = DeserializeSequence (&bitset0,false,bIterator); | 6251 bIterator = DeserializeSequence (&bitset0,false,bIterator); |
6252 | 6252 |
6253 // Deserialize rrc-TransactionIdentifier | 6253 // Deserialize rrc-TransactionIdentifier |
6254 bIterator = DeserializeInteger (&n,0,3,bIterator); | 6254 bIterator = DeserializeInteger (&n,0,3,bIterator); |
6255 m_rrcTransactionIdentifier = n; | 6255 m_rrcTransactionIdentifier = static_cast<uint8_t> (n); |
6256 | 6256 |
6257 // Deserialize criticalExtensions choice | 6257 // Deserialize criticalExtensions choice |
6258 int criticalExtensionsChoice; | 6258 int criticalExtensionsChoice; |
6259 bIterator = DeserializeChoice (2,false,&criticalExtensionsChoice,bIterator); | 6259 bIterator = DeserializeChoice (2,false,&criticalExtensionsChoice,bIterator); |
6260 if (criticalExtensionsChoice == 1) | 6260 if (criticalExtensionsChoice == 1) |
6261 { | 6261 { |
6262 // Deserialize criticalExtensionsFuture | 6262 // Deserialize criticalExtensionsFuture |
6263 bIterator = DeserializeSequence (&bitset0,false,bIterator); | 6263 bIterator = DeserializeSequence (&bitset0,false,bIterator); |
6264 } | 6264 } |
6265 else if (criticalExtensionsChoice == 0) | 6265 else if (criticalExtensionsChoice == 0) |
(...skipping 172 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
6438 int n; | 6438 int n; |
6439 | 6439 |
6440 bIterator = DeserializeDlDcchMessage (bIterator); | 6440 bIterator = DeserializeDlDcchMessage (bIterator); |
6441 | 6441 |
6442 // Deserialize RrcConnectionRelease sequence | 6442 // Deserialize RrcConnectionRelease sequence |
6443 // 0 optional fields, no extension marker | 6443 // 0 optional fields, no extension marker |
6444 bIterator = DeserializeSequence (&bitset0,false,bIterator); | 6444 bIterator = DeserializeSequence (&bitset0,false,bIterator); |
6445 | 6445 |
6446 // Deserialize rrc-TransactionIdentifier | 6446 // Deserialize rrc-TransactionIdentifier |
6447 bIterator = DeserializeInteger (&n,0,3,bIterator); | 6447 bIterator = DeserializeInteger (&n,0,3,bIterator); |
6448 m_rrcConnectionRelease.rrcTransactionIdentifier = n; | 6448 m_rrcConnectionRelease.rrcTransactionIdentifier = static_cast<uint8_t> (n); |
6449 | 6449 |
6450 // Deserialize criticalExtensions choice | 6450 // Deserialize criticalExtensions choice |
6451 int criticalExtensionsChoice; | 6451 int criticalExtensionsChoice; |
6452 bIterator = DeserializeChoice (2,false,&criticalExtensionsChoice,bIterator); | 6452 bIterator = DeserializeChoice (2,false,&criticalExtensionsChoice,bIterator); |
6453 if (criticalExtensionsChoice == 1) | 6453 if (criticalExtensionsChoice == 1) |
6454 { | 6454 { |
6455 // Deserialize criticalExtensionsFuture | 6455 // Deserialize criticalExtensionsFuture |
6456 bIterator = DeserializeSequence (&bitset0,false,bIterator); | 6456 bIterator = DeserializeSequence (&bitset0,false,bIterator); |
6457 } | 6457 } |
6458 else if (criticalExtensionsChoice == 0) | 6458 else if (criticalExtensionsChoice == 0) |
(...skipping 124 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
6583 { | 6583 { |
6584 bIterator = DeserializeNull (bIterator); | 6584 bIterator = DeserializeNull (bIterator); |
6585 } | 6585 } |
6586 else if (c1Choice == 0) | 6586 else if (c1Choice == 0) |
6587 { | 6587 { |
6588 // Deserialize rrcConnectionReject-r8 | 6588 // Deserialize rrcConnectionReject-r8 |
6589 std::bitset<1> opts; | 6589 std::bitset<1> opts; |
6590 bIterator = DeserializeSequence (&opts,false,bIterator); | 6590 bIterator = DeserializeSequence (&opts,false,bIterator); |
6591 | 6591 |
6592 bIterator = DeserializeInteger (&n,1,16,bIterator); | 6592 bIterator = DeserializeInteger (&n,1,16,bIterator); |
6593 m_rrcConnectionReject.waitTime = n; | 6593 m_rrcConnectionReject.waitTime = static_cast<uint8_t> (n); |
6594 | 6594 |
6595 if (opts[0]) | 6595 if (opts[0]) |
6596 { | 6596 { |
6597 // Deserialize RRCConnectionReject-v8a0-IEs | 6597 // Deserialize RRCConnectionReject-v8a0-IEs |
6598 // ... | 6598 // ... |
6599 } | 6599 } |
6600 } | 6600 } |
6601 } | 6601 } |
6602 | 6602 |
6603 return GetSerializedSize (); | 6603 return GetSerializedSize (); |
(...skipping 408 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
7012 { | 7012 { |
7013 SerializeSequence (std::bitset<0> (),false); | 7013 SerializeSequence (std::bitset<0> (),false); |
7014 // Choose c1 | 7014 // Choose c1 |
7015 SerializeChoice (2,0,false); | 7015 SerializeChoice (2,0,false); |
7016 // Choose message type | 7016 // Choose message type |
7017 SerializeChoice (4,messageType,false); | 7017 SerializeChoice (4,messageType,false); |
7018 } | 7018 } |
7019 | 7019 |
7020 } // namespace ns3 | 7020 } // namespace ns3 |
7021 | 7021 |
OLD | NEW |