/* ----------------------------------------------------------------------- *//**
 *
 * @file ConcreteType_impl.hpp
 *
 *//* ----------------------------------------------------------------------- */

template <typename T>
inline ConcreteType<T>::ConcreteType(const T &inValue)
: mValue(inValue) { }

template <typename T>
inline AbstractTypeSPtr ConcreteType<T>::getValueByID(uint16_t inID) const {
    if (inID > 0)
        throw std::out_of_range("Index out of bounds while accessing "
            "non-composite value");
    
    return AbstractTypeSPtr(new ConcreteType<T>(*this));
}


// Spezializations for ConcreteType<AnyTypeVector>

template <>
inline unsigned int ConcreteType<AnyTypeVector>::size() const {
    return mValue.size();
}

template <>
inline bool ConcreteType<AnyTypeVector>::isCompound() const {
    return true;
}

template <>
inline AbstractTypeSPtr ConcreteType<AnyTypeVector>::getValueByID(
    uint16_t inID) const {

    if (inID >= mValue.size())
        throw std::out_of_range("Index out of bounds while accessing "
            "composite value");
    
    return mValue[inID].mDelegate;
}


// Specializations to allow lossless imcplicit conversion

#define DECLARE_OR_DEFINE_STD_CONVERSION(x,y) \
    template <> \
    inline y ConcreteType<x >::getAs(y* /* pure type parameter */) const { \
        return mValue; \
    }

#define EXPAND_TYPE(T) \
    DECLARE_OR_DEFINE_STD_CONVERSION(T, T)

EXPAND_FOR_ALL_TYPES

#undef EXPAND_TYPE

// Additional implicit conversion to double
DECLARE_OR_DEFINE_STD_CONVERSION(float, double)
DECLARE_OR_DEFINE_STD_CONVERSION(int32_t, double)
DECLARE_OR_DEFINE_STD_CONVERSION(int16_t, double)
DECLARE_OR_DEFINE_STD_CONVERSION(int8_t, double)
DECLARE_OR_DEFINE_STD_CONVERSION(bool, double)

// Additional implicit conversion to float
DECLARE_OR_DEFINE_STD_CONVERSION(int16_t, float)
DECLARE_OR_DEFINE_STD_CONVERSION(int8_t, float)
DECLARE_OR_DEFINE_STD_CONVERSION(bool, float)

// Additional implicit conversion to int64_t
DECLARE_OR_DEFINE_STD_CONVERSION(int32_t, int64_t)
DECLARE_OR_DEFINE_STD_CONVERSION(int16_t, int64_t)
DECLARE_OR_DEFINE_STD_CONVERSION(int8_t, int64_t)
DECLARE_OR_DEFINE_STD_CONVERSION(bool, int64_t)

// Additional implicit conversion to int32_t
DECLARE_OR_DEFINE_STD_CONVERSION(int16_t, int32_t)
DECLARE_OR_DEFINE_STD_CONVERSION(int8_t, int32_t)
DECLARE_OR_DEFINE_STD_CONVERSION(bool, int32_t)

// Additional implicit conversion to int16_t
DECLARE_OR_DEFINE_STD_CONVERSION(int8_t, int16_t)
DECLARE_OR_DEFINE_STD_CONVERSION(bool, int16_t)

// Additional implicit conversion to int8_t
DECLARE_OR_DEFINE_STD_CONVERSION(bool, int8_t)

// Additional implicit conversion from Array<double>
DECLARE_OR_DEFINE_STD_CONVERSION(Array<double>, Array_const<double>)
DECLARE_OR_DEFINE_STD_CONVERSION(Array<double>, DoubleCol)
DECLARE_OR_DEFINE_STD_CONVERSION(Array<double>, DoubleCol_const)
DECLARE_OR_DEFINE_STD_CONVERSION(Array<double>, DoubleRow)
DECLARE_OR_DEFINE_STD_CONVERSION(Array<double>, DoubleRow_const)

// Additional implicit conversion from Array_const<double>
DECLARE_OR_DEFINE_STD_CONVERSION(Array_const<double>, DoubleCol_const)
DECLARE_OR_DEFINE_STD_CONVERSION(Array_const<double>, DoubleRow_const)

// FIXME: We might want to add detailed error messages when converting immutable
// into mutable type. Right now, the standard error msg will be displayed.

#undef DECLARE_OR_DEFINE_STD_CONVERSION

template <>
inline bool ConcreteType<Array_const<double> >::isMutable() const {
    return false;
}

template <>
inline AbstractTypeSPtr ConcreteType<Array_const<double> >::clone() const {
    return
        AbstractTypeSPtr(
            new ConcreteType<Array<double> >(
                Array<double>(
                    mValue.memoryHandle()->clone(), 
                    utils::shapeToExtents<1>(mValue.shape())
                )
            )
        );
}