Vector.h

/*
This file is part of Hummingbird, a modern user interface library.

Copyright (c) 2012-2017 Coherent Labs AD and/or its licensors. All
rights reserved in all media.

The coded instructions, statements, computer programs, and/or related
material (collectively the "Data") in these files contain confidential
and unpublished information proprietary Coherent Labs and/or its
licensors, which is protected by United States of America federal
copyright law and by international treaties.

This software or source code is supplied under the terms of a license
agreement and nondisclosure agreement with Coherent Labs AD and may
not be copied, disclosed, or exploited except in accordance with the
terms of that agreement. The Data may not be disclosed or distributed to
third parties, in whole or in part, without the prior written consent of
Coherent Labs AD.

COHERENT LABS MAKES NO REPRESENTATION ABOUT THE SUITABILITY OF THIS
SOURCE CODE FOR ANY PURPOSE. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT
HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE
ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER, ITS AFFILIATES,
PARENT COMPANIES, LICENSORS, SUPPLIERS, OR CONTRIBUTORS BE LIABLE FOR
ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
ANY WAY OUT OF THE USE OR PERFORMANCE OF THIS SOFTWARE OR SOURCE CODE,
EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#pragma once
#include "Property.h"

namespace cohtml
{
class Binder;

template <typename VectorType>
void CoherentVectorElementReader(Binder* binder, void* data, size_t position)
{
    auto castedData = (VectorType*)data;
    CoherentReadInternal(binder, castedData[position]);
}

template <typename VectorType>
void* CoherentVectorNativeElementReader(void* data, size_t position)
{
    return &(*(VectorType*)data)[position];
}

template <typename VectorType>
size_t CoherentVectorLength(void* data)
{
    return ((VectorType*)data)->size();
}

template <typename VectorType, typename T>
typename EnableIf<!cohtml::PointerTrait<T>::Value, void>::Type CoherentVectorElementReader(Binder* binder, void* data, size_t position)
{
    CoherentReadInternal(binder, (*(VectorType*)data)[position]);
}

template <typename VectorType, typename T>
typename EnableIf<cohtml::PointerTrait<T>::Value, void>::Type CoherentVectorElementReader(Binder* binder, void* data, size_t position)
{
    typedef typename UnwrapPointerType<T, PointerTrait<T>::Value>::Type UnwrappedType;

    if (auto unwrappedObjectPtr = (UnwrappedType*)UnwrapPointer<T>::Unwrap(&(*(VectorType*)data)[position]))
    {
        CoherentReadInternal(binder, *unwrappedObjectPtr);
    }
}

template <typename VectorType, typename T>
typename EnableIf<!cohtml::PointerTrait<T>::Value, void*>::Type CoherentVectorNativeElementReader(void* data, size_t position)
{
    return &(*(VectorType*)data)[position];
}

template <typename VectorType, typename T>
typename EnableIf<cohtml::PointerTrait<T>::Value, void*>::Type CoherentVectorNativeElementReader(void* data, size_t position)
{
    return UnwrapPointer<T>::Unwrap(&(*(VectorType*)data)[position]);
}

typedef void(*Reader)(Binder*, void*, size_t);
typedef void*(*NativeReader)(void*, size_t);
typedef size_t(*VectorLengthFunc)(void*);

template <typename T>
class VectorReaderFactory
{
public:
    static Reader ElementReader()
    {
        return cohtml::CoherentVectorElementReader<T>;
    }

    static NativeReader NativeElementReader()
    {
        return cohtml::CoherentVectorNativeElementReader<T>;
    }

    static VectorLengthFunc VectorLength()
    {
        return CoherentVectorLength<T>;
    }
};

template <typename T, typename A>
class VectorReaderFactory<std::vector<T, A>>
{
public:
    typedef std::vector<T, A> VectorType;

    static Reader ElementReader()
    {
        return cohtml::CoherentVectorElementReader<VectorType, T>;
    }

    static NativeReader NativeElementReader()
    {
        return cohtml::CoherentVectorNativeElementReader<VectorType, T>;
    }

    static VectorLengthFunc VectorLength()
    {
        return CoherentVectorLength<VectorType>;
    }
};

template <typename VectorType>
void CoherentVectorElementBinder(Binder* binder, void* arr, size_t index)
{
    auto castedArray = (VectorType*)arr;
    if (arr)
    {
        CoherentBindInternal(binder, castedArray[index]);
    }
    else
    {
        binder->BindNull();
    }
}

template <typename T, typename A>
void CoherentBindInternal(Binder* binder, std::vector<T, A>& value)
{
    if (!binder->TryBindArrayByRef(value.data(),
        value.size(),
        CoherentVectorElementBinder<T>,
        VectorReaderFactory<std::vector<T, A>>::ElementReader()))
    {
        binder->ArrayBegin(value.size());
        typedef typename std::vector<T, A>::const_iterator Iterator;

        Iterator end = value.end();
        for (Iterator i = value.begin(); i != end; ++i)
        {
            CoherentBindInternal(binder, *i);
        }

        binder->ArrayEnd();
    }
}

template <typename T, typename A>
void CoherentBindInternal(Binder* binder, const std::vector<T, A>& value)
{
    if (!binder->TryBindArrayByRef(const_cast<T*>(value.data()),
        value.size(),
        CoherentVectorElementBinder<T>,
        VectorReaderFactory<std::vector<T, A>>::ElementReader()))
    {
        binder->ArrayBegin(value.size());
        typedef typename std::vector<T, A>::const_iterator Iterator;

        Iterator end = value.end();
        for (Iterator i = value.begin(); i != end; ++i)
        {
            CoherentBindInternal(binder, *i);
        }

        binder->ArrayEnd();
    }
}

template <typename A>
void CoherentBindInternal(Binder* binder, std::vector<float, A>& value)
{
    if (!binder->TryBindArrayByRef(value.data(),
        value.size(),
        CoherentVectorElementBinder<float>,
        VectorReaderFactory<float>::ElementReader()))
    {
        binder->BindArray(&value[0], value.size());
    }
}

template <typename A>
void CoherentBindInternal(Binder* binder, const std::vector<float, A>& value)
{
    if (!binder->TryBindArrayByRef(const_cast<float*>(value.data()),
        value.size(),
        CoherentVectorElementBinder<float>,
        VectorReaderFactory<float>::ElementReader()))
    {
        binder->BindArray(&value[0], value.size());
    }
}

template <typename A>
void CoherentBindInternal(Binder* binder, std::vector<int, A>& value)
{
    if (!binder->TryBindArrayByRef(value.data(),
        value.size(),
        CoherentVectorElementBinder<int>,
        VectorReaderFactory<int>::ElementReader()))
    {
        binder->BindArray(&value[0], value.size());
    }
}

template <typename A>
void CoherentBindInternal(Binder* binder, const std::vector<int, A>& value)
{
    if (!binder->TryBindArrayByRef(const_cast<int*>(value.data()),
        value.size(),
        CoherentVectorElementBinder<int>,
        VectorReaderFactory<int>::ElementReader()))
    {
        binder->BindArray(&value[0], value.size());
    }
}

template <typename T, typename A>
void CoherentReadInternal(Binder* binder, std::vector<T, A>& value)
{
    typedef typename std::vector<T, A>::iterator Iterator;

    size_t size = binder->ReadArrayBegin();

    value.resize(size);

    Iterator end = value.end();
    size_t index = 0;
    for (Iterator i = value.begin(); i != end; ++i)
    {
        binder->ReadArrayElement(index++);
        CoherentReadInternal(binder, *i);
    }

    binder->ReadArrayEnd();
}

template<typename T, typename A>
struct TypeToElementType<const std::vector<T, A>>
{
    static constexpr ElementType value = ElementType::ET_Array;
};

template<typename T, typename A>
struct TypeToElementType<std::vector<T, A>>
{
    static constexpr ElementType value = ElementType::ET_Array;
};

template<typename T, typename A>
struct TypeToElementType<std::vector<T, A>&>
{
    static constexpr ElementType value = ElementType::ET_Array;
};

template<typename T, typename A>
struct TypeToElementType<const std::vector<T, A>&>
{
    static constexpr ElementType value = ElementType::ET_Array;
};

template <typename T>
struct IsVector : FalseType
{
    typedef T ElementType;
    typedef T AllocatorType;
};

template <typename T, typename A>
struct IsVector<std::vector<T, A>> : TrueType
{
    typedef T ElementType;
    typedef A AllocatorType;
};

template <typename T>
typename EnableIf<!IsVector<typename UnwrapPointerType<T, PointerTrait<T>::Value>::Type>::Value, bool>::Type
    GetArrayValueInvoke(Binder* binder, void* object, ArrayInfo* arrayInfo, const TypedProperty<const T&>* prop)
{
    UNUSED_PARAM(binder);
    UNUSED_PARAM(object);
    UNUSED_PARAM(arrayInfo);
    UNUSED_PARAM(prop);
    return false;
}

template <typename T>
typename EnableIf<!IsVector<typename UnwrapPointerType<T, PointerTrait<T>::Value>::Type>::Value, bool>::Type
    GetArrayValueInvoke(Binder* binder, void* object, ArrayInfo* arrayInfo, const TypedProperty<T&>* prop)
{
    UNUSED_PARAM(binder);
    UNUSED_PARAM(object);
    UNUSED_PARAM(arrayInfo);
    UNUSED_PARAM(prop);
    return false;
}

template <typename T, typename A>
bool GetArrayValueInvoke(Binder* binder, ArrayInfo* arrayInfo, std::vector<T, A>* pVector)
{
    if (!pVector)
    {
        return false;
    }

    *arrayInfo = ArrayInfo{
        TypeToElementType<T>::value,
        VectorReaderFactory<std::vector<T, A>>::VectorLength(),
        VectorReaderFactory<std::vector<T, A>>::NativeElementReader(),
        CoherentTypeInfo<T>::Get(binder),
        pVector
    };

    return true;
}

template <typename T>
typename EnableIf<IsVector<typename UnwrapPointerType<T, PointerTrait<T>::Value>::Type>::Value, bool>::Type
    GetArrayValueInvoke(Binder* binder, void* object, ArrayInfo* arrayInfo, const TypedProperty<const T&>* prop)
{
    typedef typename UnwrapPointerType<T, PointerTrait<T>::Value>::Type UnwrappedType;
    auto pVector = (UnwrappedType*)UnwrapPointer<T>::Unwrap(const_cast<T*>(&prop->GetValue(object)));

    return GetArrayValueInvoke(binder, arrayInfo, pVector);
}

template <typename T>
typename EnableIf<IsVector<typename UnwrapPointerType<T, PointerTrait<T>::Value>::Type>::Value, bool>::Type
    GetArrayValueInvoke(Binder* binder, void* object, ArrayInfo* arrayInfo, const TypedProperty<T&>* prop)
{
    typedef typename UnwrapPointerType<T, PointerTrait<T>::Value>::Type UnwrappedType;
    auto pVector = (UnwrappedType*)UnwrapPointer<T>::Unwrap(const_cast<T*>(&prop->GetValue(object)));

    return GetArrayValueInvoke(binder, arrayInfo, pVector);
}

template<typename T>
struct GetArrayValue<const T&>
{
    static bool Invoke(Binder* binder, void* object, ArrayInfo* arrayInfo, const TypedProperty<const T&>* prop)
    {
        return GetArrayValueInvoke(binder, object, arrayInfo, prop);
    }
};

template<typename T>
struct GetArrayValue<T&>
{
    static bool Invoke(Binder* binder, void* object, ArrayInfo* arrayInfo, const TypedProperty<T&>* prop)
    {
        return GetArrayValueInvoke(binder, object, arrayInfo, prop);
    }
};

}