static HRESULT PropertyValueToJson()

in src/foundation_library/JsonStatics.cpp [178:402]
216 lines of code
30 McCabe index (conditional complexity)

static HRESULT PropertyValueToJson(
    _In_ foundation::IPropertyValue *pPropertyValue,
    _Out_ json_t *&json)
{
    foundation_assert(pPropertyValue);
    PropertyType propertyType;
    HRESULT hr;

    IFHR_ASSERT(pPropertyValue->get_Type(&propertyType));
    switch(propertyType)
    {
    case PropertyType_Empty:
        json = json_null();
        break;
    case PropertyType_UInt8:
        {
            UINT8 value;
            pPropertyValue->GetUInt8(&value);
            json = json_integer((json_int_t)value);
        }
        break;
    case PropertyType_Int16:
        {
            INT16 value;
            pPropertyValue->GetInt16(&value);
            json = json_integer((json_int_t)value);
        }
        break;
    case PropertyType_UInt16:
        {
            UINT16 value;
            pPropertyValue->GetUInt16(&value);
            json = json_integer((json_int_t)value);
        }
        break;
    case PropertyType_Int32:
        {
            INT32 value;
            pPropertyValue->GetInt32(&value);
            json = json_integer((json_int_t)value);
        }
        break;
    case PropertyType_UInt32:
        {
            UINT32 value;
            pPropertyValue->GetUInt32(&value);
            json = json_integer((json_int_t)value);
        }
        break;
    case PropertyType_Int64:
        {
            INT64 value;
            pPropertyValue->GetInt64(&value);
            json = json_integer((json_int_t)value);
        }
        break;
    case PropertyType_UInt64:
        {
            UINT64 value;
            pPropertyValue->GetUInt64(&value);
            json = json_integer((json_int_t)value);
        }
        break;
    case PropertyType_Single:
        {
            FLOAT value;
            pPropertyValue->GetSingle(&value);
            json = json_real(value);
        }
        break;
    case PropertyType_Double:
        {
            DOUBLE value;
            pPropertyValue->GetDouble(&value);
            json = json_real(value);
        }
        break;
    case PropertyType_Char16:
        {
            WCHAR value;
            pPropertyValue->GetChar16(&value);
            json = json_integer((json_int_t)value);
        }
        break;
    case PropertyType_Boolean:
        {
            boolean bVal;
            pPropertyValue->GetBoolean(&bVal);
            json = json_boolean(bVal);
        }
        break;
    case PropertyType_String:
        {
            foundation::HStringPtr hstr;
            pPropertyValue->GetString(hstr.GetAddressOf());
            json = toJson(hstr);
        }
        break;
    case PropertyType_Guid:
        {
            IID iid;
            pPropertyValue->GetGuid(&iid);
            HStringPtr hstr;
            pv_util::ToString(iid,hstr.GetAddressOf());
            json = json_string(foundation::to_utf8_string(hstr).c_str());
        }
        break;
    case PropertyType_DateTime:
        {
            DateTime dt;
            pPropertyValue->GetDateTime(&dt);

            std::ostringstream dtStream;
            dtStream << _dtPrefix;
            dtStream << dt.UniversalTime;

            json = json_string(dtStream.str().c_str());
        }
        break;
    case PropertyType_UInt8Array:
        {
            hr = ToJsonArray(pPropertyValue,&IPropertyValue::GetUInt8Array,json_integer,json);
            IFHR_ASSERT(hr);
        }
        break;
    case PropertyType_Int16Array:
        {
            hr = ToJsonArray(pPropertyValue,&IPropertyValue::GetInt16Array,json_integer,json);
            IFHR_ASSERT(hr);
        }
        break;
    case PropertyType_UInt16Array:
        {
            hr = ToJsonArray(pPropertyValue,&IPropertyValue::GetUInt16Array,json_integer,json);
            IFHR_ASSERT(hr);
        }
        break;
    case PropertyType_Int32Array:
        {
            hr = ToJsonArray(pPropertyValue,&IPropertyValue::GetInt32Array,json_integer,json);
            IFHR_ASSERT(hr);
        }
        break;
    case PropertyType_UInt32Array:
        {
            hr = ToJsonArray(pPropertyValue,&IPropertyValue::GetUInt32Array,json_integer,json);
            IFHR_ASSERT(hr);
        }
        break;
    case PropertyType_Int64Array:
        {
            hr = ToJsonArray(pPropertyValue,&IPropertyValue::GetInt64Array,json_integer,json);
            IFHR_ASSERT(hr);
        }
        break;
    case PropertyType_UInt64Array:
        {
            hr = ToJsonArray(pPropertyValue,&IPropertyValue::GetUInt64Array,json_integer,json);
            IFHR_ASSERT(hr);
        }
        break;
    case PropertyType_SingleArray:
        {
            hr = ToJsonArray(pPropertyValue,&IPropertyValue::GetSingleArray,json_real,json);
            IFHR_ASSERT(hr);
        }
        break;
    case PropertyType_DoubleArray:
        {
            hr = ToJsonArray(pPropertyValue,&IPropertyValue::GetDoubleArray,json_real,json);
            IFHR_ASSERT(hr);
        }
        break;
    case PropertyType_BooleanArray:
        {
            UINT32 size;
            boolean *pValues;

            hr = pPropertyValue->GetBooleanArray(&size,&pValues);
            IFHR_ASSERT(hr);

            json = json_array();
            for(UINT32 i = 0;i < size;++i)
            {
                json_array_append_new(json,json_boolean(pValues[i]));
            }
            _pal_MemFree((LPVOID)pValues);
        }
        break;
    case PropertyType_StringArray:
        {
            foundation::HStringArrayWrapper strArrayWrapper;

            hr = pPropertyValue->GetStringArray(
                strArrayWrapper.GetSizeAddressOf(),
                strArrayWrapper.GetBufferAddressOf());
            IFHR_ASSERT(hr);

            json = json_array();
            for(UINT32 i = 0;i < strArrayWrapper.GetSize();++i)
            {
                json_array_append_new(json,json_string(_TO_UTF8_STR(strArrayWrapper[i])));
            }
        }
        break;
    case PropertyType_InspectableArray:
        {
            foundation::InspectableArrayWrapper objArrayWrapper;

            IFHR_ASSERT(pPropertyValue->GetInspectableArray(
                objArrayWrapper.GetSizeAddressOf(),
                objArrayWrapper.GetBufferAddressOf()));

            IFHR_ASSERT(InspectableArrayToJson(
                objArrayWrapper.GetSize(),
                (foundation::IInspectable **)objArrayWrapper.GetBuffer(),
                json));
        }
        break;
    default:
        foundation_assert(false);
        return E_NOTIMPL;
    }
    return S_OK;
}