HRESULT CPropertyValueInternalStatics::Serialize()

in src/foundation/PropertyValueInternalStatics.cpp [319:501]
181 lines of code
34 McCabe index (conditional complexity)

HRESULT CPropertyValueInternalStatics::Serialize(
    std::ostream& os,
    PropertyType type,
    IPropertyValue *pPropertyValue)
{
    foundation_assert(pPropertyValue);

    binary_serializer bos(os);

    switch (type)
    {
    case PropertyType_Empty:
        break;
    case PropertyType_UInt8:
        {
            UINT8 value;
            pPropertyValue->GetUInt8(&value);
            bos.serializeByte(value);
        }
        break;
    case PropertyType_Int16:
        {
            INT16 value;
            pPropertyValue->GetInt16(&value);
            bos.serializeInt16(value);
        }
        break;
    case PropertyType_UInt16:
        {
            UINT16 value;
            pPropertyValue->GetUInt16(&value);
            bos.serializeUInt16(value);
        }
        break;
    case PropertyType_Int32:
        {
            INT32 value;
            pPropertyValue->GetInt32(&value);
            bos.serializeInt(value);
        }
        break;
    case PropertyType_UInt32:
        {
            UINT32 value;
            pPropertyValue->GetUInt32(&value);
            bos.serializeUInt(value);
        }
        break;
    case PropertyType_Int64:
        {
            INT64 value;
            pPropertyValue->GetInt64(&value);
            bos.serializeInt64(value);
        }
        break;
    case PropertyType_UInt64:
        {
            UINT64 value;
            pPropertyValue->GetUInt64(&value);
            bos.serializeUInt64(value);
        }
        break;
    case PropertyType_Single:
        {
            FLOAT value;
            pPropertyValue->GetSingle(&value);
            bos.serializeSingle(value);
        }
        break;
    case PropertyType_Double:
        {
            DOUBLE value;
            pPropertyValue->GetDouble(&value);
            bos.serializeDouble(value);
        }
        break;
    case PropertyType_Char16:
        {
            WCHAR value;
            pPropertyValue->GetChar16(&value);
            bos.serializeChar16(value);
        }
        break;
    case PropertyType_Boolean:
        {
            boolean boolValue;
            pPropertyValue->GetBoolean(&boolValue);
            bos.serializeBoolean(boolValue ? true:false);
        }
        break;
    case PropertyType_String:
        {
            foundation::HStringPtr hstr;
            pPropertyValue->GetString(hstr.GetAddressOf());
            bos.serializeString(hstr.GetRawBuffer());
        }
        break;
    case PropertyType_Guid:
        {
            IID iid;
            pPropertyValue->GetGuid(&iid);
            bos.serializeIID(iid);
        }
        break;
    case PropertyType_UInt8Array:
        {
            SerializeArray<foundation::UInt8ArrayWrapper,BYTE,&IPropertyValue::GetUInt8Array>(pPropertyValue,bos);
        }
        break;
    case PropertyType_Int16Array:
        {
            SerializeArray<foundation::Int16ArrayWrapper,INT16,&IPropertyValue::GetInt16Array>(pPropertyValue,bos);
        }
        break;
    case PropertyType_UInt16Array:
        {
            SerializeArray<foundation::UInt16ArrayWrapper,UINT16,&IPropertyValue::GetUInt16Array>(pPropertyValue,bos);
        }
        break;
    case PropertyType_Int32Array:
        {
            SerializeArray<foundation::Int32ArrayWrapper,INT32,&IPropertyValue::GetInt32Array>(pPropertyValue,bos);
        }
        break;
    case PropertyType_UInt32Array:
        {
            SerializeArray<foundation::UInt32ArrayWrapper,UINT32,&IPropertyValue::GetUInt32Array>(pPropertyValue,bos);
        }
        break;
    case PropertyType_Int64Array:
        {
            SerializeArray<foundation::Int64ArrayWrapper,INT64,&IPropertyValue::GetInt64Array>(pPropertyValue,bos);
        }
        break;
    case PropertyType_UInt64Array:
        {
            SerializeArray<foundation::UInt64ArrayWrapper,UINT64,&IPropertyValue::GetUInt64Array>(pPropertyValue,bos);
        }
        break;
    case PropertyType_SingleArray:
        {
            SerializeArray<foundation::SingleArrayWrapper,FLOAT,&IPropertyValue::GetSingleArray>(pPropertyValue,bos);
        }
        break;
    case PropertyType_DoubleArray:
        {
            SerializeArray<foundation::DoubleArrayWrapper,DOUBLE,&IPropertyValue::GetDoubleArray>(pPropertyValue,bos);
        }
        break;
    case PropertyType_BooleanArray:
        {
            SerializeArray<foundation::ArrayWrapper<boolean>,boolean,&IPropertyValue::GetBooleanArray>(pPropertyValue,bos);
        }
        break;
    case PropertyType_StringArray:
        {
            foundation::HStringArrayWrapper ArrayWrapper;
            IFR_ASSERT(pPropertyValue->GetStringArray(ArrayWrapper.GetSizeAddressOf(), ArrayWrapper.GetBufferAddressOf()));
            bos.serializeValue(ArrayWrapper.GetSize());
            for (UINT32 index = 0; index < ArrayWrapper.GetSize(); ++index)
            {
                bos.serializeString(_pal_GetStringRawBuffer(ArrayWrapper[index],nullptr));
            }
        }
        break;
    case PropertyType_DateTime:
        {
            foundation::DateTime dt;
            pPropertyValue->GetDateTime(&dt);
            bos.get_ostream().write((const char *)&dt,sizeof(foundation::DateTime));
        }
        break;
    case PropertyType_Inspectable:
    case PropertyType_TimeSpan:
    case PropertyType_Point:
    case PropertyType_Size:
    case PropertyType_Rect:
    default:
        foundation_assert(false);
        return E_NOTIMPL;
    }
    return S_OK;
}