app::ConversionResult::Type Column::ReadToBuffer()

in modules/platforms/cpp/odbc/src/column.cpp [328:531]
138 lines of code
24 McCabe index (conditional complexity)

        app::ConversionResult::Type Column::ReadToBuffer(BinaryReaderImpl& reader, app::ApplicationDataBuffer& dataBuf)
        {
            if (!IsValid())
                return app::ConversionResult::AI_FAILURE;

            if (GetUnreadDataLength() == 0)
            {
                dataBuf.PutNull();

                return app::ConversionResult::AI_NO_DATA;
            }

            InteropInputStream* stream = reader.GetStream();

            if (!stream)
                return app::ConversionResult::AI_FAILURE;

            InteropStreamPositionGuard<InteropInputStream> guard(*stream);

            stream->Position(startPos);

            app::ConversionResult::Type convRes = app::ConversionResult::AI_SUCCESS;

            switch (type)
            {
                case IGNITE_TYPE_BYTE:
                {
                    convRes = dataBuf.PutInt8(reader.ReadInt8());

                    IncreaseOffset(size);

                    break;
                }

                case IGNITE_TYPE_SHORT:
                case IGNITE_TYPE_CHAR:
                {
                    convRes = dataBuf.PutInt16(reader.ReadInt16());

                    IncreaseOffset(size);

                    break;
                }

                case IGNITE_TYPE_INT:
                {
                    convRes = dataBuf.PutInt32(reader.ReadInt32());

                    IncreaseOffset(size);

                    break;
                }

                case IGNITE_TYPE_LONG:
                {
                    convRes = dataBuf.PutInt64(reader.ReadInt64());

                    IncreaseOffset(size);

                    break;
                }

                case IGNITE_TYPE_FLOAT:
                {
                    convRes = dataBuf.PutFloat(reader.ReadFloat());

                    IncreaseOffset(size);

                    break;
                }

                case IGNITE_TYPE_DOUBLE:
                {
                    convRes = dataBuf.PutDouble(reader.ReadDouble());

                    IncreaseOffset(size);

                    break;
                }

                case IGNITE_TYPE_BOOL:
                {
                    convRes = dataBuf.PutInt8(reader.ReadBool() ? 1 : 0);

                    IncreaseOffset(size);

                    break;
                }

                case IGNITE_TYPE_STRING:
                {
                    std::string str;
                    utility::ReadString(reader, str);

                    int32_t written = 0;
                    convRes = dataBuf.PutString(str.substr(offset), written);

                    IncreaseOffset(written);

                    break;
                }

                case IGNITE_TYPE_UUID:
                {
                    Guid guid = reader.ReadGuid();

                    convRes = dataBuf.PutGuid(guid);

                    IncreaseOffset(size);

                    break;
                }

                case IGNITE_HDR_NULL:
                {
                    convRes = dataBuf.PutNull();

                    IncreaseOffset(size);

                    break;
                }

                case IGNITE_TYPE_BINARY:
                case IGNITE_TYPE_OBJECT:
                {
                    int32_t len;

                    if (!GetObjectLength(*stream, len))
                        return app::ConversionResult::AI_FAILURE;

                    std::vector<int8_t> data(len);

                    stream->ReadInt8Array(&data[0], static_cast<int32_t>(data.size()));

                    int32_t written = 0;
                    convRes = dataBuf.PutBinaryData(data.data() + offset,
                        static_cast<size_t>(len - offset), written);

                    IncreaseOffset(written);

                    break;
                }

                case IGNITE_TYPE_DECIMAL:
                {
                    common::Decimal res;

                    utility::ReadDecimal(reader, res);

                    convRes = dataBuf.PutDecimal(res);

                    IncreaseOffset(size);

                    break;
                }

                case IGNITE_TYPE_DATE:
                {
                    Date date = reader.ReadDate();

                    convRes = dataBuf.PutDate(date);

                    break;
                }

                case IGNITE_TYPE_TIMESTAMP:
                {
                    Timestamp ts = reader.ReadTimestamp();

                    convRes = dataBuf.PutTimestamp(ts);

                    break;
                }

                case IGNITE_TYPE_TIME:
                {
                    Time time = reader.ReadTime();

                    convRes = dataBuf.PutTime(time);

                    break;
                }

                case IGNITE_TYPE_ARRAY_BYTE:
                {
                    stream->Position(startPos + offset);
                    int32_t maxRead = std::min(GetUnreadDataLength(), static_cast<int32_t>(dataBuf.GetSize()));
                    std::vector<int8_t> data(maxRead);

                    stream->ReadInt8Array(&data[0], static_cast<int32_t>(data.size()));

                    int32_t written = 0;
                    convRes = dataBuf.PutBinaryData(data.data(), data.size(), written);

                    IncreaseOffset(written);
                    break;
                }

                default:
                    return app::ConversionResult::AI_UNSUPPORTED_CONVERSION;
            }

            return convRes;
        }