LEFT | RIGHT |
1 /* -*- Mode: C++; c-file-style: "gnu"; indent-tabs-mode:nil; -*- */ | 1 /* -*- Mode: C++; c-file-style: "gnu"; indent-tabs-mode:nil; -*- */ |
2 /* | 2 /* |
3 * Copyright (c) 2012 Centre Tecnologic de Telecomunicacions de Catalunya (CTTC) | 3 * Copyright (c) 2012 Centre Tecnologic de Telecomunicacions de Catalunya (CTTC) |
4 * | 4 * |
5 * This program is free software; you can redistribute it and/or modify | 5 * This program is free software; you can redistribute it and/or modify |
6 * it under the terms of the GNU General Public License version 2 as | 6 * it under the terms of the GNU General Public License version 2 as |
7 * published by the Free Software Foundation; | 7 * published by the Free Software Foundation; |
8 * | 8 * |
9 * This program is distributed in the hope that it will be useful, | 9 * This program is distributed in the hope that it will be useful, |
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of | 10 * but WITHOUT ANY WARRANTY; without even the implied warranty of |
(...skipping 743 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
754 { | 754 { |
755 // plmn-Identity sequence, mcc is optional, no extension marker | 755 // plmn-Identity sequence, mcc is optional, no extension marker |
756 SerializeSequence (std::bitset<1> (0), false); | 756 SerializeSequence (std::bitset<1> (0), false); |
757 | 757 |
758 // Serialize mnc | 758 // Serialize mnc |
759 int nDig = (plmnId > 99) ? 3 : 2; | 759 int nDig = (plmnId > 99) ? 3 : 2; |
760 | 760 |
761 SerializeSequenceOf (nDig,3,2); | 761 SerializeSequenceOf (nDig,3,2); |
762 for (int i = nDig - 1; i >= 0; i--) | 762 for (int i = nDig - 1; i >= 0; i--) |
763 { | 763 { |
764 int n = (int)floor (plmnId / pow (10,i)); | 764 int n = static_cast<int>(floor (plmnId / pow (10,i))); |
765 SerializeInteger (n,0,9); | 765 SerializeInteger (n,0,9); |
766 plmnId -= (uint32_t)(n * pow (10,i)); | 766 plmnId -= static_cast<uint32_t>(n * pow (10,i)); |
767 } | 767 } |
768 | 768 |
769 // cellReservedForOperatorUse· | 769 // cellReservedForOperatorUse· |
770 SerializeEnum (2,0); | 770 SerializeEnum (2,0); |
771 } | 771 } |
772 | 772 |
773 void· | 773 void· |
774 RrcAsn1Header::SerializeRachConfigCommon (LteRrcSap::RachConfigCommon rachConfig
Common) const | 774 RrcAsn1Header::SerializeRachConfigCommon (LteRrcSap::RachConfigCommon rachConfig
Common) const |
775 { | 775 { |
776 // rach-ConfigCommon | 776 // rach-ConfigCommon |
(...skipping 1215 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1992 RrcAsn1Header::DeserializeThresholdEutra (LteRrcSap::ThresholdEutra * thresholdE
utra, Buffer::Iterator bIterator) | 1992 RrcAsn1Header::DeserializeThresholdEutra (LteRrcSap::ThresholdEutra * thresholdE
utra, Buffer::Iterator bIterator) |
1993 { | 1993 { |
1994 int thresholdEutraChoice, range; | 1994 int thresholdEutraChoice, range; |
1995 bIterator = DeserializeChoice (2, false, &thresholdEutraChoice, bIterator); | 1995 bIterator = DeserializeChoice (2, false, &thresholdEutraChoice, bIterator); |
1996 | 1996 |
1997 switch (thresholdEutraChoice) | 1997 switch (thresholdEutraChoice) |
1998 { | 1998 { |
1999 case 0: | 1999 case 0: |
2000 thresholdEutra->choice = LteRrcSap::ThresholdEutra::THRESHOLD_RSRP; | 2000 thresholdEutra->choice = LteRrcSap::ThresholdEutra::THRESHOLD_RSRP; |
2001 bIterator = DeserializeInteger (&range, 0, 97, bIterator); | 2001 bIterator = DeserializeInteger (&range, 0, 97, bIterator); |
2002 thresholdEutra->range = (uint8_t)range; | 2002 thresholdEutra->range = static_cast<uint8_t>(range); |
2003 break; | 2003 break; |
2004 case 1: | 2004 case 1: |
2005 default: | 2005 default: |
2006 thresholdEutra->choice = LteRrcSap::ThresholdEutra::THRESHOLD_RSRQ; | 2006 thresholdEutra->choice = LteRrcSap::ThresholdEutra::THRESHOLD_RSRQ; |
2007 bIterator = DeserializeInteger (&range, 0, 34, bIterator); | 2007 bIterator = DeserializeInteger (&range, 0, 34, bIterator); |
2008 thresholdEutra->range = (uint8_t)range; | 2008 thresholdEutra->range = static_cast<uint8_t>(range); |
2009 } | 2009 } |
2010 | 2010 |
2011 return bIterator; | 2011 return bIterator; |
2012 } | 2012 } |
2013 | 2013 |
2014 Buffer::Iterator | 2014 Buffer::Iterator |
2015 RrcAsn1Header::DeserializeQoffsetRange (int8_t * qOffsetRange, Buffer::Iterator
bIterator) | 2015 RrcAsn1Header::DeserializeQoffsetRange (int8_t * qOffsetRange, Buffer::Iterator
bIterator) |
2016 { | 2016 { |
2017 int n; | 2017 int n; |
2018 bIterator = DeserializeEnum (31, &n, bIterator); | 2018 bIterator = DeserializeEnum (31, &n, bIterator); |
(...skipping 117 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2136 | 2136 |
2137 if (optionalFieldsPresent[3]) | 2137 if (optionalFieldsPresent[3]) |
2138 { | 2138 { |
2139 // Deserialize drb-ToReleaseList | 2139 // Deserialize drb-ToReleaseList |
2140 int n; | 2140 int n; |
2141 int val; | 2141 int val; |
2142 bIterator = DeserializeSequenceOf (&n,MAX_DRB,1,bIterator); | 2142 bIterator = DeserializeSequenceOf (&n,MAX_DRB,1,bIterator); |
2143 for (int i = 0; i < n; i++) | 2143 for (int i = 0; i < n; i++) |
2144 { | 2144 { |
2145 bIterator = DeserializeInteger (&val,1,32,bIterator); | 2145 bIterator = DeserializeInteger (&val,1,32,bIterator); |
2146 radioResourceConfigDedicated->drbToReleaseList.push_back ((uint8_t)val
); | 2146 radioResourceConfigDedicated->drbToReleaseList.push_back (static_cast<
uint8_t>(val)); |
2147 } | 2147 } |
2148 } | 2148 } |
2149 | 2149 |
2150 if (optionalFieldsPresent[2]) | 2150 if (optionalFieldsPresent[2]) |
2151 { | 2151 { |
2152 // Deserialize mac-MainConfig | 2152 // Deserialize mac-MainConfig |
2153 // ... | 2153 // ... |
2154 } | 2154 } |
2155 | 2155 |
2156 if (optionalFieldsPresent[1]) | 2156 if (optionalFieldsPresent[1]) |
(...skipping 25 matching lines...) Expand all Loading... |
2182 { | 2182 { |
2183 LteRrcSap::SrbToAddMod srbToAddMod; | 2183 LteRrcSap::SrbToAddMod srbToAddMod; |
2184 // Deserialize SRB-ToAddMod sequence | 2184 // Deserialize SRB-ToAddMod sequence |
2185 // 2 optional fields, extension marker present | 2185 // 2 optional fields, extension marker present |
2186 std::bitset<2> optionalFields; | 2186 std::bitset<2> optionalFields; |
2187 bIterator = DeserializeSequence (&optionalFields,true,bIterator); | 2187 bIterator = DeserializeSequence (&optionalFields,true,bIterator); |
2188 | 2188 |
2189 // Deserialize srbIdentity | 2189 // Deserialize srbIdentity |
2190 int n; | 2190 int n; |
2191 bIterator = DeserializeInteger (&n,1,2,bIterator); | 2191 bIterator = DeserializeInteger (&n,1,2,bIterator); |
2192 srbToAddMod.srbIdentity = (uint8_t)n; | 2192 srbToAddMod.srbIdentity = static_cast<uint8_t>(n); |
2193 | 2193 |
2194 if (optionalFields[1]) | 2194 if (optionalFields[1]) |
2195 { | 2195 { |
2196 // Deserialize rlcConfig choice | 2196 // Deserialize rlcConfig choice |
2197 // ... | 2197 // ... |
2198 } | 2198 } |
2199 | 2199 |
2200 if (optionalFields[0]) | 2200 if (optionalFields[0]) |
2201 { | 2201 { |
2202 // Deserialize logicalChannelConfig choice | 2202 // Deserialize logicalChannelConfig choice |
(...skipping 31 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2234 { | 2234 { |
2235 LteRrcSap::DrbToAddMod drbToAddMod; | 2235 LteRrcSap::DrbToAddMod drbToAddMod; |
2236 | 2236 |
2237 std::bitset<5> optionalFields; | 2237 std::bitset<5> optionalFields; |
2238 bIterator = DeserializeSequence (&optionalFields,true,bIterator); | 2238 bIterator = DeserializeSequence (&optionalFields,true,bIterator); |
2239 | 2239 |
2240 if (optionalFields[4]) | 2240 if (optionalFields[4]) |
2241 { | 2241 { |
2242 // Deserialize epsBearerIdentity | 2242 // Deserialize epsBearerIdentity |
2243 bIterator = DeserializeInteger (&val,0,15,bIterator); | 2243 bIterator = DeserializeInteger (&val,0,15,bIterator); |
2244 drbToAddMod.epsBearerIdentity = (uint8_t)val; | 2244 drbToAddMod.epsBearerIdentity = static_cast<uint8_t>(val); |
2245 } | 2245 } |
2246 | 2246 |
2247 bIterator = DeserializeInteger (&val,1,32,bIterator); | 2247 bIterator = DeserializeInteger (&val,1,32,bIterator); |
2248 drbToAddMod.drbIdentity = (uint8_t)val; | 2248 drbToAddMod.drbIdentity = static_cast<uint8_t>(val); |
2249 | 2249 |
2250 if (optionalFields[3]) | 2250 if (optionalFields[3]) |
2251 { | 2251 { |
2252 // Deserialize pdcp-Config | 2252 // Deserialize pdcp-Config |
2253 // ... | 2253 // ... |
2254 } | 2254 } |
2255 | 2255 |
2256 if (optionalFields[2]) | 2256 if (optionalFields[2]) |
2257 { | 2257 { |
2258 // Deserialize RLC-Config | 2258 // Deserialize RLC-Config |
(...skipping 49 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2308 bIterator = DeserializeEnum (2,&sel, bIterator); // sn-FieldLength | 2308 bIterator = DeserializeEnum (2,&sel, bIterator); // sn-FieldLength |
2309 bIterator = DeserializeEnum (32,&sel, bIterator); // t-Reordering | 2309 bIterator = DeserializeEnum (32,&sel, bIterator); // t-Reordering |
2310 break; | 2310 break; |
2311 } | 2311 } |
2312 | 2312 |
2313 } | 2313 } |
2314 | 2314 |
2315 if (optionalFields[1]) | 2315 if (optionalFields[1]) |
2316 { | 2316 { |
2317 bIterator = DeserializeInteger (&val,3,10,bIterator); | 2317 bIterator = DeserializeInteger (&val,3,10,bIterator); |
2318 drbToAddMod.logicalChannelIdentity = (uint8_t)val; | 2318 drbToAddMod.logicalChannelIdentity = static_cast<uint8_t>(val); |
2319 } | 2319 } |
2320 | 2320 |
2321 if (optionalFields[0]) | 2321 if (optionalFields[0]) |
2322 { | 2322 { |
2323 bIterator = DeserializeLogicalChannelConfig (&drbToAddMod.logicalChann
elConfig,bIterator); | 2323 bIterator = DeserializeLogicalChannelConfig (&drbToAddMod.logicalChann
elConfig,bIterator); |
2324 } | 2324 } |
2325 | 2325 |
2326 drbToAddModList->insert (drbToAddModList->end (),drbToAddMod); | 2326 drbToAddModList->insert (drbToAddModList->end (),drbToAddMod); |
2327 } | 2327 } |
2328 return bIterator; | 2328 return bIterator; |
2329 } | 2329 } |
2330 | 2330 |
2331 Buffer::Iterator | 2331 Buffer::Iterator |
2332 RrcAsn1Header::DeserializeLogicalChannelConfig (LteRrcSap::LogicalChannelConfig
*logicalChannelConfig, Buffer::Iterator bIterator) | 2332 RrcAsn1Header::DeserializeLogicalChannelConfig (LteRrcSap::LogicalChannelConfig
*logicalChannelConfig, Buffer::Iterator bIterator) |
2333 { | 2333 { |
2334 int n; | 2334 int n; |
2335 | 2335 |
2336 // Deserialize LogicalChannelConfig sequence | 2336 // Deserialize LogicalChannelConfig sequence |
2337 // 1 optional field, extension marker is present. | 2337 // 1 optional field, extension marker is present. |
2338 std::bitset<1> bitset1; | 2338 std::bitset<1> bitset1; |
2339 bIterator = DeserializeSequence (&bitset1,true,bIterator); | 2339 bIterator = DeserializeSequence (&bitset1,true,bIterator); |
2340 | 2340 |
2341 if (bitset1[0]) | 2341 if (bitset1[0]) |
2342 { | 2342 { |
2343 // Deserialize ul-SpecificParameters sequence | 2343 // Deserialize ul-SpecificParameters sequence |
2344 bIterator = DeserializeSequence (&bitset1,false,bIterator); | 2344 bIterator = DeserializeSequence (&bitset1,false,bIterator); |
2345 | 2345 |
2346 // Deserialize priority | 2346 // Deserialize priority |
2347 bIterator = DeserializeInteger (&n,1,16,bIterator); | 2347 bIterator = DeserializeInteger (&n,1,16,bIterator); |
2348 logicalChannelConfig->priority = (uint8_t)n; | 2348 logicalChannelConfig->priority = static_cast<uint8_t>(n); |
2349 | 2349 |
2350 // Deserialize prioritisedBitRate | 2350 // Deserialize prioritisedBitRate |
2351 bIterator = DeserializeEnum (16,&n,bIterator); | 2351 bIterator = DeserializeEnum (16,&n,bIterator); |
2352 uint16_t prioritizedBitRateKbps; | 2352 uint16_t prioritizedBitRateKbps; |
2353 | 2353 |
2354 switch (n) | 2354 switch (n) |
2355 { | 2355 { |
2356 case 0: | 2356 case 0: |
2357 prioritizedBitRateKbps = 0; | 2357 prioritizedBitRateKbps = 0; |
2358 break; | 2358 break; |
(...skipping 48 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2407 break; | 2407 break; |
2408 default: | 2408 default: |
2409 bucketSizeDurationMs = 1000; | 2409 bucketSizeDurationMs = 1000; |
2410 } | 2410 } |
2411 logicalChannelConfig->bucketSizeDurationMs = bucketSizeDurationMs; | 2411 logicalChannelConfig->bucketSizeDurationMs = bucketSizeDurationMs; |
2412 | 2412 |
2413 if (bitset1[0]) | 2413 if (bitset1[0]) |
2414 { | 2414 { |
2415 // Deserialize logicalChannelGroup | 2415 // Deserialize logicalChannelGroup |
2416 bIterator = DeserializeInteger (&n,0,3,bIterator); | 2416 bIterator = DeserializeInteger (&n,0,3,bIterator); |
2417 logicalChannelConfig->logicalChannelGroup = (uint8_t)n; | 2417 logicalChannelConfig->logicalChannelGroup = static_cast<uint8_t>(n); |
2418 } | 2418 } |
2419 } | 2419 } |
2420 return bIterator; | 2420 return bIterator; |
2421 } | 2421 } |
2422 | 2422 |
2423 Buffer::Iterator | 2423 Buffer::Iterator |
2424 RrcAsn1Header::DeserializePhysicalConfigDedicated (LteRrcSap::PhysicalConfigDedi
cated *physicalConfigDedicated, Buffer::Iterator bIterator) | 2424 RrcAsn1Header::DeserializePhysicalConfigDedicated (LteRrcSap::PhysicalConfigDedi
cated *physicalConfigDedicated, Buffer::Iterator bIterator) |
2425 { | 2425 { |
2426 std::bitset<10> optionalFieldPresent; | 2426 std::bitset<10> optionalFieldPresent; |
2427 bIterator = DeserializeSequence (&optionalFieldPresent,true,bIterator); | 2427 bIterator = DeserializeSequence (&optionalFieldPresent,true,bIterator); |
2428 | 2428 |
2429 physicalConfigDedicated->havePdschConfigDedicated = optionalFieldPresent[9]; | 2429 physicalConfigDedicated->havePdschConfigDedicated = optionalFieldPresent[9]; |
2430 if (optionalFieldPresent[9]) | 2430 if (optionalFieldPresent[9]) |
2431 { | 2431 { |
2432 // Deserialize pdsch-ConfigDedicated | 2432 // Deserialize pdsch-ConfigDedicated |
2433 std::bitset<0> bitset0; | 2433 std::bitset<0> bitset0; |
2434 bIterator = DeserializeSequence (&bitset0,false,bIterator); | 2434 bIterator = DeserializeSequence (&bitset0,false,bIterator); |
2435 | 2435 |
2436 int slct; | 2436 int slct; |
2437 | 2437 |
2438 // Deserialize p-a | 2438 // Deserialize p-a |
2439 bIterator = DeserializeEnum (8,&slct,bIterator); | 2439 bIterator = DeserializeEnum (8,&slct,bIterator); |
2440 physicalConfigDedicated->pdschConfigDedicated.pa = (uint8_t)slct; | 2440 physicalConfigDedicated->pdschConfigDedicated.pa = static_cast<uint8_t>(sl
ct); |
2441 | 2441 |
2442 bIterator = DeserializeNull (bIterator); | 2442 bIterator = DeserializeNull (bIterator); |
2443 | 2443 |
2444 } | 2444 } |
2445 if (optionalFieldPresent[8]) | 2445 if (optionalFieldPresent[8]) |
2446 { | 2446 { |
2447 // Deserialize pucch-ConfigDedicated | 2447 // Deserialize pucch-ConfigDedicated |
2448 // ... | 2448 // ... |
2449 } | 2449 } |
2450 if (optionalFieldPresent[7]) | 2450 if (optionalFieldPresent[7]) |
(...skipping 39 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2490 { | 2490 { |
2491 physicalConfigDedicated->soundingRsUlConfigDedicated.type = LteRrcSap:
:SoundingRsUlConfigDedicated::SETUP; | 2491 physicalConfigDedicated->soundingRsUlConfigDedicated.type = LteRrcSap:
:SoundingRsUlConfigDedicated::SETUP; |
2492 | 2492 |
2493 std::bitset<0> bitset0; | 2493 std::bitset<0> bitset0; |
2494 bIterator = DeserializeSequence (&bitset0,false,bIterator); | 2494 bIterator = DeserializeSequence (&bitset0,false,bIterator); |
2495 | 2495 |
2496 int slct; | 2496 int slct; |
2497 | 2497 |
2498 // Deserialize srs-Bandwidth | 2498 // Deserialize srs-Bandwidth |
2499 bIterator = DeserializeEnum (4,&slct,bIterator); | 2499 bIterator = DeserializeEnum (4,&slct,bIterator); |
2500 physicalConfigDedicated->soundingRsUlConfigDedicated.srsBandwidth = (u
int8_t)slct; | 2500 physicalConfigDedicated->soundingRsUlConfigDedicated.srsBandwidth = st
atic_cast<uint8_t>(slct); |
2501 | 2501 |
2502 // Deserialize srs-HoppingBandwidth | 2502 // Deserialize srs-HoppingBandwidth |
2503 bIterator = DeserializeEnum (4,&slct,bIterator); | 2503 bIterator = DeserializeEnum (4,&slct,bIterator); |
2504 | 2504 |
2505 // Deserialize freqDomainPosition | 2505 // Deserialize freqDomainPosition |
2506 bIterator = DeserializeInteger (&slct,0,23,bIterator); | 2506 bIterator = DeserializeInteger (&slct,0,23,bIterator); |
2507 | 2507 |
2508 // Deserialize duration | 2508 // Deserialize duration |
2509 bool duration; | 2509 bool duration; |
2510 bIterator = DeserializeBoolean (&duration,bIterator); | 2510 bIterator = DeserializeBoolean (&duration,bIterator); |
2511 | 2511 |
2512 // Deserialize srs-ConfigIndex | 2512 // Deserialize srs-ConfigIndex |
2513 bIterator = DeserializeInteger (&slct,0,1023,bIterator); | 2513 bIterator = DeserializeInteger (&slct,0,1023,bIterator); |
2514 physicalConfigDedicated->soundingRsUlConfigDedicated.srsConfigIndex =
(uint16_t)slct; | 2514 physicalConfigDedicated->soundingRsUlConfigDedicated.srsConfigIndex =
static_cast<uint16_t>(slct); |
2515 | 2515 |
2516 // Deserialize transmissionComb | 2516 // Deserialize transmissionComb |
2517 bIterator = DeserializeInteger (&slct,0,1,bIterator); | 2517 bIterator = DeserializeInteger (&slct,0,1,bIterator); |
2518 | 2518 |
2519 // Deserialize cyclicShift | 2519 // Deserialize cyclicShift |
2520 bIterator = DeserializeEnum (8,&slct,bIterator); | 2520 bIterator = DeserializeEnum (8,&slct,bIterator); |
2521 } | 2521 } |
2522 } | 2522 } |
2523 physicalConfigDedicated->haveAntennaInfoDedicated = optionalFieldPresent[1]; | 2523 physicalConfigDedicated->haveAntennaInfoDedicated = optionalFieldPresent[1]; |
2524 if (optionalFieldPresent[1]) | 2524 if (optionalFieldPresent[1]) |
2525 { | 2525 { |
2526 // Deserialize antennaInfo | 2526 // Deserialize antennaInfo |
2527 int sel; | 2527 int sel; |
2528 bIterator = DeserializeChoice (2,false,&sel,bIterator); | 2528 bIterator = DeserializeChoice (2,false,&sel,bIterator); |
2529 if (sel == 1) | 2529 if (sel == 1) |
2530 { | 2530 { |
2531 bIterator = DeserializeNull (bIterator); | 2531 bIterator = DeserializeNull (bIterator); |
2532 } | 2532 } |
2533 else if (sel == 0) | 2533 else if (sel == 0) |
2534 { | 2534 { |
2535 std::bitset<1> codebookSubsetRestrictionPresent; | 2535 std::bitset<1> codebookSubsetRestrictionPresent; |
2536 bIterator = DeserializeSequence (&codebookSubsetRestrictionPresent,fal
se,bIterator); | 2536 bIterator = DeserializeSequence (&codebookSubsetRestrictionPresent,fal
se,bIterator); |
2537 | 2537 |
2538 int txmode; | 2538 int txmode; |
2539 bIterator = DeserializeEnum (8,&txmode,bIterator); | 2539 bIterator = DeserializeEnum (8,&txmode,bIterator); |
2540 physicalConfigDedicated->antennaInfo.transmissionMode = (uint8_t)txmod
e; | 2540 physicalConfigDedicated->antennaInfo.transmissionMode = static_cast<ui
nt8_t>(txmode); |
2541 | 2541 |
2542 if (codebookSubsetRestrictionPresent[0]) | 2542 if (codebookSubsetRestrictionPresent[0]) |
2543 { | 2543 { |
2544 // Deserialize codebookSubsetRestriction | 2544 // Deserialize codebookSubsetRestriction |
2545 // ... | 2545 // ... |
2546 } | 2546 } |
2547 | 2547 |
2548 int txantennaselchosen; | 2548 int txantennaselchosen; |
2549 bIterator = DeserializeChoice (2,false,&txantennaselchosen,bIterator); | 2549 bIterator = DeserializeChoice (2,false,&txantennaselchosen,bIterator); |
2550 if (txantennaselchosen == 0) | 2550 if (txantennaselchosen == 0) |
(...skipping 106 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2657 std::bitset<2> radioResourceConfigCommonSCell_r10; | 2657 std::bitset<2> radioResourceConfigCommonSCell_r10; |
2658 bIterator = DeserializeSequence (&radioResourceConfigCommonSCell_r10,false,b
Iterator); | 2658 bIterator = DeserializeSequence (&radioResourceConfigCommonSCell_r10,false,b
Iterator); |
2659 rrccsc->haveNonUlConfiguration = radioResourceConfigCommonSCell_r10[1]; | 2659 rrccsc->haveNonUlConfiguration = radioResourceConfigCommonSCell_r10[1]; |
2660 rrccsc->haveUlConfiguration = radioResourceConfigCommonSCell_r10[0]; | 2660 rrccsc->haveUlConfiguration = radioResourceConfigCommonSCell_r10[0]; |
2661 if (rrccsc->haveNonUlConfiguration) | 2661 if (rrccsc->haveNonUlConfiguration) |
2662 { | 2662 { |
2663 std::bitset<5> nonUlConfiguration_r10; | 2663 std::bitset<5> nonUlConfiguration_r10; |
2664 bIterator = DeserializeSequence (&nonUlConfiguration_r10,false,bIterator
); | 2664 bIterator = DeserializeSequence (&nonUlConfiguration_r10,false,bIterator
); |
2665 int n; | 2665 int n; |
2666 bIterator = DeserializeInteger (&n,6,100,bIterator); | 2666 bIterator = DeserializeInteger (&n,6,100,bIterator); |
2667 rrccsc->nonUlConfiguration.dlBandwidth = (uint16_t)n; | 2667 rrccsc->nonUlConfiguration.dlBandwidth = static_cast<uint16_t>(n); |
2668 | 2668 |
2669 std::bitset<1> antennaInfoCommon_r10; | 2669 std::bitset<1> antennaInfoCommon_r10; |
2670 bIterator = DeserializeSequence (&antennaInfoCommon_r10,false,bIterator)
; | 2670 bIterator = DeserializeSequence (&antennaInfoCommon_r10,false,bIterator)
; |
2671 bIterator = DeserializeInteger (&n,0,65536,bIterator); | 2671 bIterator = DeserializeInteger (&n,0,65536,bIterator); |
2672 rrccsc->nonUlConfiguration.antennaInfoCommon.antennaPortsCount = (uint16
_t)n; | 2672 rrccsc->nonUlConfiguration.antennaInfoCommon.antennaPortsCount = static_
cast<uint16_t>(n); |
2673 | 2673 |
2674 std::bitset<2> pdschConfigCommon_r10; | 2674 std::bitset<2> pdschConfigCommon_r10; |
2675 bIterator = DeserializeSequence (&pdschConfigCommon_r10,false,bIterator)
; | 2675 bIterator = DeserializeSequence (&pdschConfigCommon_r10,false,bIterator)
; |
2676 bIterator = DeserializeInteger (&n,-60,50,bIterator); | 2676 bIterator = DeserializeInteger (&n,-60,50,bIterator); |
2677 rrccsc->nonUlConfiguration.pdschConfigCommon.referenceSignalPower = (int
8_t)n; | 2677 rrccsc->nonUlConfiguration.pdschConfigCommon.referenceSignalPower = stat
ic_cast<int8_t>(n); |
2678 bIterator = DeserializeInteger (&n,0,3,bIterator); | 2678 bIterator = DeserializeInteger (&n,0,3,bIterator); |
2679 rrccsc->nonUlConfiguration.pdschConfigCommon.pb = (int8_t)n; | 2679 rrccsc->nonUlConfiguration.pdschConfigCommon.pb = static_cast<int8_t>(n)
; |
2680 } | 2680 } |
2681 if (rrccsc->haveUlConfiguration) | 2681 if (rrccsc->haveUlConfiguration) |
2682 { | 2682 { |
2683 std::bitset<7> UlConfiguration_r10; | 2683 std::bitset<7> UlConfiguration_r10; |
2684 bIterator = DeserializeSequence (&UlConfiguration_r10,true,bIterator); | 2684 bIterator = DeserializeSequence (&UlConfiguration_r10,true,bIterator); |
2685 ········ | 2685 ········ |
2686 std::bitset<3> FreqInfo_r10; | 2686 std::bitset<3> FreqInfo_r10; |
2687 bIterator = DeserializeSequence (&FreqInfo_r10,false,bIterator); | 2687 bIterator = DeserializeSequence (&FreqInfo_r10,false,bIterator); |
2688 int n; | 2688 int n; |
2689 bIterator = DeserializeInteger (&n,0,MAX_EARFCN,bIterator); | 2689 bIterator = DeserializeInteger (&n,0,MAX_EARFCN,bIterator); |
2690 rrccsc->ulConfiguration.ulFreqInfo.ulCarrierFreq = n; | 2690 rrccsc->ulConfiguration.ulFreqInfo.ulCarrierFreq = n; |
2691 bIterator = DeserializeInteger (&n,6,100,bIterator); | 2691 bIterator = DeserializeInteger (&n,6,100,bIterator); |
2692 rrccsc->ulConfiguration.ulFreqInfo.ulBandwidth = (uint8_t)n; | 2692 rrccsc->ulConfiguration.ulFreqInfo.ulBandwidth = static_cast<int8_t>(n); |
2693 | 2693 |
2694 std::bitset<2> UlPowerControlCommonSCell_r10; | 2694 std::bitset<2> UlPowerControlCommonSCell_r10; |
2695 bIterator = DeserializeSequence (&UlPowerControlCommonSCell_r10,false,bI
terator); | 2695 bIterator = DeserializeSequence (&UlPowerControlCommonSCell_r10,false,bI
terator); |
2696 bIterator = DeserializeInteger (&n,0,65536,bIterator); | 2696 bIterator = DeserializeInteger (&n,0,65536,bIterator); |
2697 rrccsc->ulConfiguration.ulPowerControlCommonSCell.alpha = (uint16_t)n; | 2697 rrccsc->ulConfiguration.ulPowerControlCommonSCell.alpha = static_cast<ui
nt16_t>(n); |
2698 ········· | 2698 ········· |
2699 std::bitset<1> prachConfigSCell_r10; | 2699 std::bitset<1> prachConfigSCell_r10; |
2700 bIterator = DeserializeSequence (&prachConfigSCell_r10,false,bIterator); | 2700 bIterator = DeserializeSequence (&prachConfigSCell_r10,false,bIterator); |
2701 bIterator = DeserializeInteger (&n,0,256,bIterator); | 2701 bIterator = DeserializeInteger (&n,0,256,bIterator); |
2702 rrccsc->ulConfiguration.prachConfigSCell.index = (uint16_t)n; | 2702 rrccsc->ulConfiguration.prachConfigSCell.index = static_cast<uint16_t>(n
); |
2703 }···· | 2703 }···· |
2704 ···· | 2704 ···· |
2705 return bIterator; | 2705 return bIterator; |
2706 } | 2706 } |
2707 | 2707 |
2708 Buffer::Iterator· | 2708 Buffer::Iterator· |
2709 RrcAsn1Header::DeserializeRadioResourceConfigDedicatedSCell (LteRrcSap::RadioR
esourceConfigDedicatedSCell *rrcdsc, Buffer::Iterator bIterator) | 2709 RrcAsn1Header::DeserializeRadioResourceConfigDedicatedSCell (LteRrcSap::RadioR
esourceConfigDedicatedSCell *rrcdsc, Buffer::Iterator bIterator) |
2710 { | 2710 { |
2711 NS_LOG_FUNCTION (this); | 2711 NS_LOG_FUNCTION (this); |
2712 std::bitset<1> RadioResourceConfigDedicatedSCell_r10; | 2712 std::bitset<1> RadioResourceConfigDedicatedSCell_r10; |
(...skipping 29 matching lines...) Expand all Loading... |
2742 { | 2742 { |
2743 bIterator = DeserializeNull (bIterator); | 2743 bIterator = DeserializeNull (bIterator); |
2744 } | 2744 } |
2745 else if (sel == 0) | 2745 else if (sel == 0) |
2746 { | 2746 { |
2747 std::bitset<1> codebookSubsetRestrictionPresent; | 2747 std::bitset<1> codebookSubsetRestrictionPresent; |
2748 bIterator = DeserializeSequence (&codebookSubsetRestrictionPres
ent,false,bIterator); | 2748 bIterator = DeserializeSequence (&codebookSubsetRestrictionPres
ent,false,bIterator); |
2749 | 2749 |
2750 int txmode; | 2750 int txmode; |
2751 bIterator = DeserializeEnum (8,&txmode,bIterator); | 2751 bIterator = DeserializeEnum (8,&txmode,bIterator); |
2752 pcdsc->antennaInfo.transmissionMode = (uint8_t)txmode; | 2752 pcdsc->antennaInfo.transmissionMode = static_cast<uint8_t>(txmo
de); |
2753 | 2753 |
2754 if (codebookSubsetRestrictionPresent[0]) | 2754 if (codebookSubsetRestrictionPresent[0]) |
2755 { | 2755 { |
2756 // Deserialize codebookSubsetRestriction | 2756 // Deserialize codebookSubsetRestriction |
2757 NS_FATAL_ERROR ("Not implemented yet"); | 2757 NS_FATAL_ERROR ("Not implemented yet"); |
2758 // ... | 2758 // ... |
2759 } | 2759 } |
2760 | 2760 |
2761 int txantennaselchosen; | 2761 int txantennaselchosen; |
2762 bIterator = DeserializeChoice (2,false,&txantennaselchosen,bIte
rator); | 2762 bIterator = DeserializeChoice (2,false,&txantennaselchosen,bIte
rator); |
(...skipping 13 matching lines...) Expand all Loading... |
2776 if (pcdsc->havePdschConfigDedicated) | 2776 if (pcdsc->havePdschConfigDedicated) |
2777 { | 2777 { |
2778 // Deserialize pdsch-ConfigDedicated | 2778 // Deserialize pdsch-ConfigDedicated |
2779 std::bitset<0> bitset0; | 2779 std::bitset<0> bitset0; |
2780 bIterator = DeserializeSequence (&bitset0,false,bIterator); | 2780 bIterator = DeserializeSequence (&bitset0,false,bIterator); |
2781 | 2781 |
2782 int slct; | 2782 int slct; |
2783 | 2783 |
2784 // Deserialize p-a | 2784 // Deserialize p-a |
2785 bIterator = DeserializeEnum (8,&slct,bIterator); | 2785 bIterator = DeserializeEnum (8,&slct,bIterator); |
2786 pcdsc->pdschConfigDedicated.pa = (uint8_t)slct; | 2786 pcdsc->pdschConfigDedicated.pa = static_cast<uint8_t>(slct); |
2787 | 2787 |
2788 bIterator = DeserializeNull (bIterator); | 2788 bIterator = DeserializeNull (bIterator); |
2789 } | 2789 } |
2790 ········ | 2790 ········ |
2791 } | 2791 } |
2792 if (pcdsc->haveUlConfiguration) | 2792 if (pcdsc->haveUlConfiguration) |
2793 { | 2793 { |
2794 std::bitset<7> ulOpt; | 2794 std::bitset<7> ulOpt; |
2795 bIterator = DeserializeSequence (&ulOpt,false,bIterator); | 2795 bIterator = DeserializeSequence (&ulOpt,false,bIterator); |
2796 pcdsc->haveAntennaInfoUlDedicated = ulOpt[6]; | 2796 pcdsc->haveAntennaInfoUlDedicated = ulOpt[6]; |
(...skipping 13 matching lines...) Expand all Loading... |
2810 { | 2810 { |
2811 bIterator = DeserializeNull (bIterator); | 2811 bIterator = DeserializeNull (bIterator); |
2812 } | 2812 } |
2813 else if (sel == 0) | 2813 else if (sel == 0) |
2814 { | 2814 { |
2815 std::bitset<1> codebookSubsetRestrictionPresent; | 2815 std::bitset<1> codebookSubsetRestrictionPresent; |
2816 bIterator = DeserializeSequence (&codebookSubsetRestrictionPres
ent,false,bIterator); | 2816 bIterator = DeserializeSequence (&codebookSubsetRestrictionPres
ent,false,bIterator); |
2817 | 2817 |
2818 int txmode; | 2818 int txmode; |
2819 bIterator = DeserializeEnum (8,&txmode,bIterator); | 2819 bIterator = DeserializeEnum (8,&txmode,bIterator); |
2820 pcdsc->antennaInfo.transmissionMode = (uint8_t)txmode; | 2820 pcdsc->antennaInfo.transmissionMode = static_cast<uint8_t>(txmo
de); |
2821 | 2821 |
2822 if (codebookSubsetRestrictionPresent[0]) | 2822 if (codebookSubsetRestrictionPresent[0]) |
2823 { | 2823 { |
2824 // Deserialize codebookSubsetRestriction | 2824 // Deserialize codebookSubsetRestriction |
2825 NS_FATAL_ERROR ("Not implemented yet"); | 2825 NS_FATAL_ERROR ("Not implemented yet"); |
2826 // ... | 2826 // ... |
2827 } | 2827 } |
2828 | 2828 |
2829 int txantennaselchosen; | 2829 int txantennaselchosen; |
2830 bIterator = DeserializeChoice (2,false,&txantennaselchosen,bIte
rator); | 2830 bIterator = DeserializeChoice (2,false,&txantennaselchosen,bIte
rator); |
(...skipping 27 matching lines...) Expand all Loading... |
2858 { | 2858 { |
2859 pcdsc->soundingRsUlConfigDedicated.type = LteRrcSap::SoundingRs
UlConfigDedicated::SETUP; | 2859 pcdsc->soundingRsUlConfigDedicated.type = LteRrcSap::SoundingRs
UlConfigDedicated::SETUP; |
2860 | 2860 |
2861 std::bitset<0> bitset0; | 2861 std::bitset<0> bitset0; |
2862 bIterator = DeserializeSequence (&bitset0,false,bIterator); | 2862 bIterator = DeserializeSequence (&bitset0,false,bIterator); |
2863 | 2863 |
2864 int slct; | 2864 int slct; |
2865 | 2865 |
2866 // Deserialize srs-Bandwidth | 2866 // Deserialize srs-Bandwidth |
2867 bIterator = DeserializeEnum (4,&slct,bIterator); | 2867 bIterator = DeserializeEnum (4,&slct,bIterator); |
2868 pcdsc->soundingRsUlConfigDedicated.srsBandwidth = (uint8_t)slct
; | 2868 pcdsc->soundingRsUlConfigDedicated.srsBandwidth = static_cast<u
int8_t>(slct); |
2869 | 2869 |
2870 // Deserialize srs-HoppingBandwidth | 2870 // Deserialize srs-HoppingBandwidth |
2871 bIterator = DeserializeEnum (4,&slct,bIterator); | 2871 bIterator = DeserializeEnum (4,&slct,bIterator); |
2872 | 2872 |
2873 // Deserialize freqDomainPosition | 2873 // Deserialize freqDomainPosition |
2874 bIterator = DeserializeInteger (&slct,0,23,bIterator); | 2874 bIterator = DeserializeInteger (&slct,0,23,bIterator); |
2875 | 2875 |
2876 // Deserialize duration | 2876 // Deserialize duration |
2877 bool duration; | 2877 bool duration; |
2878 bIterator = DeserializeBoolean (&duration,bIterator); | 2878 bIterator = DeserializeBoolean (&duration,bIterator); |
2879 | 2879 |
2880 // Deserialize srs-ConfigIndex | 2880 // Deserialize srs-ConfigIndex |
2881 bIterator = DeserializeInteger (&slct,0,1023,bIterator); | 2881 bIterator = DeserializeInteger (&slct,0,1023,bIterator); |
2882 pcdsc->soundingRsUlConfigDedicated.srsConfigIndex = (uint16_t)s
lct; | 2882 pcdsc->soundingRsUlConfigDedicated.srsConfigIndex = static_cast
<uint16_t>(slct); |
2883 | 2883 |
2884 // Deserialize transmissionComb | 2884 // Deserialize transmissionComb |
2885 bIterator = DeserializeInteger (&slct,0,1,bIterator); | 2885 bIterator = DeserializeInteger (&slct,0,1,bIterator); |
2886 | 2886 |
2887 // Deserialize cyclicShift | 2887 // Deserialize cyclicShift |
2888 bIterator = DeserializeEnum (8,&slct,bIterator); | 2888 bIterator = DeserializeEnum (8,&slct,bIterator); |
2889 } | 2889 } |
2890 } | 2890 } |
2891 | 2891 |
2892 | 2892 |
(...skipping 426 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
3319 case 14: | 3319 case 14: |
3320 rachConfigCommon->preambleInfo.numberOfRaPreambles = 60; | 3320 rachConfigCommon->preambleInfo.numberOfRaPreambles = 60; |
3321 break; | 3321 break; |
3322 case 15: | 3322 case 15: |
3323 rachConfigCommon->preambleInfo.numberOfRaPreambles = 64; | 3323 rachConfigCommon->preambleInfo.numberOfRaPreambles = 64; |
3324 break; | 3324 break; |
3325 default: | 3325 default: |
3326 rachConfigCommon->preambleInfo.numberOfRaPreambles = 0; | 3326 rachConfigCommon->preambleInfo.numberOfRaPreambles = 0; |
3327 } | 3327 } |
3328 | 3328 |
3329 rachConfigCommon->preambleInfo.numberOfRaPreambles = (uint8_t)n; | 3329 rachConfigCommon->preambleInfo.numberOfRaPreambles = static_cast<uint8_t>(n); |
3330 | 3330 |
3331 if (preamblesGroupAConfigPresent[0]) | 3331 if (preamblesGroupAConfigPresent[0]) |
3332 { | 3332 { |
3333 // Deserialize preamblesGroupAConfig | 3333 // Deserialize preamblesGroupAConfig |
3334 // ... | 3334 // ... |
3335 } | 3335 } |
3336 | 3336 |
3337 // powerRampingParameters | 3337 // powerRampingParameters |
3338 bIterator = DeserializeSequence (&bitset0,false,bIterator); | 3338 bIterator = DeserializeSequence (&bitset0,false,bIterator); |
3339 bIterator = DeserializeEnum (4,&n,bIterator); // powerRampingStep | 3339 bIterator = DeserializeEnum (4,&n,bIterator); // powerRampingStep |
(...skipping 191 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
3531 RrcAsn1Header::DeserializeMeasResults (LteRrcSap::MeasResults *measResults, Buff
er::Iterator bIterator) | 3531 RrcAsn1Header::DeserializeMeasResults (LteRrcSap::MeasResults *measResults, Buff
er::Iterator bIterator) |
3532 { | 3532 { |
3533 int n; | 3533 int n; |
3534 std::bitset<0> b0; | 3534 std::bitset<0> b0; |
3535 std::bitset<4> measResultOptionalPresent; | 3535 std::bitset<4> measResultOptionalPresent; |
3536 // bIterator = DeserializeSequence (&measResultNeighCellsPresent,true,bIter
ator); | 3536 // bIterator = DeserializeSequence (&measResultNeighCellsPresent,true,bIter
ator); |
3537 bIterator = DeserializeSequence (&measResultOptionalPresent,true,bIterator); | 3537 bIterator = DeserializeSequence (&measResultOptionalPresent,true,bIterator); |
3538 | 3538 |
3539 // Deserialize measId | 3539 // Deserialize measId |
3540 bIterator = DeserializeInteger (&n, 1, MAX_MEAS_ID, bIterator); | 3540 bIterator = DeserializeInteger (&n, 1, MAX_MEAS_ID, bIterator); |
3541 measResults->measId = (uint8_t)n; | 3541 measResults->measId = static_cast<uint8_t>(n); |
3542 | 3542 |
3543 // Deserialize measResultServCell | 3543 // Deserialize measResultServCell |
3544 bIterator = DeserializeSequence (&b0,false,bIterator); | 3544 bIterator = DeserializeSequence (&b0,false,bIterator); |
3545 | 3545 |
3546 // Deserialize rsrpResult | 3546 // Deserialize rsrpResult |
3547 bIterator = DeserializeInteger (&n, 0, 97, bIterator); | 3547 bIterator = DeserializeInteger (&n, 0, 97, bIterator); |
3548 measResults->rsrpResult = (uint8_t)n; | 3548 measResults->rsrpResult = static_cast<uint8_t>(n); |
3549 | 3549 |
3550 // Deserialize rsrqResult | 3550 // Deserialize rsrqResult |
3551 bIterator = DeserializeInteger (&n, 0, 34, bIterator); | 3551 bIterator = DeserializeInteger (&n, 0, 34, bIterator); |
3552 measResults->rsrqResult = (uint8_t)n; | 3552 measResults->rsrqResult = static_cast<uint8_t>(n); |
3553 | 3553 |
3554 measResults->haveMeasResultNeighCells = measResultOptionalPresent[0]; | 3554 measResults->haveMeasResultNeighCells = measResultOptionalPresent[0]; |
3555 measResults->haveScellsMeas = measResultOptionalPresent[3]; | 3555 measResults->haveScellsMeas = measResultOptionalPresent[3]; |
3556 if ( measResults->haveMeasResultNeighCells) | 3556 if ( measResults->haveMeasResultNeighCells) |
3557 { | 3557 { |
3558 int measResultNeighCellsChoice; | 3558 int measResultNeighCellsChoice; |
3559 | 3559 |
3560 // Deserialize measResultNeighCells | 3560 // Deserialize measResultNeighCells |
3561 bIterator = DeserializeChoice (4,false,&measResultNeighCellsChoice,bIterat
or); | 3561 bIterator = DeserializeChoice (4,false,&measResultNeighCellsChoice,bIterat
or); |
3562 | 3562 |
3563 if (measResultNeighCellsChoice == 0) | 3563 if (measResultNeighCellsChoice == 0) |
3564 { | 3564 { |
3565 // Deserialize measResultListEUTRA | 3565 // Deserialize measResultListEUTRA |
3566 int numElems; | 3566 int numElems; |
3567 bIterator = DeserializeSequenceOf (&numElems,MAX_CELL_REPORT,1,bIterat
or); | 3567 bIterator = DeserializeSequenceOf (&numElems,MAX_CELL_REPORT,1,bIterat
or); |
3568 | 3568 |
3569 for (int i = 0; i < numElems; i++) | 3569 for (int i = 0; i < numElems; i++) |
3570 { | 3570 { |
3571 LteRrcSap::MeasResultEutra measResultEutra; | 3571 LteRrcSap::MeasResultEutra measResultEutra; |
3572 | 3572 |
3573 std::bitset<1> isCgiInfoPresent; | 3573 std::bitset<1> isCgiInfoPresent; |
3574 bIterator = DeserializeSequence (&isCgiInfoPresent,false,bIterator
); | 3574 bIterator = DeserializeSequence (&isCgiInfoPresent,false,bIterator
); |
3575 | 3575 |
3576 // PhysCellId | 3576 // PhysCellId |
3577 bIterator = DeserializeInteger (&n,0,503,bIterator); | 3577 bIterator = DeserializeInteger (&n,0,503,bIterator); |
3578 measResultEutra.physCellId = (uint16_t)n; | 3578 measResultEutra.physCellId = static_cast<uint16_t>(n); |
3579 | 3579 |
3580 measResultEutra.haveCgiInfo = isCgiInfoPresent[0]; | 3580 measResultEutra.haveCgiInfo = isCgiInfoPresent[0]; |
3581 if (isCgiInfoPresent[0]) | 3581 if (isCgiInfoPresent[0]) |
3582 { | 3582 { |
3583 std::bitset<1> havePlmnIdentityList; | 3583 std::bitset<1> havePlmnIdentityList; |
3584 bIterator = DeserializeSequence (&havePlmnIdentityList,false,b
Iterator); | 3584 bIterator = DeserializeSequence (&havePlmnIdentityList,false,b
Iterator); |
3585 | 3585 |
3586 // Deserialize cellGlobalId | 3586 // Deserialize cellGlobalId |
3587 bIterator = DeserializeSequence (&b0,false,bIterator); | 3587 bIterator = DeserializeSequence (&b0,false,bIterator); |
3588 | 3588 |
3589 // Deserialize plmn-Identity | 3589 // Deserialize plmn-Identity |
3590 bIterator = DeserializePlmnIdentity (&measResultEutra.cgiInfo.
plmnIdentity,bIterator); | 3590 bIterator = DeserializePlmnIdentity (&measResultEutra.cgiInfo.
plmnIdentity,bIterator); |
3591 | 3591 |
3592 // Deserialize CellIdentity | 3592 // Deserialize CellIdentity |
3593 std::bitset<28> cellId; | 3593 std::bitset<28> cellId; |
3594 bIterator = DeserializeBitstring (&cellId,bIterator); | 3594 bIterator = DeserializeBitstring (&cellId,bIterator); |
3595 measResultEutra.cgiInfo.cellIdentity = cellId.to_ulong (); | 3595 measResultEutra.cgiInfo.cellIdentity = cellId.to_ulong (); |
3596 | 3596 |
3597 // Deserialize trackingAreaCode | 3597 // Deserialize trackingAreaCode |
3598 std::bitset<16> trArCo; | 3598 std::bitset<16> trArCo; |
3599 bIterator = DeserializeBitstring (&trArCo,bIterator); | 3599 bIterator = DeserializeBitstring (&trArCo,bIterator); |
3600 measResultEutra.cgiInfo.trackingAreaCode = (uint16_t)trArCo.to
_ulong (); | 3600 measResultEutra.cgiInfo.trackingAreaCode = static_cast<uint16_
t>(trArCo.to_ulong ()); |
3601 | 3601 |
3602 // Deserialize plmn-IdentityList | 3602 // Deserialize plmn-IdentityList |
3603 if (havePlmnIdentityList[0]) | 3603 if (havePlmnIdentityList[0]) |
3604 { | 3604 { |
3605 int numPlmnElems; | 3605 int numPlmnElems; |
3606 bIterator = DeserializeSequenceOf (&numPlmnElems, 5, 1, bI
terator); | 3606 bIterator = DeserializeSequenceOf (&numPlmnElems, 5, 1, bI
terator); |
3607 | 3607 |
3608 for ( int j = 0; j < numPlmnElems; j++) | 3608 for ( int j = 0; j < numPlmnElems; j++) |
3609 { | 3609 { |
3610 uint32_t plmnId; | 3610 uint32_t plmnId; |
3611 bIterator = DeserializePlmnIdentity (&plmnId,bIterator
); | 3611 bIterator = DeserializePlmnIdentity (&plmnId,bIterator
); |
3612 measResultEutra.cgiInfo.plmnIdentityList.push_back (pl
mnId); | 3612 measResultEutra.cgiInfo.plmnIdentityList.push_back (pl
mnId); |
3613 } | 3613 } |
3614 } | 3614 } |
3615 } | 3615 } |
3616 | 3616 |
3617 // Deserialize measResult | 3617 // Deserialize measResult |
3618 std::bitset<2> measResultOpts; | 3618 std::bitset<2> measResultOpts; |
3619 bIterator = DeserializeSequence (&measResultOpts, true, bIterator)
; | 3619 bIterator = DeserializeSequence (&measResultOpts, true, bIterator)
; |
3620 | 3620 |
3621 measResultEutra.haveRsrpResult = measResultOpts[1]; | 3621 measResultEutra.haveRsrpResult = measResultOpts[1]; |
3622 if (measResultOpts[1]) | 3622 if (measResultOpts[1]) |
3623 { | 3623 { |
3624 // Deserialize rsrpResult | 3624 // Deserialize rsrpResult |
3625 bIterator = DeserializeInteger (&n,0,97,bIterator); | 3625 bIterator = DeserializeInteger (&n,0,97,bIterator); |
3626 measResultEutra.rsrpResult = (uint8_t)n; | 3626 measResultEutra.rsrpResult = static_cast<uint8_t>(n); |
3627 } | 3627 } |
3628 | 3628 |
3629 measResultEutra.haveRsrqResult = measResultOpts[0]; | 3629 measResultEutra.haveRsrqResult = measResultOpts[0]; |
3630 if (measResultOpts[0]) | 3630 if (measResultOpts[0]) |
3631 { | 3631 { |
3632 // Deserialize rsrqResult | 3632 // Deserialize rsrqResult |
3633 bIterator = DeserializeInteger (&n,0,34,bIterator); | 3633 bIterator = DeserializeInteger (&n,0,34,bIterator); |
3634 measResultEutra.rsrqResult = (uint8_t)n; | 3634 measResultEutra.rsrqResult = static_cast<uint8_t>(n); |
3635 } | 3635 } |
3636 | 3636 |
3637 measResults->measResultListEutra.push_back (measResultEutra); | 3637 measResults->measResultListEutra.push_back (measResultEutra); |
3638 } | 3638 } |
3639 } | 3639 } |
3640 | 3640 |
3641 if (measResultNeighCellsChoice == 1) | 3641 if (measResultNeighCellsChoice == 1) |
3642 { | 3642 { |
3643 // Deserialize measResultListUTRA | 3643 // Deserialize measResultListUTRA |
3644 // ... | 3644 // ... |
(...skipping 14 matching lines...) Expand all Loading... |
3659 { | 3659 { |
3660 | 3660 |
3661 int numElems; | 3661 int numElems; |
3662 bIterator = DeserializeSequenceOf (&numElems,MAX_SCELL_REPORT,1,bIterato
r); | 3662 bIterator = DeserializeSequenceOf (&numElems,MAX_SCELL_REPORT,1,bIterato
r); |
3663 for (int i = 0; i < numElems; i++) | 3663 for (int i = 0; i < numElems; i++) |
3664 { | 3664 { |
3665 LteRrcSap::MeasResultScell measResultScell; | 3665 LteRrcSap::MeasResultScell measResultScell; |
3666 int measScellId; | 3666 int measScellId; |
3667 // Deserialize measId | 3667 // Deserialize measId |
3668 bIterator = DeserializeInteger (&measScellId, 1,MAX_SCELL_REPORT,bIt
erator); | 3668 bIterator = DeserializeInteger (&measScellId, 1,MAX_SCELL_REPORT,bIt
erator); |
3669 measResultScell.servFreqId = (uint16_t)measScellId; | 3669 measResultScell.servFreqId = static_cast<uint16_t>(measScellId); |
3670 std::bitset<2> measResultScellPresent; | 3670 std::bitset<2> measResultScellPresent; |
3671 bIterator = DeserializeSequence (&measResultScellPresent,true,bItera
tor); | 3671 bIterator = DeserializeSequence (&measResultScellPresent,true,bItera
tor); |
3672 measResults->measScellResultList.haveMeasurementResultsServingSCells
= measResultScellPresent[0]; | 3672 measResults->measScellResultList.haveMeasurementResultsServingSCells
= measResultScellPresent[0]; |
3673 measResults->measScellResultList.haveMeasurementResultsNeighCell = me
asResultScellPresent[1]; | 3673 measResults->measScellResultList.haveMeasurementResultsNeighCell = me
asResultScellPresent[1]; |
3674 if (measResults->measScellResultList.haveMeasurementResultsServingSCe
lls) | 3674 if (measResults->measScellResultList.haveMeasurementResultsServingSCe
lls) |
3675 { | 3675 { |
3676 // Deserialize measResult | 3676 // Deserialize measResult |
3677 std::bitset<2> measResultOpts; | 3677 std::bitset<2> measResultOpts; |
3678 bIterator = DeserializeSequence (&measResultOpts, true, bIterator
); | 3678 bIterator = DeserializeSequence (&measResultOpts, true, bIterator
); |
3679 | 3679 |
3680 measResultScell.haveRsrpResult = measResultOpts[1]; | 3680 measResultScell.haveRsrpResult = measResultOpts[1]; |
3681 if (measResultOpts[1]) | 3681 if (measResultOpts[1]) |
3682 { | 3682 { |
3683 // Deserialize rsrpResult | 3683 // Deserialize rsrpResult |
3684 bIterator = DeserializeInteger (&n,0,97,bIterator); | 3684 bIterator = DeserializeInteger (&n,0,97,bIterator); |
3685 measResultScell.rsrpResult = (uint8_t)n; | 3685 measResultScell.rsrpResult = static_cast<uint8_t>(n); |
3686 } | 3686 } |
3687 | 3687 |
3688 measResultScell.haveRsrqResult = measResultOpts[0]; | 3688 measResultScell.haveRsrqResult = measResultOpts[0]; |
3689 if (measResultOpts[0]) | 3689 if (measResultOpts[0]) |
3690 { | 3690 { |
3691 // Deserialize rsrqResult | 3691 // Deserialize rsrqResult |
3692 bIterator = DeserializeInteger (&n,0,34,bIterator); | 3692 bIterator = DeserializeInteger (&n,0,34,bIterator); |
3693 measResultScell.rsrqResult = (uint8_t)n; | 3693 measResultScell.rsrqResult = static_cast<uint8_t>(n); |
3694 } | 3694 } |
3695 } | 3695 } |
3696 if (measResults->measScellResultList.haveMeasurementResultsNeighCell) | 3696 if (measResults->measScellResultList.haveMeasurementResultsNeighCell) |
3697 { | 3697 { |
3698 // Deserialize measResultBestNeighCell | 3698 // Deserialize measResultBestNeighCell |
3699 } | 3699 } |
3700 measResults->measScellResultList.measResultScell.push_back (measResul
tScell); | 3700 measResults->measScellResultList.measResultScell.push_back (measResul
tScell); |
3701 } | 3701 } |
3702 ········ | 3702 ········ |
3703 } | 3703 } |
(...skipping 14 matching lines...) Expand all Loading... |
3718 } | 3718 } |
3719 | 3719 |
3720 // Deserialize mnc | 3720 // Deserialize mnc |
3721 int mncDigits; | 3721 int mncDigits; |
3722 int mnc = 0; | 3722 int mnc = 0; |
3723 bIterator = DeserializeSequenceOf (&mncDigits,3,2,bIterator); | 3723 bIterator = DeserializeSequenceOf (&mncDigits,3,2,bIterator); |
3724 | 3724 |
3725 for (int j = mncDigits - 1; j >= 0; j--) | 3725 for (int j = mncDigits - 1; j >= 0; j--) |
3726 { | 3726 { |
3727 bIterator = DeserializeInteger (&n,0,9,bIterator); | 3727 bIterator = DeserializeInteger (&n,0,9,bIterator); |
3728 mnc += (int)(n * pow (10,j)); | 3728 mnc += static_cast<int>(n * pow (10,j)); |
3729 } | 3729 } |
3730 | 3730 |
3731 *plmnId = mnc; | 3731 *plmnId = mnc; |
3732 | 3732 |
3733 // cellReservedForOperatorUse | 3733 // cellReservedForOperatorUse |
3734 bIterator = DeserializeEnum (2,&n,bIterator); | 3734 bIterator = DeserializeEnum (2,&n,bIterator); |
3735 return bIterator; | 3735 return bIterator; |
3736 } | 3736 } |
3737 | 3737 |
3738 Buffer::Iterator | 3738 Buffer::Iterator |
3739 RrcAsn1Header::DeserializeMeasConfig (LteRrcSap::MeasConfig * measConfig, Buffer
::Iterator bIterator) | 3739 RrcAsn1Header::DeserializeMeasConfig (LteRrcSap::MeasConfig * measConfig, Buffer
::Iterator bIterator) |
3740 { | 3740 { |
3741 std::bitset<0> bitset0; | 3741 std::bitset<0> bitset0; |
3742 std::bitset<2> bitset2; | 3742 std::bitset<2> bitset2; |
3743 std::bitset<11> bitset11; | 3743 std::bitset<11> bitset11; |
3744 int n; | 3744 int n; |
3745 | 3745 |
3746 // measConfig | 3746 // measConfig |
3747 bIterator = DeserializeSequence (&bitset11,true,bIterator); | 3747 bIterator = DeserializeSequence (&bitset11,true,bIterator); |
3748 | 3748 |
3749 if (bitset11[10]) | 3749 if (bitset11[10]) |
3750 { | 3750 { |
3751 // measObjectToRemoveList | 3751 // measObjectToRemoveList |
3752 int measObjectToRemoveListElems; | 3752 int measObjectToRemoveListElems; |
3753 bIterator = DeserializeSequenceOf (&measObjectToRemoveListElems, MAX_OBJEC
T_ID, 1, bIterator); | 3753 bIterator = DeserializeSequenceOf (&measObjectToRemoveListElems, MAX_OBJEC
T_ID, 1, bIterator); |
3754 | 3754 |
3755 for (int i = 0; i < measObjectToRemoveListElems; i++) | 3755 for (int i = 0; i < measObjectToRemoveListElems; i++) |
3756 { | 3756 { |
3757 bIterator = DeserializeInteger (&n, 1, MAX_OBJECT_ID, bIterator); | 3757 bIterator = DeserializeInteger (&n, 1, MAX_OBJECT_ID, bIterator); |
3758 measConfig->measObjectToRemoveList.push_back ((uint8_t)n); | 3758 measConfig->measObjectToRemoveList.push_back (static_cast<uint8_t>(n))
; |
3759 } | 3759 } |
3760 } | 3760 } |
3761 | 3761 |
3762 if (bitset11[9]) | 3762 if (bitset11[9]) |
3763 { | 3763 { |
3764 // measObjectToAddModList | 3764 // measObjectToAddModList |
3765 int measObjectToAddModListElems; | 3765 int measObjectToAddModListElems; |
3766 bIterator = DeserializeSequenceOf (&measObjectToAddModListElems, MAX_OBJEC
T_ID, 1, bIterator); | 3766 bIterator = DeserializeSequenceOf (&measObjectToAddModListElems, MAX_OBJEC
T_ID, 1, bIterator); |
3767 | 3767 |
3768 for (int i = 0; i < measObjectToAddModListElems; i++) | 3768 for (int i = 0; i < measObjectToAddModListElems; i++) |
3769 { | 3769 { |
3770 LteRrcSap::MeasObjectToAddMod elem; | 3770 LteRrcSap::MeasObjectToAddMod elem; |
3771 | 3771 |
3772 bIterator = DeserializeSequence (&bitset0, false, bIterator); | 3772 bIterator = DeserializeSequence (&bitset0, false, bIterator); |
3773 | 3773 |
3774 bIterator = DeserializeInteger (&n, 1, MAX_OBJECT_ID, bIterator); | 3774 bIterator = DeserializeInteger (&n, 1, MAX_OBJECT_ID, bIterator); |
3775 elem.measObjectId = (uint8_t)n; | 3775 elem.measObjectId = static_cast<uint8_t>(n); |
3776 | 3776 |
3777 int measObjectChoice; | 3777 int measObjectChoice; |
3778 bIterator = DeserializeChoice (4, true, &measObjectChoice, bIterator); | 3778 bIterator = DeserializeChoice (4, true, &measObjectChoice, bIterator); |
3779 | 3779 |
3780 switch (measObjectChoice) | 3780 switch (measObjectChoice) |
3781 { | 3781 { |
3782 case 1: | 3782 case 1: |
3783 // Deserialize measObjectUTRA | 3783 // Deserialize measObjectUTRA |
3784 // ... | 3784 // ... |
3785 break; | 3785 break; |
(...skipping 41 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
3827 default: | 3827 default: |
3828 elem.measObjectEutra.allowedMeasBandwidth = 100; | 3828 elem.measObjectEutra.allowedMeasBandwidth = 100; |
3829 break; | 3829 break; |
3830 } | 3830 } |
3831 | 3831 |
3832 // presenceAntennaPort1 | 3832 // presenceAntennaPort1 |
3833 bIterator = DeserializeBoolean (&elem.measObjectEutra.presenceAnte
nnaPort1, bIterator); | 3833 bIterator = DeserializeBoolean (&elem.measObjectEutra.presenceAnte
nnaPort1, bIterator); |
3834 | 3834 |
3835 // neighCellConfig | 3835 // neighCellConfig |
3836 bIterator = DeserializeBitstring (&bitset2, bIterator); | 3836 bIterator = DeserializeBitstring (&bitset2, bIterator); |
3837 elem.measObjectEutra.neighCellConfig = (uint8_t)bitset2.to_ulong (
); | 3837 elem.measObjectEutra.neighCellConfig = static_cast<uint8_t>(bitset
2.to_ulong ()); |
3838 | 3838 |
3839 // offsetFreq | 3839 // offsetFreq |
3840 bIterator = DeserializeQoffsetRange (&elem.measObjectEutra.offsetF
req, bIterator); | 3840 bIterator = DeserializeQoffsetRange (&elem.measObjectEutra.offsetF
req, bIterator); |
3841 | 3841 |
3842 if (measObjectEutraOpts[4]) | 3842 if (measObjectEutraOpts[4]) |
3843 { | 3843 { |
3844 // cellsToRemoveList | 3844 // cellsToRemoveList |
3845 int numElems; | 3845 int numElems; |
3846 bIterator = DeserializeSequenceOf (&numElems, MAX_CELL_MEAS, 1
, bIterator); | 3846 bIterator = DeserializeSequenceOf (&numElems, MAX_CELL_MEAS, 1
, bIterator); |
3847 | 3847 |
3848 for (int j = 0; j < numElems; j++) | 3848 for (int j = 0; j < numElems; j++) |
3849 { | 3849 { |
3850 bIterator = DeserializeInteger (&n, 1, MAX_CELL_MEAS, bIte
rator); | 3850 bIterator = DeserializeInteger (&n, 1, MAX_CELL_MEAS, bIte
rator); |
3851 elem.measObjectEutra.cellsToRemoveList.push_back ((uint8_t
)n); | 3851 elem.measObjectEutra.cellsToRemoveList.push_back (static_c
ast<uint8_t>(n)); |
3852 } | 3852 } |
3853 } | 3853 } |
3854 | 3854 |
3855 if (measObjectEutraOpts[3]) | 3855 if (measObjectEutraOpts[3]) |
3856 { | 3856 { |
3857 // cellsToAddModList | 3857 // cellsToAddModList |
3858 int numElems; | 3858 int numElems; |
3859 bIterator = DeserializeSequenceOf (&numElems, MAX_CELL_MEAS, 1
, bIterator); | 3859 bIterator = DeserializeSequenceOf (&numElems, MAX_CELL_MEAS, 1
, bIterator); |
3860 | 3860 |
3861 for (int j = 0; j < numElems; j++) | 3861 for (int j = 0; j < numElems; j++) |
3862 { | 3862 { |
3863 LteRrcSap::CellsToAddMod cellsToAddMod; | 3863 LteRrcSap::CellsToAddMod cellsToAddMod; |
3864 | 3864 |
3865 bIterator = DeserializeSequence (&bitset0, false, bIterato
r); | 3865 bIterator = DeserializeSequence (&bitset0, false, bIterato
r); |
3866 | 3866 |
3867 // cellIndex | 3867 // cellIndex |
3868 bIterator = DeserializeInteger (&n, 1, MAX_CELL_MEAS, bIte
rator); | 3868 bIterator = DeserializeInteger (&n, 1, MAX_CELL_MEAS, bIte
rator); |
3869 cellsToAddMod.cellIndex = (uint8_t)n; | 3869 cellsToAddMod.cellIndex = static_cast<uint8_t>(n); |
3870 | 3870 |
3871 // PhysCellId | 3871 // PhysCellId |
3872 bIterator = DeserializeInteger (&n, 0, 503, bIterator); | 3872 bIterator = DeserializeInteger (&n, 0, 503, bIterator); |
3873 cellsToAddMod.physCellId = (uint16_t)n; | 3873 cellsToAddMod.physCellId = static_cast<uint16_t>(n); |
3874 | 3874 |
3875 // cellIndividualOffset | 3875 // cellIndividualOffset |
3876 bIterator = DeserializeQoffsetRange ( &cellsToAddMod.cellI
ndividualOffset, bIterator); | 3876 bIterator = DeserializeQoffsetRange ( &cellsToAddMod.cellI
ndividualOffset, bIterator); |
3877 | 3877 |
3878 elem.measObjectEutra.cellsToAddModList.push_back (cellsToA
ddMod); | 3878 elem.measObjectEutra.cellsToAddModList.push_back (cellsToA
ddMod); |
3879 } | 3879 } |
3880 } | 3880 } |
3881 | 3881 |
3882 if (measObjectEutraOpts[2]) | 3882 if (measObjectEutraOpts[2]) |
3883 { | 3883 { |
3884 // blackCellsToRemoveList | 3884 // blackCellsToRemoveList |
3885 int numElems; | 3885 int numElems; |
3886 bIterator = DeserializeSequenceOf (&numElems, MAX_CELL_MEAS, 1
, bIterator); | 3886 bIterator = DeserializeSequenceOf (&numElems, MAX_CELL_MEAS, 1
, bIterator); |
3887 | 3887 |
3888 for (int j = 0; j < numElems; j++) | 3888 for (int j = 0; j < numElems; j++) |
3889 { | 3889 { |
3890 bIterator = DeserializeInteger (&n, 1, MAX_CELL_MEAS, bIte
rator); | 3890 bIterator = DeserializeInteger (&n, 1, MAX_CELL_MEAS, bIte
rator); |
3891 elem.measObjectEutra.blackCellsToRemoveList.push_back ((ui
nt8_t)n); | 3891 elem.measObjectEutra.blackCellsToRemoveList.push_back (sta
tic_cast<uint8_t>(n)); |
3892 } | 3892 } |
3893 } | 3893 } |
3894 | 3894 |
3895 | 3895 |
3896 if (measObjectEutraOpts[1]) | 3896 if (measObjectEutraOpts[1]) |
3897 { | 3897 { |
3898 // blackCellsToAddModList | 3898 // blackCellsToAddModList |
3899 int numElems; | 3899 int numElems; |
3900 bIterator = DeserializeSequenceOf (&numElems, MAX_CELL_MEAS, 1
, bIterator); | 3900 bIterator = DeserializeSequenceOf (&numElems, MAX_CELL_MEAS, 1
, bIterator); |
3901 | 3901 |
3902 for (int j = 0; j < numElems; j++) | 3902 for (int j = 0; j < numElems; j++) |
3903 { | 3903 { |
3904 LteRrcSap::BlackCellsToAddMod blackCellsToAddMod; | 3904 LteRrcSap::BlackCellsToAddMod blackCellsToAddMod; |
3905 bIterator = DeserializeSequence (&bitset0, false, bIterato
r); | 3905 bIterator = DeserializeSequence (&bitset0, false, bIterato
r); |
3906 | 3906 |
3907 bIterator = DeserializeInteger (&n, 1, MAX_CELL_MEAS, bIte
rator); | 3907 bIterator = DeserializeInteger (&n, 1, MAX_CELL_MEAS, bIte
rator); |
3908 blackCellsToAddMod.cellIndex = (uint8_t)n; | 3908 blackCellsToAddMod.cellIndex = static_cast<uint8_t>(n); |
3909 | 3909 |
3910 // PhysCellIdRange | 3910 // PhysCellIdRange |
3911 std::bitset<1> isRangePresent; | 3911 std::bitset<1> isRangePresent; |
3912 bIterator = DeserializeSequence (&isRangePresent, false, b
Iterator); | 3912 bIterator = DeserializeSequence (&isRangePresent, false, b
Iterator); |
3913 | 3913 |
3914 // start | 3914 // start |
3915 bIterator = DeserializeInteger (&n, 0, 503, bIterator); | 3915 bIterator = DeserializeInteger (&n, 0, 503, bIterator); |
3916 blackCellsToAddMod.physCellIdRange.start = (uint16_t)n; | 3916 blackCellsToAddMod.physCellIdRange.start = static_cast<uin
t16_t>(n); |
3917 | 3917 |
3918 blackCellsToAddMod.physCellIdRange.haveRange = isRangePres
ent[0]; | 3918 blackCellsToAddMod.physCellIdRange.haveRange = isRangePres
ent[0]; |
3919 // initialize range to silence compiler warning | 3919 // initialize range to silence compiler warning |
3920 blackCellsToAddMod.physCellIdRange.range = 0; | 3920 blackCellsToAddMod.physCellIdRange.range = 0; |
3921 if (blackCellsToAddMod.physCellIdRange.haveRange) | 3921 if (blackCellsToAddMod.physCellIdRange.haveRange) |
3922 { | 3922 { |
3923 // range | 3923 // range |
3924 bIterator = DeserializeEnum (16, &n, bIterator); | 3924 bIterator = DeserializeEnum (16, &n, bIterator); |
3925 switch (n) | 3925 switch (n) |
3926 { | 3926 { |
(...skipping 46 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
3973 | 3973 |
3974 elem.measObjectEutra.blackCellsToAddModList.push_back (bla
ckCellsToAddMod); | 3974 elem.measObjectEutra.blackCellsToAddModList.push_back (bla
ckCellsToAddMod); |
3975 } | 3975 } |
3976 } | 3976 } |
3977 | 3977 |
3978 elem.measObjectEutra.haveCellForWhichToReportCGI = measObjectEutra
Opts[0]; | 3978 elem.measObjectEutra.haveCellForWhichToReportCGI = measObjectEutra
Opts[0]; |
3979 if (measObjectEutraOpts[0]) | 3979 if (measObjectEutraOpts[0]) |
3980 { | 3980 { |
3981 // cellForWhichToReportCGI | 3981 // cellForWhichToReportCGI |
3982 bIterator = DeserializeInteger (&n, 0, 503, bIterator); | 3982 bIterator = DeserializeInteger (&n, 0, 503, bIterator); |
3983 elem.measObjectEutra.cellForWhichToReportCGI = (uint8_t)n; | 3983 elem.measObjectEutra.cellForWhichToReportCGI = static_cast<uin
t8_t>(n); |
3984 } | 3984 } |
3985 } | 3985 } |
3986 measConfig->measObjectToAddModList.push_back (elem); | 3986 measConfig->measObjectToAddModList.push_back (elem); |
3987 } | 3987 } |
3988 } | 3988 } |
3989 | 3989 |
3990 if (bitset11[8]) | 3990 if (bitset11[8]) |
3991 { | 3991 { |
3992 // reportConfigToRemoveList | 3992 // reportConfigToRemoveList |
3993 int reportConfigToRemoveListElems; | 3993 int reportConfigToRemoveListElems; |
3994 bIterator = DeserializeSequenceOf (&reportConfigToRemoveListElems, MAX_REP
ORT_CONFIG_ID, 1, bIterator); | 3994 bIterator = DeserializeSequenceOf (&reportConfigToRemoveListElems, MAX_REP
ORT_CONFIG_ID, 1, bIterator); |
3995 | 3995 |
3996 for (int i = 0; i < reportConfigToRemoveListElems; i++) | 3996 for (int i = 0; i < reportConfigToRemoveListElems; i++) |
3997 { | 3997 { |
3998 bIterator = DeserializeInteger (&n, 1, MAX_REPORT_CONFIG_ID, bIterator
); | 3998 bIterator = DeserializeInteger (&n, 1, MAX_REPORT_CONFIG_ID, bIterator
); |
3999 measConfig->reportConfigToRemoveList.push_back ((uint8_t)n); | 3999 measConfig->reportConfigToRemoveList.push_back (static_cast<uint8_t>(n
)); |
4000 } | 4000 } |
4001 } | 4001 } |
4002 | 4002 |
4003 if (bitset11[7]) | 4003 if (bitset11[7]) |
4004 { | 4004 { |
4005 // reportConfigToAddModList | 4005 // reportConfigToAddModList |
4006 int reportConfigToAddModListElems; | 4006 int reportConfigToAddModListElems; |
4007 bIterator = DeserializeSequenceOf (&reportConfigToAddModListElems, MAX_REP
ORT_CONFIG_ID, 1, bIterator); | 4007 bIterator = DeserializeSequenceOf (&reportConfigToAddModListElems, MAX_REP
ORT_CONFIG_ID, 1, bIterator); |
4008 | 4008 |
4009 for (int i = 0; i < reportConfigToAddModListElems; i++) | 4009 for (int i = 0; i < reportConfigToAddModListElems; i++) |
4010 { | 4010 { |
4011 LteRrcSap::ReportConfigToAddMod elem; | 4011 LteRrcSap::ReportConfigToAddMod elem; |
4012 | 4012 |
4013 bIterator = DeserializeSequence (&bitset0, false, bIterator); | 4013 bIterator = DeserializeSequence (&bitset0, false, bIterator); |
4014 bIterator = DeserializeInteger (&n, 1, MAX_REPORT_CONFIG_ID, bIterator
); | 4014 bIterator = DeserializeInteger (&n, 1, MAX_REPORT_CONFIG_ID, bIterator
); |
4015 elem.reportConfigId = (uint8_t)n; | 4015 elem.reportConfigId = static_cast<uint8_t>(n); |
4016 | 4016 |
4017 // Deserialize reportConfig | 4017 // Deserialize reportConfig |
4018 int reportConfigChoice; | 4018 int reportConfigChoice; |
4019 bIterator = DeserializeChoice (2, false, &reportConfigChoice, bIterato
r); | 4019 bIterator = DeserializeChoice (2, false, &reportConfigChoice, bIterato
r); |
4020 | 4020 |
4021 if (reportConfigChoice == 0) | 4021 if (reportConfigChoice == 0) |
4022 { | 4022 { |
4023 // reportConfigEUTRA | 4023 // reportConfigEUTRA |
4024 bIterator = DeserializeSequence (&bitset0, true, bIterator); | 4024 bIterator = DeserializeSequence (&bitset0, true, bIterator); |
4025 | 4025 |
(...skipping 22 matching lines...) Expand all Loading... |
4048 case 1: | 4048 case 1: |
4049 elem.reportConfigEutra.eventId = LteRrcSap::ReportConfigEu
tra::EVENT_A2; | 4049 elem.reportConfigEutra.eventId = LteRrcSap::ReportConfigEu
tra::EVENT_A2; |
4050 bIterator = DeserializeSequence (&bitset0, false, bIterato
r); | 4050 bIterator = DeserializeSequence (&bitset0, false, bIterato
r); |
4051 bIterator = DeserializeThresholdEutra (&elem.reportConfigE
utra.threshold1, bIterator); | 4051 bIterator = DeserializeThresholdEutra (&elem.reportConfigE
utra.threshold1, bIterator); |
4052 break; | 4052 break; |
4053 | 4053 |
4054 case 2: | 4054 case 2: |
4055 elem.reportConfigEutra.eventId = LteRrcSap::ReportConfigEu
tra::EVENT_A3; | 4055 elem.reportConfigEutra.eventId = LteRrcSap::ReportConfigEu
tra::EVENT_A3; |
4056 bIterator = DeserializeSequence (&bitset0, false, bIterato
r); | 4056 bIterator = DeserializeSequence (&bitset0, false, bIterato
r); |
4057 bIterator = DeserializeInteger (&n, -30, 30, bIterator); | 4057 bIterator = DeserializeInteger (&n, -30, 30, bIterator); |
4058 elem.reportConfigEutra.a3Offset = (int8_t)n; | 4058 elem.reportConfigEutra.a3Offset = static_cast<int8_t>(n); |
4059 bIterator = DeserializeBoolean (&elem.reportConfigEutra.re
portOnLeave, bIterator); | 4059 bIterator = DeserializeBoolean (&elem.reportConfigEutra.re
portOnLeave, bIterator); |
4060 break; | 4060 break; |
4061 | 4061 |
4062 case 3: | 4062 case 3: |
4063 elem.reportConfigEutra.eventId = LteRrcSap::ReportConfigEu
tra::EVENT_A4; | 4063 elem.reportConfigEutra.eventId = LteRrcSap::ReportConfigEu
tra::EVENT_A4; |
4064 bIterator = DeserializeSequence (&bitset0, false, bIterato
r); | 4064 bIterator = DeserializeSequence (&bitset0, false, bIterato
r); |
4065 bIterator = DeserializeThresholdEutra (&elem.reportConfigE
utra.threshold1, bIterator); | 4065 bIterator = DeserializeThresholdEutra (&elem.reportConfigE
utra.threshold1, bIterator); |
4066 break; | 4066 break; |
4067 | 4067 |
4068 case 4: | 4068 case 4: |
4069 default: | 4069 default: |
4070 elem.reportConfigEutra.eventId = LteRrcSap::ReportConfigEu
tra::EVENT_A5; | 4070 elem.reportConfigEutra.eventId = LteRrcSap::ReportConfigEu
tra::EVENT_A5; |
4071 bIterator = DeserializeSequence (&bitset0, false, bIterato
r); | 4071 bIterator = DeserializeSequence (&bitset0, false, bIterato
r); |
4072 bIterator = DeserializeThresholdEutra (&elem.reportConfigE
utra.threshold1, bIterator); | 4072 bIterator = DeserializeThresholdEutra (&elem.reportConfigE
utra.threshold1, bIterator); |
4073 bIterator = DeserializeThresholdEutra (&elem.reportConfigE
utra.threshold2, bIterator); | 4073 bIterator = DeserializeThresholdEutra (&elem.reportConfigE
utra.threshold2, bIterator); |
4074 } | 4074 } |
4075 | 4075 |
4076 bIterator = DeserializeInteger (&n, 0, 30, bIterator); | 4076 bIterator = DeserializeInteger (&n, 0, 30, bIterator); |
4077 elem.reportConfigEutra.hysteresis = (uint8_t)n; | 4077 elem.reportConfigEutra.hysteresis = static_cast<uint8_t>(n); |
4078 | 4078 |
4079 bIterator = DeserializeEnum (16, &n, bIterator); | 4079 bIterator = DeserializeEnum (16, &n, bIterator); |
4080 switch (n) | 4080 switch (n) |
4081 { | 4081 { |
4082 case 0: | 4082 case 0: |
4083 elem.reportConfigEutra.timeToTrigger = 0; | 4083 elem.reportConfigEutra.timeToTrigger = 0; |
4084 break; | 4084 break; |
4085 case 1: | 4085 case 1: |
4086 elem.reportConfigEutra.timeToTrigger = 40; | 4086 elem.reportConfigEutra.timeToTrigger = 40; |
4087 break; | 4087 break; |
(...skipping 77 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
4165 { | 4165 { |
4166 elem.reportConfigEutra.reportQuantity = LteRrcSap::ReportConfi
gEutra::SAME_AS_TRIGGER_QUANTITY; | 4166 elem.reportConfigEutra.reportQuantity = LteRrcSap::ReportConfi
gEutra::SAME_AS_TRIGGER_QUANTITY; |
4167 } | 4167 } |
4168 else | 4168 else |
4169 { | 4169 { |
4170 elem.reportConfigEutra.reportQuantity = LteRrcSap::ReportConfi
gEutra::BOTH; | 4170 elem.reportConfigEutra.reportQuantity = LteRrcSap::ReportConfi
gEutra::BOTH; |
4171 } | 4171 } |
4172 | 4172 |
4173 // maxReportCells | 4173 // maxReportCells |
4174 bIterator = DeserializeInteger (&n, 1, MAX_CELL_REPORT, bIterator)
; | 4174 bIterator = DeserializeInteger (&n, 1, MAX_CELL_REPORT, bIterator)
; |
4175 elem.reportConfigEutra.maxReportCells = (uint8_t)n; | 4175 elem.reportConfigEutra.maxReportCells = static_cast<int8_t>(n); |
4176 | 4176 |
4177 // reportInterval | 4177 // reportInterval |
4178 bIterator = DeserializeEnum (16, &n, bIterator); | 4178 bIterator = DeserializeEnum (16, &n, bIterator); |
4179 switch (n) | 4179 switch (n) |
4180 { | 4180 { |
4181 case 0: | 4181 case 0: |
4182 elem.reportConfigEutra.reportInterval = LteRrcSap::ReportConfi
gEutra::MS120; | 4182 elem.reportConfigEutra.reportInterval = LteRrcSap::ReportConfi
gEutra::MS120; |
4183 break; | 4183 break; |
4184 case 1: | 4184 case 1: |
4185 elem.reportConfigEutra.reportInterval = LteRrcSap::ReportConfi
gEutra::MS240; | 4185 elem.reportConfigEutra.reportInterval = LteRrcSap::ReportConfi
gEutra::MS240; |
(...skipping 84 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
4270 | 4270 |
4271 if (bitset11[6]) | 4271 if (bitset11[6]) |
4272 { | 4272 { |
4273 // measIdToRemoveList | 4273 // measIdToRemoveList |
4274 int measIdToRemoveListElems; | 4274 int measIdToRemoveListElems; |
4275 bIterator = DeserializeSequenceOf (&measIdToRemoveListElems, MAX_MEAS_ID,
1, bIterator); | 4275 bIterator = DeserializeSequenceOf (&measIdToRemoveListElems, MAX_MEAS_ID,
1, bIterator); |
4276 | 4276 |
4277 for (int i = 0; i < measIdToRemoveListElems; i++) | 4277 for (int i = 0; i < measIdToRemoveListElems; i++) |
4278 { | 4278 { |
4279 bIterator = DeserializeInteger (&n, 1, MAX_MEAS_ID, bIterator); | 4279 bIterator = DeserializeInteger (&n, 1, MAX_MEAS_ID, bIterator); |
4280 measConfig->measIdToRemoveList.push_back ((uint8_t)n); | 4280 measConfig->measIdToRemoveList.push_back (static_cast<uint8_t>(n)); |
4281 } | 4281 } |
4282 } | 4282 } |
4283 | 4283 |
4284 if (bitset11[5]) | 4284 if (bitset11[5]) |
4285 { | 4285 { |
4286 // measIdToAddModList | 4286 // measIdToAddModList |
4287 int measIdToAddModListElems; | 4287 int measIdToAddModListElems; |
4288 bIterator = DeserializeSequenceOf (&measIdToAddModListElems, MAX_MEAS_ID,
1, bIterator); | 4288 bIterator = DeserializeSequenceOf (&measIdToAddModListElems, MAX_MEAS_ID,
1, bIterator); |
4289 | 4289 |
4290 for (int i = 0; i < measIdToAddModListElems; i++) | 4290 for (int i = 0; i < measIdToAddModListElems; i++) |
4291 { | 4291 { |
4292 LteRrcSap::MeasIdToAddMod elem; | 4292 LteRrcSap::MeasIdToAddMod elem; |
4293 | 4293 |
4294 bIterator = DeserializeSequence (&bitset0, false, bIterator); | 4294 bIterator = DeserializeSequence (&bitset0, false, bIterator); |
4295 | 4295 |
4296 bIterator = DeserializeInteger (&n, 1, MAX_MEAS_ID, bIterator); | 4296 bIterator = DeserializeInteger (&n, 1, MAX_MEAS_ID, bIterator); |
4297 elem.measId = (uint8_t)n; | 4297 elem.measId = static_cast<uint8_t>(n); |
4298 | 4298 |
4299 bIterator = DeserializeInteger (&n, 1, MAX_OBJECT_ID, bIterator); | 4299 bIterator = DeserializeInteger (&n, 1, MAX_OBJECT_ID, bIterator); |
4300 elem.measObjectId = (uint8_t)n; | 4300 elem.measObjectId = static_cast<uint8_t>(n); |
4301 | 4301 |
4302 bIterator = DeserializeInteger (&n, 1, MAX_REPORT_CONFIG_ID, bIterator
); | 4302 bIterator = DeserializeInteger (&n, 1, MAX_REPORT_CONFIG_ID, bIterator
); |
4303 elem.reportConfigId = (uint8_t)n; | 4303 elem.reportConfigId = static_cast<uint8_t>(n); |
4304 | 4304 |
4305 measConfig->measIdToAddModList.push_back (elem); | 4305 measConfig->measIdToAddModList.push_back (elem); |
4306 } | 4306 } |
4307 } | 4307 } |
4308 | 4308 |
4309 measConfig->haveQuantityConfig = bitset11[4]; | 4309 measConfig->haveQuantityConfig = bitset11[4]; |
4310 if (measConfig->haveQuantityConfig) | 4310 if (measConfig->haveQuantityConfig) |
4311 { | 4311 { |
4312 // quantityConfig | 4312 // quantityConfig |
4313 std::bitset<4> quantityConfigOpts; | 4313 std::bitset<4> quantityConfigOpts; |
(...skipping 146 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
4460 measConfig->measGapConfig.type = LteRrcSap::MeasGapConfig::SETUP; | 4460 measConfig->measGapConfig.type = LteRrcSap::MeasGapConfig::SETUP; |
4461 bIterator = DeserializeSequence (&bitset0, false, bIterator); | 4461 bIterator = DeserializeSequence (&bitset0, false, bIterator); |
4462 | 4462 |
4463 int gapOffsetChoice; | 4463 int gapOffsetChoice; |
4464 bIterator = DeserializeChoice (2, true, &gapOffsetChoice, bIterator); | 4464 bIterator = DeserializeChoice (2, true, &gapOffsetChoice, bIterator); |
4465 switch (gapOffsetChoice) | 4465 switch (gapOffsetChoice) |
4466 { | 4466 { |
4467 case 0: | 4467 case 0: |
4468 measConfig->measGapConfig.gapOffsetChoice = LteRrcSap::MeasGapConf
ig::GP0; | 4468 measConfig->measGapConfig.gapOffsetChoice = LteRrcSap::MeasGapConf
ig::GP0; |
4469 bIterator = DeserializeInteger (&n, 0, 39, bIterator); | 4469 bIterator = DeserializeInteger (&n, 0, 39, bIterator); |
4470 measConfig->measGapConfig.gapOffsetValue = (uint8_t)n; | 4470 measConfig->measGapConfig.gapOffsetValue = static_cast<uint8_t>(n)
; |
4471 break; | 4471 break; |
4472 case 1: | 4472 case 1: |
4473 default: | 4473 default: |
4474 measConfig->measGapConfig.gapOffsetChoice = LteRrcSap::MeasGapConf
ig::GP1; | 4474 measConfig->measGapConfig.gapOffsetChoice = LteRrcSap::MeasGapConf
ig::GP1; |
4475 bIterator = DeserializeInteger (&n, 0, 79, bIterator); | 4475 bIterator = DeserializeInteger (&n, 0, 79, bIterator); |
4476 measConfig->measGapConfig.gapOffsetValue = (uint8_t)n; | 4476 measConfig->measGapConfig.gapOffsetValue = static_cast<uint8_t>(n)
; |
4477 } | 4477 } |
4478 } | 4478 } |
4479 } | 4479 } |
4480 | 4480 |
4481 measConfig->haveSmeasure = bitset11[2]; | 4481 measConfig->haveSmeasure = bitset11[2]; |
4482 if (measConfig->haveSmeasure) | 4482 if (measConfig->haveSmeasure) |
4483 { | 4483 { |
4484 // s-Measure | 4484 // s-Measure |
4485 bIterator = DeserializeInteger (&n, 0, 97, bIterator); | 4485 bIterator = DeserializeInteger (&n, 0, 97, bIterator); |
4486 measConfig->sMeasure = (uint8_t)n; | 4486 measConfig->sMeasure = static_cast<uint8_t>(n); |
4487 } | 4487 } |
4488 | 4488 |
4489 if (bitset11[1]) | 4489 if (bitset11[1]) |
4490 { | 4490 { |
4491 // preRegistrationInfoHRPD | 4491 // preRegistrationInfoHRPD |
4492 // ... | 4492 // ... |
4493 } | 4493 } |
4494 | 4494 |
4495 measConfig->haveSpeedStatePars = bitset11[0]; | 4495 measConfig->haveSpeedStatePars = bitset11[0]; |
4496 if (measConfig->haveSpeedStatePars) | 4496 if (measConfig->haveSpeedStatePars) |
(...skipping 52 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
4549 measConfig->speedStatePars.mobilityStateParameters.tHystNormal = 1
80; | 4549 measConfig->speedStatePars.mobilityStateParameters.tHystNormal = 1
80; |
4550 break; | 4550 break; |
4551 case 4: | 4551 case 4: |
4552 measConfig->speedStatePars.mobilityStateParameters.tHystNormal = 2
40; | 4552 measConfig->speedStatePars.mobilityStateParameters.tHystNormal = 2
40; |
4553 break; | 4553 break; |
4554 default: | 4554 default: |
4555 measConfig->speedStatePars.mobilityStateParameters.tHystNormal = 0
; | 4555 measConfig->speedStatePars.mobilityStateParameters.tHystNormal = 0
; |
4556 } | 4556 } |
4557 | 4557 |
4558 bIterator = DeserializeInteger (&n, 1, 16, bIterator); | 4558 bIterator = DeserializeInteger (&n, 1, 16, bIterator); |
4559 measConfig->speedStatePars.mobilityStateParameters.nCellChangeMedium =
(uint8_t)n; | 4559 measConfig->speedStatePars.mobilityStateParameters.nCellChangeMedium =
static_cast<uint8_t>(n); |
4560 | 4560 |
4561 bIterator = DeserializeInteger (&n, 1, 16, bIterator); | 4561 bIterator = DeserializeInteger (&n, 1, 16, bIterator); |
4562 measConfig->speedStatePars.mobilityStateParameters.nCellChangeHigh = (
uint8_t)n; | 4562 measConfig->speedStatePars.mobilityStateParameters.nCellChangeHigh = s
tatic_cast<uint8_t>(n); |
4563 | 4563 |
4564 // Deserialize timeToTriggerSf | 4564 // Deserialize timeToTriggerSf |
4565 bIterator = DeserializeEnum (4, &n, bIterator); | 4565 bIterator = DeserializeEnum (4, &n, bIterator); |
4566 measConfig->speedStatePars.timeToTriggerSf.sfMedium = (uint8_t)((n + 1
) * 25); | 4566 measConfig->speedStatePars.timeToTriggerSf.sfMedium = static_cast<uint
8_t>((n + 1) * 25); |
4567 bIterator = DeserializeEnum (4, &n, bIterator); | 4567 bIterator = DeserializeEnum (4, &n, bIterator); |
4568 measConfig->speedStatePars.timeToTriggerSf.sfHigh = (uint8_t)((n + 1)
* 25); | 4568 measConfig->speedStatePars.timeToTriggerSf.sfHigh = static_cast<uint8_
t>((n + 1) * 25); |
4569 } | 4569 } |
4570 } | 4570 } |
4571 return bIterator; | 4571 return bIterator; |
4572 } | 4572 } |
4573 //////////////////// RrcConnectionRequest class //////////////////////// | 4573 //////////////////// RrcConnectionRequest class //////////////////////// |
4574 | 4574 |
4575 // Constructor | 4575 // Constructor |
4576 RrcConnectionRequestHeader::RrcConnectionRequestHeader () : RrcUlCcchMessage () | 4576 RrcConnectionRequestHeader::RrcConnectionRequestHeader () : RrcUlCcchMessage () |
4577 { | 4577 { |
4578 m_mmec = std::bitset<8> (0ul); | 4578 m_mmec = std::bitset<8> (0ul); |
(...skipping 206 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
4785 | 4785 |
4786 bIterator = DeserializeDlCcchMessage (bIterator); | 4786 bIterator = DeserializeDlCcchMessage (bIterator); |
4787 | 4787 |
4788 bIterator = DeserializeInteger (&n,0,15,bIterator); | 4788 bIterator = DeserializeInteger (&n,0,15,bIterator); |
4789 | 4789 |
4790 // Deserialize RRCConnectionSetup sequence | 4790 // Deserialize RRCConnectionSetup sequence |
4791 bIterator = DeserializeSequence (&bitset0,false,bIterator); | 4791 bIterator = DeserializeSequence (&bitset0,false,bIterator); |
4792 | 4792 |
4793 // Deserialize rrc-TransactionIdentifier ::=INTEGER (0..3) | 4793 // Deserialize rrc-TransactionIdentifier ::=INTEGER (0..3) |
4794 bIterator = DeserializeInteger (&n,0,3,bIterator); | 4794 bIterator = DeserializeInteger (&n,0,3,bIterator); |
4795 m_rrcTransactionIdentifier = (uint8_t)n; | 4795 m_rrcTransactionIdentifier = static_cast<uint8_t>(n); |
4796 | 4796 |
4797 // Deserialize criticalExtensions choice | 4797 // Deserialize criticalExtensions choice |
4798 int criticalExtensionChoice; | 4798 int criticalExtensionChoice; |
4799 bIterator = DeserializeChoice (2,false,&criticalExtensionChoice,bIterator); | 4799 bIterator = DeserializeChoice (2,false,&criticalExtensionChoice,bIterator); |
4800 if (criticalExtensionChoice == 1) | 4800 if (criticalExtensionChoice == 1) |
4801 { | 4801 { |
4802 // Deserialize criticalExtensionsFuture | 4802 // Deserialize criticalExtensionsFuture |
4803 bIterator = DeserializeSequence (&bitset0,false,bIterator); | 4803 bIterator = DeserializeSequence (&bitset0,false,bIterator); |
4804 } | 4804 } |
4805 else if (criticalExtensionChoice == 0) | 4805 else if (criticalExtensionChoice == 0) |
(...skipping 132 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
4938 RrcConnectionSetupCompleteHeader::Deserialize (Buffer::Iterator bIterator) | 4938 RrcConnectionSetupCompleteHeader::Deserialize (Buffer::Iterator bIterator) |
4939 { | 4939 { |
4940 std::bitset<0> bitset0; | 4940 std::bitset<0> bitset0; |
4941 | 4941 |
4942 bIterator = DeserializeUlDcchMessage (bIterator); | 4942 bIterator = DeserializeUlDcchMessage (bIterator); |
4943 | 4943 |
4944 bIterator = DeserializeSequence (&bitset0,false,bIterator); | 4944 bIterator = DeserializeSequence (&bitset0,false,bIterator); |
4945 | 4945 |
4946 int n; | 4946 int n; |
4947 bIterator = DeserializeInteger (&n,0,3,bIterator); | 4947 bIterator = DeserializeInteger (&n,0,3,bIterator); |
4948 m_rrcTransactionIdentifier = (uint8_t)n; | 4948 m_rrcTransactionIdentifier = static_cast<uint8_t>(n); |
4949 | 4949 |
4950 bIterator = DeserializeChoice (2,false,&n,bIterator); | 4950 bIterator = DeserializeChoice (2,false,&n,bIterator); |
4951 | 4951 |
4952 if (n == 1) | 4952 if (n == 1) |
4953 { | 4953 { |
4954 // Deserialize criticalExtensionsFuture | 4954 // Deserialize criticalExtensionsFuture |
4955 bIterator = DeserializeSequence (&bitset0,false,bIterator); | 4955 bIterator = DeserializeSequence (&bitset0,false,bIterator); |
4956 } | 4956 } |
4957 else if (n == 0) | 4957 else if (n == 0) |
4958 { | 4958 { |
(...skipping 81 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
5040 uint32_t | 5040 uint32_t |
5041 RrcConnectionReconfigurationCompleteHeader::Deserialize (Buffer::Iterator bItera
tor) | 5041 RrcConnectionReconfigurationCompleteHeader::Deserialize (Buffer::Iterator bItera
tor) |
5042 { | 5042 { |
5043 std::bitset<0> bitset0; | 5043 std::bitset<0> bitset0; |
5044 int n; | 5044 int n; |
5045 | 5045 |
5046 bIterator = DeserializeUlDcchMessage (bIterator); | 5046 bIterator = DeserializeUlDcchMessage (bIterator); |
5047 bIterator = DeserializeSequence (&bitset0,false,bIterator); | 5047 bIterator = DeserializeSequence (&bitset0,false,bIterator); |
5048 | 5048 |
5049 bIterator = DeserializeInteger (&n,0,3,bIterator); | 5049 bIterator = DeserializeInteger (&n,0,3,bIterator); |
5050 m_rrcTransactionIdentifier = (uint8_t)n; | 5050 m_rrcTransactionIdentifier = static_cast<uint8_t>(n); |
5051 | 5051 |
5052 bIterator = DeserializeChoice (2,false,&n,bIterator); | 5052 bIterator = DeserializeChoice (2,false,&n,bIterator); |
5053 | 5053 |
5054 if (n == 1) | 5054 if (n == 1) |
5055 { | 5055 { |
5056 // Deserialize criticalExtensionsFuture | 5056 // Deserialize criticalExtensionsFuture |
5057 bIterator = DeserializeSequence (&bitset0,false,bIterator); | 5057 bIterator = DeserializeSequence (&bitset0,false,bIterator); |
5058 } | 5058 } |
5059 else if (n == 0) | 5059 else if (n == 0) |
5060 { | 5060 { |
(...skipping 211 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
5272 std::bitset<0> bitset0; | 5272 std::bitset<0> bitset0; |
5273 | 5273 |
5274 bIterator = DeserializeDlDcchMessage (bIterator); | 5274 bIterator = DeserializeDlDcchMessage (bIterator); |
5275 | 5275 |
5276 // RRCConnectionReconfiguration sequence | 5276 // RRCConnectionReconfiguration sequence |
5277 bIterator = DeserializeSequence (&bitset0,false,bIterator); | 5277 bIterator = DeserializeSequence (&bitset0,false,bIterator); |
5278 | 5278 |
5279 // rrc-TransactionIdentifier | 5279 // rrc-TransactionIdentifier |
5280 int n; | 5280 int n; |
5281 bIterator = DeserializeInteger (&n,0,3,bIterator); | 5281 bIterator = DeserializeInteger (&n,0,3,bIterator); |
5282 m_rrcTransactionIdentifier = (uint8_t)n; | 5282 m_rrcTransactionIdentifier = static_cast<uint8_t>(n); |
5283 | 5283 |
5284 // criticalExtensions | 5284 // criticalExtensions |
5285 int sel; | 5285 int sel; |
5286 bIterator = DeserializeChoice (2,false,&sel,bIterator); | 5286 bIterator = DeserializeChoice (2,false,&sel,bIterator); |
5287 if (sel == 1) | 5287 if (sel == 1) |
5288 { | 5288 { |
5289 // criticalExtensionsFuture | 5289 // criticalExtensionsFuture |
5290 bIterator = DeserializeSequence (&bitset0,false,bIterator); | 5290 bIterator = DeserializeSequence (&bitset0,false,bIterator); |
5291 } | 5291 } |
5292 else if (sel == 0) | 5292 else if (sel == 0) |
(...skipping 19 matching lines...) Expand all Loading... |
5312 | 5312 |
5313 m_haveMobilityControlInfo = rrcConnRecOpts[4]; | 5313 m_haveMobilityControlInfo = rrcConnRecOpts[4]; |
5314 if (m_haveMobilityControlInfo) | 5314 if (m_haveMobilityControlInfo) |
5315 { | 5315 { |
5316 // mobilityControlInfo | 5316 // mobilityControlInfo |
5317 std::bitset<4> mobCtrlOpts; | 5317 std::bitset<4> mobCtrlOpts; |
5318 bIterator = DeserializeSequence (&mobCtrlOpts,true,bIterator); | 5318 bIterator = DeserializeSequence (&mobCtrlOpts,true,bIterator); |
5319 | 5319 |
5320 // PhysCellId | 5320 // PhysCellId |
5321 bIterator = DeserializeInteger (&n,0,503,bIterator); | 5321 bIterator = DeserializeInteger (&n,0,503,bIterator); |
5322 m_mobilityControlInfo.targetPhysCellId = (uint16_t)n; | 5322 m_mobilityControlInfo.targetPhysCellId = static_cast<uint16_t>(n); |
5323 | 5323 |
5324 // carrierFreq | 5324 // carrierFreq |
5325 m_mobilityControlInfo.haveCarrierFreq = mobCtrlOpts[3]; | 5325 m_mobilityControlInfo.haveCarrierFreq = mobCtrlOpts[3]; |
5326 if (m_mobilityControlInfo.haveCarrierFreq) | 5326 if (m_mobilityControlInfo.haveCarrierFreq) |
5327 { | 5327 { |
5328 std::bitset<1> ulCarrierFreqPresent; | 5328 std::bitset<1> ulCarrierFreqPresent; |
5329 bIterator = DeserializeSequence (&ulCarrierFreqPresent,false,b
Iterator); | 5329 bIterator = DeserializeSequence (&ulCarrierFreqPresent,false,b
Iterator); |
5330 | 5330 |
5331 bIterator = DeserializeInteger (&n,0,MAX_EARFCN,bIterator); | 5331 bIterator = DeserializeInteger (&n,0,MAX_EARFCN,bIterator); |
5332 m_mobilityControlInfo.carrierFreq.dlCarrierFreq = n; | 5332 m_mobilityControlInfo.carrierFreq.dlCarrierFreq = n; |
(...skipping 73 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
5406 { | 5406 { |
5407 // ... | 5407 // ... |
5408 } | 5408 } |
5409 | 5409 |
5410 // t304 | 5410 // t304 |
5411 bIterator = DeserializeEnum (8,&n,bIterator); | 5411 bIterator = DeserializeEnum (8,&n,bIterator); |
5412 | 5412 |
5413 // newUE-Identity | 5413 // newUE-Identity |
5414 std::bitset<16> cRnti; | 5414 std::bitset<16> cRnti; |
5415 bIterator = DeserializeBitstring (&cRnti, bIterator); | 5415 bIterator = DeserializeBitstring (&cRnti, bIterator); |
5416 m_mobilityControlInfo.newUeIdentity = (uint16_t)cRnti.to_ulong (); | 5416 m_mobilityControlInfo.newUeIdentity = static_cast<uint16_t>(cRnti.
to_ulong ()); |
5417 | 5417 |
5418 // radioResourceConfigCommon | 5418 // radioResourceConfigCommon |
5419 bIterator = DeserializeRadioResourceConfigCommon (&m_mobilityContr
olInfo.radioResourceConfigCommon, bIterator); | 5419 bIterator = DeserializeRadioResourceConfigCommon (&m_mobilityContr
olInfo.radioResourceConfigCommon, bIterator); |
5420 | 5420 |
5421 m_mobilityControlInfo.haveRachConfigDedicated = mobCtrlOpts[0]; | 5421 m_mobilityControlInfo.haveRachConfigDedicated = mobCtrlOpts[0]; |
5422 if (m_mobilityControlInfo.haveRachConfigDedicated) | 5422 if (m_mobilityControlInfo.haveRachConfigDedicated) |
5423 { | 5423 { |
5424 bIterator = DeserializeSequence (&bitset0, false, bIterator); | 5424 bIterator = DeserializeSequence (&bitset0, false, bIterator); |
5425 bIterator = DeserializeInteger (&n,0,63, bIterator); | 5425 bIterator = DeserializeInteger (&n,0,63, bIterator); |
5426 m_mobilityControlInfo.rachConfigDedicated.raPreambleIndex = (u
int8_t)n; | 5426 m_mobilityControlInfo.rachConfigDedicated.raPreambleIndex = st
atic_cast<uint8_t>(n); |
5427 bIterator = DeserializeInteger (&n,0,15, bIterator); | 5427 bIterator = DeserializeInteger (&n,0,15, bIterator); |
5428 m_mobilityControlInfo.rachConfigDedicated.raPrachMaskIndex = (
uint8_t)n; | 5428 m_mobilityControlInfo.rachConfigDedicated.raPrachMaskIndex = s
tatic_cast<uint8_t>(n); |
5429 } | 5429 } |
5430 } | 5430 } |
5431 | 5431 |
5432 // dedicatedInfoNASList | 5432 // dedicatedInfoNASList |
5433 if (rrcConnRecOpts[3]) | 5433 if (rrcConnRecOpts[3]) |
5434 { | 5434 { |
5435 // ... | 5435 // ... |
5436 } | 5436 } |
5437 | 5437 |
5438 // radioResourceConfigDedicated | 5438 // radioResourceConfigDedicated |
(...skipping 512 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
5951 bIterator = DeserializeRadioResourceConfigDedicated (&m_asConfig.s
ourceRadioResourceConfig,bIterator); | 5951 bIterator = DeserializeRadioResourceConfigDedicated (&m_asConfig.s
ourceRadioResourceConfig,bIterator); |
5952 | 5952 |
5953 // Deserialize sourceSecurityAlgorithmConfig | 5953 // Deserialize sourceSecurityAlgorithmConfig |
5954 bIterator = DeserializeSequence (&bitset0,false,bIterator); | 5954 bIterator = DeserializeSequence (&bitset0,false,bIterator); |
5955 bIterator = DeserializeEnum (8,&n,bIterator); // cipheringAlgorith
m | 5955 bIterator = DeserializeEnum (8,&n,bIterator); // cipheringAlgorith
m |
5956 bIterator = DeserializeEnum (8,&n,bIterator); // integrityProtAlgo
rithm | 5956 bIterator = DeserializeEnum (8,&n,bIterator); // integrityProtAlgo
rithm |
5957 | 5957 |
5958 // Deserialize sourceUE-Identity | 5958 // Deserialize sourceUE-Identity |
5959 std::bitset<16> cRnti; | 5959 std::bitset<16> cRnti; |
5960 bIterator = DeserializeBitstring (&cRnti,bIterator); | 5960 bIterator = DeserializeBitstring (&cRnti,bIterator); |
5961 m_asConfig.sourceUeIdentity = (uint16_t)cRnti.to_ulong (); | 5961 m_asConfig.sourceUeIdentity = static_cast<uint16_t>(cRnti.to_ulong
()); |
5962 | 5962 |
5963 // Deserialize sourceMasterInformationBlock | 5963 // Deserialize sourceMasterInformationBlock |
5964 bIterator = DeserializeSequence (&bitset0,false,bIterator); | 5964 bIterator = DeserializeSequence (&bitset0,false,bIterator); |
5965 bIterator = DeserializeEnum (6,&n,bIterator); // dl-Bandwidth | 5965 bIterator = DeserializeEnum (6,&n,bIterator); // dl-Bandwidth |
5966 m_asConfig.sourceMasterInformationBlock.dlBandwidth = (uint8_t)n; | 5966 m_asConfig.sourceMasterInformationBlock.dlBandwidth = static_cast<
uint8_t>(n); |
5967 | 5967 |
5968 // phich-Config | 5968 // phich-Config |
5969 bIterator = DeserializeSequence (&bitset0,false,bIterator); | 5969 bIterator = DeserializeSequence (&bitset0,false,bIterator); |
5970 bIterator = DeserializeEnum (2,&n,bIterator); // phich-Duration | 5970 bIterator = DeserializeEnum (2,&n,bIterator); // phich-Duration |
5971 bIterator = DeserializeEnum (4,&n,bIterator); // phich-Resource | 5971 bIterator = DeserializeEnum (4,&n,bIterator); // phich-Resource |
5972 | 5972 |
5973 // systemFrameNumber | 5973 // systemFrameNumber |
5974 std::bitset<8> systemFrameNumber; | 5974 std::bitset<8> systemFrameNumber; |
5975 bIterator = DeserializeBitstring (&systemFrameNumber,bIterator); | 5975 bIterator = DeserializeBitstring (&systemFrameNumber,bIterator); |
5976 m_asConfig.sourceMasterInformationBlock.systemFrameNumber = (uint8
_t)systemFrameNumber.to_ulong (); | 5976 m_asConfig.sourceMasterInformationBlock.systemFrameNumber = static
_cast<uint8_t>(systemFrameNumber.to_ulong ()); |
5977 // spare | 5977 // spare |
5978 std::bitset<10> spare; | 5978 std::bitset<10> spare; |
5979 bIterator = DeserializeBitstring (&spare,bIterator); | 5979 bIterator = DeserializeBitstring (&spare,bIterator); |
5980 | 5980 |
5981 // Deserialize sourceSystemInformationBlockType1 | 5981 // Deserialize sourceSystemInformationBlockType1 |
5982 bIterator = DeserializeSystemInformationBlockType1 (&m_asConfig.so
urceSystemInformationBlockType1,bIterator); | 5982 bIterator = DeserializeSystemInformationBlockType1 (&m_asConfig.so
urceSystemInformationBlockType1,bIterator); |
5983 | 5983 |
5984 // Deserialize sourceSystemInformationBlockType2 | 5984 // Deserialize sourceSystemInformationBlockType2 |
5985 bIterator = DeserializeSystemInformationBlockType2 (&m_asConfig.so
urceSystemInformationBlockType2,bIterator); | 5985 bIterator = DeserializeSystemInformationBlockType2 (&m_asConfig.so
urceSystemInformationBlockType2,bIterator); |
5986 | 5986 |
(...skipping 146 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
6133 { | 6133 { |
6134 // Deserialize RRCConnectionReestablishmentRequest-r8-IEs | 6134 // Deserialize RRCConnectionReestablishmentRequest-r8-IEs |
6135 bIterator = DeserializeSequence (&bitset0,false,bIterator); | 6135 bIterator = DeserializeSequence (&bitset0,false,bIterator); |
6136 | 6136 |
6137 // Deserialize ReestabUE-Identity sequence | 6137 // Deserialize ReestabUE-Identity sequence |
6138 bIterator = DeserializeSequence (&bitset0,false,bIterator); | 6138 bIterator = DeserializeSequence (&bitset0,false,bIterator); |
6139 | 6139 |
6140 // Deserialize c-RNTI | 6140 // Deserialize c-RNTI |
6141 std::bitset<16> cRnti; | 6141 std::bitset<16> cRnti; |
6142 bIterator = DeserializeBitstring (&cRnti,bIterator); | 6142 bIterator = DeserializeBitstring (&cRnti,bIterator); |
6143 m_ueIdentity.cRnti = (uint16_t)cRnti.to_ulong (); | 6143 m_ueIdentity.cRnti = static_cast<uint16_t>(cRnti.to_ulong ()); |
6144 | 6144 |
6145 // Deserialize physCellId | 6145 // Deserialize physCellId |
6146 int physCellId; | 6146 int physCellId; |
6147 bIterator = DeserializeInteger (&physCellId,0,503,bIterator); | 6147 bIterator = DeserializeInteger (&physCellId,0,503,bIterator); |
6148 m_ueIdentity.physCellId = (uint16_t)physCellId; | 6148 m_ueIdentity.physCellId = static_cast<uint16_t>(physCellId); |
6149 | 6149 |
6150 // Deserialize shortMAC-I | 6150 // Deserialize shortMAC-I |
6151 std::bitset<16> shortMacI; | 6151 std::bitset<16> shortMacI; |
6152 bIterator = DeserializeBitstring (&shortMacI,bIterator); | 6152 bIterator = DeserializeBitstring (&shortMacI,bIterator); |
6153 | 6153 |
6154 // Deserialize ReestablishmentCause | 6154 // Deserialize ReestablishmentCause |
6155 int reestCs; | 6155 int reestCs; |
6156 bIterator = DeserializeEnum (4,&reestCs,bIterator); | 6156 bIterator = DeserializeEnum (4,&reestCs,bIterator); |
6157 switch (reestCs) | 6157 switch (reestCs) |
6158 { | 6158 { |
(...skipping 107 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
6266 int n; | 6266 int n; |
6267 | 6267 |
6268 bIterator = DeserializeDlCcchMessage (bIterator); | 6268 bIterator = DeserializeDlCcchMessage (bIterator); |
6269 | 6269 |
6270 // Deserialize RrcConnectionReestablishment sequence | 6270 // Deserialize RrcConnectionReestablishment sequence |
6271 // 0 optional fields, no extension marker | 6271 // 0 optional fields, no extension marker |
6272 bIterator = DeserializeSequence (&bitset0,false,bIterator); | 6272 bIterator = DeserializeSequence (&bitset0,false,bIterator); |
6273 | 6273 |
6274 // Deserialize rrc-TransactionIdentifier | 6274 // Deserialize rrc-TransactionIdentifier |
6275 bIterator = DeserializeInteger (&n,0,3,bIterator); | 6275 bIterator = DeserializeInteger (&n,0,3,bIterator); |
6276 m_rrcTransactionIdentifier = (uint8_t)n; | 6276 m_rrcTransactionIdentifier = static_cast<uint8_t>(n); |
6277 | 6277 |
6278 // Deserialize criticalExtensions choice | 6278 // Deserialize criticalExtensions choice |
6279 int criticalExtensionsChoice; | 6279 int criticalExtensionsChoice; |
6280 bIterator = DeserializeChoice (2,false,&criticalExtensionsChoice,bIterator); | 6280 bIterator = DeserializeChoice (2,false,&criticalExtensionsChoice,bIterator); |
6281 if (criticalExtensionsChoice == 1) | 6281 if (criticalExtensionsChoice == 1) |
6282 { | 6282 { |
6283 // Deserialize criticalExtensionsFuture | 6283 // Deserialize criticalExtensionsFuture |
6284 bIterator = DeserializeSequence (&bitset0,false,bIterator); | 6284 bIterator = DeserializeSequence (&bitset0,false,bIterator); |
6285 } | 6285 } |
6286 else if (criticalExtensionsChoice == 0) | 6286 else if (criticalExtensionsChoice == 0) |
(...skipping 99 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
6386 int n; | 6386 int n; |
6387 | 6387 |
6388 bIterator = DeserializeUlDcchMessage (bIterator); | 6388 bIterator = DeserializeUlDcchMessage (bIterator); |
6389 | 6389 |
6390 // Deserialize RrcConnectionReestablishmentComplete sequence | 6390 // Deserialize RrcConnectionReestablishmentComplete sequence |
6391 // 0 optional fields, no extension marker | 6391 // 0 optional fields, no extension marker |
6392 bIterator = DeserializeSequence (&bitset0,false,bIterator); | 6392 bIterator = DeserializeSequence (&bitset0,false,bIterator); |
6393 | 6393 |
6394 // Deserialize rrc-TransactionIdentifier | 6394 // Deserialize rrc-TransactionIdentifier |
6395 bIterator = DeserializeInteger (&n,0,3,bIterator); | 6395 bIterator = DeserializeInteger (&n,0,3,bIterator); |
6396 m_rrcTransactionIdentifier = (uint8_t)n; | 6396 m_rrcTransactionIdentifier = static_cast<uint8_t>(n); |
6397 | 6397 |
6398 // Deserialize criticalExtensions choice | 6398 // Deserialize criticalExtensions choice |
6399 int criticalExtensionsChoice; | 6399 int criticalExtensionsChoice; |
6400 bIterator = DeserializeChoice (2,false,&criticalExtensionsChoice,bIterator); | 6400 bIterator = DeserializeChoice (2,false,&criticalExtensionsChoice,bIterator); |
6401 if (criticalExtensionsChoice == 1) | 6401 if (criticalExtensionsChoice == 1) |
6402 { | 6402 { |
6403 // Deserialize criticalExtensionsFuture | 6403 // Deserialize criticalExtensionsFuture |
6404 bIterator = DeserializeSequence (&bitset0,false,bIterator); | 6404 bIterator = DeserializeSequence (&bitset0,false,bIterator); |
6405 } | 6405 } |
6406 else if (criticalExtensionsChoice == 0) | 6406 else if (criticalExtensionsChoice == 0) |
(...skipping 173 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
6580 int n; | 6580 int n; |
6581 | 6581 |
6582 bIterator = DeserializeDlDcchMessage (bIterator); | 6582 bIterator = DeserializeDlDcchMessage (bIterator); |
6583 | 6583 |
6584 // Deserialize RrcConnectionRelease sequence | 6584 // Deserialize RrcConnectionRelease sequence |
6585 // 0 optional fields, no extension marker | 6585 // 0 optional fields, no extension marker |
6586 bIterator = DeserializeSequence (&bitset0,false,bIterator); | 6586 bIterator = DeserializeSequence (&bitset0,false,bIterator); |
6587 | 6587 |
6588 // Deserialize rrc-TransactionIdentifier | 6588 // Deserialize rrc-TransactionIdentifier |
6589 bIterator = DeserializeInteger (&n,0,3,bIterator); | 6589 bIterator = DeserializeInteger (&n,0,3,bIterator); |
6590 m_rrcConnectionRelease.rrcTransactionIdentifier = (uint8_t)n; | 6590 m_rrcConnectionRelease.rrcTransactionIdentifier = static_cast<uint8_t>(n); |
6591 | 6591 |
6592 // Deserialize criticalExtensions choice | 6592 // Deserialize criticalExtensions choice |
6593 int criticalExtensionsChoice; | 6593 int criticalExtensionsChoice; |
6594 bIterator = DeserializeChoice (2,false,&criticalExtensionsChoice,bIterator); | 6594 bIterator = DeserializeChoice (2,false,&criticalExtensionsChoice,bIterator); |
6595 if (criticalExtensionsChoice == 1) | 6595 if (criticalExtensionsChoice == 1) |
6596 { | 6596 { |
6597 // Deserialize criticalExtensionsFuture | 6597 // Deserialize criticalExtensionsFuture |
6598 bIterator = DeserializeSequence (&bitset0,false,bIterator); | 6598 bIterator = DeserializeSequence (&bitset0,false,bIterator); |
6599 } | 6599 } |
6600 else if (criticalExtensionsChoice == 0) | 6600 else if (criticalExtensionsChoice == 0) |
(...skipping 125 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
6726 { | 6726 { |
6727 bIterator = DeserializeNull (bIterator); | 6727 bIterator = DeserializeNull (bIterator); |
6728 } | 6728 } |
6729 else if (c1Choice == 0) | 6729 else if (c1Choice == 0) |
6730 { | 6730 { |
6731 // Deserialize rrcConnectionReject-r8 | 6731 // Deserialize rrcConnectionReject-r8 |
6732 std::bitset<1> opts; | 6732 std::bitset<1> opts; |
6733 bIterator = DeserializeSequence (&opts,false,bIterator); | 6733 bIterator = DeserializeSequence (&opts,false,bIterator); |
6734 | 6734 |
6735 bIterator = DeserializeInteger (&n,1,16,bIterator); | 6735 bIterator = DeserializeInteger (&n,1,16,bIterator); |
6736 m_rrcConnectionReject.waitTime = (uint8_t)n; | 6736 m_rrcConnectionReject.waitTime = static_cast<uint8_t>(n); |
6737 | 6737 |
6738 if (opts[0]) | 6738 if (opts[0]) |
6739 { | 6739 { |
6740 // Deserialize RRCConnectionReject-v8a0-IEs | 6740 // Deserialize RRCConnectionReject-v8a0-IEs |
6741 // ... | 6741 // ... |
6742 } | 6742 } |
6743 } | 6743 } |
6744 } | 6744 } |
6745 | 6745 |
6746 return GetSerializedSize (); | 6746 return GetSerializedSize (); |
(...skipping 412 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
7159 { | 7159 { |
7160 SerializeSequence (std::bitset<0> (),false); | 7160 SerializeSequence (std::bitset<0> (),false); |
7161 // Choose c1 | 7161 // Choose c1 |
7162 SerializeChoice (2,0,false); | 7162 SerializeChoice (2,0,false); |
7163 // Choose message type | 7163 // Choose message type |
7164 SerializeChoice (4,messageType,false); | 7164 SerializeChoice (4,messageType,false); |
7165 } | 7165 } |
7166 | 7166 |
7167 } // namespace ns3 | 7167 } // namespace ns3 |
7168 | 7168 |
LEFT | RIGHT |