Buffer::Iterator Asn1Header::DeserializeInteger()

in simulation/src/lte/model/lte-asn1-header.cc [541:673]
125 lines of code
23 McCabe index (conditional complexity)

Buffer::Iterator Asn1Header::DeserializeInteger (int *n, int nmin, int nmax, Buffer::Iterator bIterator)
{
  // Misusage check: Ensure nmax>nmin ...
  if (nmin > nmax)
    {
      int aux = nmin;
      nmin = nmax;
      nmax = aux;
    }

  int range = nmax - nmin + 1;

  if (range == 1)
    {
      return bIterator;
    }

  int requiredBits = std::ceil (std::log (range) / std::log (2.0));

  std::bitset<1> bitsRead1;
  std::bitset<2> bitsRead2;
  std::bitset<3> bitsRead3;
  std::bitset<4> bitsRead4;
  std::bitset<5> bitsRead5;
  std::bitset<6> bitsRead6;
  std::bitset<7> bitsRead7;
  std::bitset<8> bitsRead8;
  std::bitset<9> bitsRead9;
  std::bitset<10> bitsRead10;
  std::bitset<11> bitsRead11;
  std::bitset<12> bitsRead12;
  std::bitset<13> bitsRead13;
  std::bitset<14> bitsRead14;
  std::bitset<15> bitsRead15;
  std::bitset<16> bitsRead16;
  std::bitset<17> bitsRead17;
  std::bitset<18> bitsRead18;
  std::bitset<19> bitsRead19;
  std::bitset<20> bitsRead20;

  switch (requiredBits)
    {
    case 1:
      bIterator = DeserializeBitset<1> (&bitsRead1,bIterator);
      *n = (int)bitsRead1.to_ulong ();
      break;
    case 2:
      bIterator = DeserializeBitset<2> (&bitsRead2,bIterator);
      *n = (int)bitsRead2.to_ulong ();
      break;
    case 3:
      bIterator = DeserializeBitset<3> (&bitsRead3,bIterator);
      *n = (int)bitsRead3.to_ulong ();
      break;
    case 4:
      bIterator = DeserializeBitset<4> (&bitsRead4,bIterator);
      *n = (int)bitsRead4.to_ulong ();
      break;
    case 5:
      bIterator = DeserializeBitset<5> (&bitsRead5,bIterator);
      *n = (int)bitsRead5.to_ulong ();
      break;
    case 6:
      bIterator = DeserializeBitset<6> (&bitsRead6,bIterator);
      *n = (int)bitsRead6.to_ulong ();
      break;
    case 7:
      bIterator = DeserializeBitset<7> (&bitsRead7,bIterator);
      *n = (int)bitsRead7.to_ulong ();
      break;
    case 8:
      bIterator = DeserializeBitset<8> (&bitsRead8,bIterator);
      *n = (int)bitsRead8.to_ulong ();
      break;
    case 9:
      bIterator = DeserializeBitset<9> (&bitsRead9,bIterator);
      *n = (int)bitsRead9.to_ulong ();
      break;
    case 10:
      bIterator = DeserializeBitset<10> (&bitsRead10,bIterator);
      *n = (int)bitsRead10.to_ulong ();
      break;
    case 11:
      bIterator = DeserializeBitset<11> (&bitsRead11,bIterator);
      *n = (int)bitsRead11.to_ulong ();
      break;
    case 12:
      bIterator = DeserializeBitset<12> (&bitsRead12,bIterator);
      *n = (int)bitsRead12.to_ulong ();
      break;
    case 13:
      bIterator = DeserializeBitset<13> (&bitsRead13,bIterator);
      *n = (int)bitsRead13.to_ulong ();
      break;
    case 14:
      bIterator = DeserializeBitset<14> (&bitsRead14,bIterator);
      *n = (int)bitsRead14.to_ulong ();
      break;
    case 15:
      bIterator = DeserializeBitset<15> (&bitsRead15,bIterator);
      *n = (int)bitsRead15.to_ulong ();
      break;
    case 16:
      bIterator = DeserializeBitset<16> (&bitsRead16,bIterator);
      *n = (int)bitsRead16.to_ulong ();
      break;
    case 17:
      bIterator = DeserializeBitset<17> (&bitsRead17,bIterator);
      *n = (int)bitsRead17.to_ulong ();
      break;
    case 18:
      bIterator = DeserializeBitset<18> (&bitsRead18,bIterator);
      *n = (int)bitsRead18.to_ulong ();
      break;
    case 19:
      bIterator = DeserializeBitset<19> (&bitsRead19,bIterator);
      *n = (int)bitsRead19.to_ulong ();
      break;
    case 20:
      bIterator = DeserializeBitset<20> (&bitsRead20,bIterator);
      *n = (int)bitsRead20.to_ulong ();
      break;
    default:
      {
        std::cout << "SerializeInteger Out of range!!" << std::endl;
        exit (1);
      }
    }

  *n += nmin;

  return bIterator;
}