Json::Value Receiver::getValue()

in shims/qpid-proton-cpp/src/qpidit/amqp_types_test/Receiver.cpp [149:258]
109 lines of code
28 McCabe index (conditional complexity)

        Json::Value Receiver::getValue(const std::string& amqpType, const proton::value& val) {
            if (amqpType.compare("null") == 0) {
                checkMessageType(val, proton::NULL_TYPE);
                return "None";
            }
            if (amqpType.compare("boolean") == 0) {
                checkMessageType(val, proton::BOOLEAN);
                return proton::get<bool>(val) ? "True" : "False";
            }
            if (amqpType.compare("ubyte") == 0) {
                checkMessageType(val, proton::UBYTE);
                return toHexStr<uint8_t>(proton::get<uint8_t>(val));
            }
            if (amqpType.compare("ushort") == 0) {
                checkMessageType(val, proton::USHORT);
                return toHexStr<uint16_t>(proton::get<uint16_t>(val));
            }
            if (amqpType.compare("uint") == 0) {
                checkMessageType(val, proton::UINT);
                return toHexStr<uint32_t>(proton::get<uint32_t>(val));
            }
            if (amqpType.compare("ulong") == 0) {
                checkMessageType(val, proton::ULONG);
                return toHexStr<uint64_t>(proton::get<uint64_t>(val));
            }
            if (amqpType.compare("byte") == 0) {
                checkMessageType(val, proton::BYTE);
                return toHexStr<int8_t>(proton::get<int8_t>(val));
            }
            if (amqpType.compare("short") == 0) {
                checkMessageType(val, proton::SHORT);
                return toHexStr<int16_t>(proton::get<int16_t>(val));
            }
            if (amqpType.compare("int") == 0) {
                checkMessageType(val, proton::INT);
                return toHexStr<int32_t>(proton::get<int32_t>(val));
            }
            if (amqpType.compare("long") == 0) {
                checkMessageType(val, proton::LONG);
                return toHexStr<int64_t>(proton::get<int64_t>(val));
            }
            if (amqpType.compare("float") == 0) {
                checkMessageType(val, proton::FLOAT);
                float f = proton::get<float>(val);
                return toHexStr<uint32_t>(*((uint32_t*)&f), true);
            }
            if (amqpType.compare("double") == 0) {
                checkMessageType(val, proton::DOUBLE);
                double d = proton::get<double>(val);
                return toHexStr<uint64_t>(*((uint64_t*)&d), true);
            }
            if (amqpType.compare("decimal32") == 0) {
                checkMessageType(val, proton::DECIMAL32);
                return byteArrayToHexStr(proton::get<proton::decimal32>(val));
            }
            if (amqpType.compare("decimal64") == 0) {
                checkMessageType(val, proton::DECIMAL64);
                return byteArrayToHexStr(proton::get<proton::decimal64>(val));
            }
            if (amqpType.compare("decimal128") == 0) {
                checkMessageType(val, proton::DECIMAL128);
                return byteArrayToHexStr(proton::get<proton::decimal128>(val));
            }
            if (amqpType.compare("char") == 0) {
                checkMessageType(val, proton::CHAR);
                wchar_t c = proton::get<wchar_t>(val);
                std::stringstream oss;
                if (c < 0x7f && std::iswprint(c)) {
                    oss << (char)c;
                } else {
                    oss << "0x" << std::hex << c;
                }
                return oss.str();
            }
            if (amqpType.compare("timestamp") == 0) {
                checkMessageType(val, proton::TIMESTAMP);
                std::ostringstream oss;
                oss << "0x" << std::hex << proton::get<proton::timestamp>(val).milliseconds();
                return oss.str();
            }
            if (amqpType.compare("uuid") == 0) {
                checkMessageType(val, proton::UUID);
                std::ostringstream oss;
                oss << proton::get<proton::uuid>(val);
                return oss.str();
            }
            if (amqpType.compare("binary") == 0) {
                checkMessageType(val, proton::BINARY);
                // Encode binary to base64 before returning value as string
                return b64_encode(proton::get<proton::binary>(val));
            }
            if (amqpType.compare("string") == 0) {
                checkMessageType(val, proton::STRING);
                return proton::get<std::string>(val);
            }
            if (amqpType.compare("symbol") == 0) {
                checkMessageType(val, proton::SYMBOL);
                return proton::get<proton::symbol>(val);
            }
            if (amqpType.compare("list") == 0) {
                throw qpidit::UnsupportedAmqpTypeError(amqpType);
            }
            if (amqpType.compare("map") == 0) {
                throw qpidit::UnsupportedAmqpTypeError(amqpType);
            }
            if (amqpType.compare("array") == 0) {
                throw qpidit::UnsupportedAmqpTypeError(amqpType);
            }
            throw qpidit::UnknownAmqpTypeError(amqpType);
        }