std::unique_ptr Decoder::decode()

in hessian2/basic_codec/object_codec.cc [71:219]

• 122 lines of code
• 84 McCabe index (conditional complexity)

std::unique_ptr<Object> Decoder::decode() {
  auto ret = reader_->peek<uint8_t>();
  if (!ret.first) {
    return nullptr;
  }
  auto code = ret.second;

  switch (code) {
    // Null Object
    case 'N': {
      auto ret = decode<NullObject>();
      return ret == nullptr ? nullptr : std::make_unique<NullObject>();
    }
    // Bool
    case 0x46:
    case 0x54: {
      auto ret = decode<bool>();
      return ret == nullptr ? nullptr : std::make_unique<BooleanObject>(*ret);
    }

    // Date
    case 0x4a:
    case 0x4b: {
      auto ret = decode<std::chrono::milliseconds>();
      return ret == nullptr ? nullptr : std::make_unique<DateObject>(*ret);
    }

    // Double
    case 0x5b:
    case 0x5c:
    case 0x5d:
    case 0x5e:
    case 0x5f:
    case 'D': {
      auto ret = decode<double>();
      return ret == nullptr ? nullptr : std::make_unique<DoubleObject>(*ret);
    }

    // Typed list
    case 'V':
    case 0x55:
    case 0x70:
    case 0x71:
    case 0x72:
    case 0x73:
    case 0x74:
    case 0x75:
    case 0x76:
    case 0x77: {
      auto ret = decode<TypedListObject>();
      return ret;
    }

    // Untyped list
    case 0x57:
    case 0x58:
    case 0x78:
    case 0x79:
    case 0x7a:
    case 0x7b:
    case 0x7c:
    case 0x7d:
    case 0x7e:
    case 0x7f: {
      auto ret = decode<UntypedListObject>();
      return ret;
    }

    // Typed map
    case 'M': {
      auto ret = decode<TypedMapObject>();
      return ret;
    }

    case 'H': {
      auto ret = decode<UntypedMapObject>();
      return ret;
    }

    case 'C': {
      auto ret = decode<Object::Definition>();
      if (!ret) {
        return nullptr;
      }
      return decode<Object>();
    }

    case 'O':
    case 0x60:
    case 0x61:
    case 0x62:
    case 0x63:
    case 0x64:
    case 0x65:
    case 0x66:
    case 0x67:
    case 0x68:
    case 0x69:
    case 0x6a:
    case 0x6b:
    case 0x6c:
    case 0x6d:
    case 0x6e:
    case 0x6f: {
      auto ret = decode<ClassInstanceObject>();
      return ret;
    }

    case 0x51: {
      auto ret = decode<RefObject>();
      return ret;
    }

    default:
      break;
  }

  // String
  if (code <= 0x1f || (code >= 0x30 && code <= 0x33) || code == 0x52 ||
      code == 0x53) {
    auto ret = decode<std::string>();
    return ret == nullptr ? nullptr
                          : std::make_unique<StringObject>(std::move(ret));
  }

  // Binary
  if ((code >= 0x20 && code <= 0x2f) || (code >= 0x34 && code <= 0x37) ||
      code == 0x41 || code == 0x42) {
    auto ret = decode<std::vector<uint8_t>>();
    return ret == nullptr ? nullptr
                          : std::make_unique<BinaryObject>(std::move(ret));
  }

  // Long
  if ((code >= 0x38 && code <= 0x3f) || (code >= 0xd8 && code <= 0xef) ||
      code >= 0xf0 || code == 0x59 || code == 0x4c) {
    auto ret = decode<int64_t>();
    return ret == nullptr ? nullptr : std::make_unique<LongObject>(*ret);
  }

  // int
  if (code == 0x49 || (code >= 0x80 && code <= 0xbf) ||
      (code >= 0xc0 && code <= 0xcf) || (code >= 0xd0 && code <= 0xd7)) {
    auto ret = decode<int32_t>();
    return ret == nullptr ? nullptr : std::make_unique<IntegerObject>(*ret);
  }

  return nullptr;
}