ValueType.hpp

/*
 *  Copyright 2013 Lukas Jirkovsky
 *
 *  This file is part of FotoSHOCKcore.
 *
 *  FotoSHOCKcore is free software: you can redistribute it and/or modify it
 *  under the terms of the GNU Lesser General Public License as published by
 *  the Free Software Foundation, version 3 of the License.
 *
 *  FotoSHOCKcore is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU Lesser General Public License for more details.
 *
 *  You should have received a copy of the GNU Lesser General Public License
 *  along with FotoSHOCKcore.  If not, see <http://www.gnu.org/licenses/>.
 */

#ifndef VALUETYPE_H
#define VALUETYPE_H

#include "ColorSpace.hpp"

#include <stdint.h>
#include <limits>

namespace FotoSHOCKcore {


class ValueType {
public:
    enum Enum {value_ANY, value_ANYINT, value_ANYFLOAT, value_SAME,
               value_uint1, value_uint8, value_uint16, value_uint32, value_uint64,
               value_float, value_double};

    friend class ValueTypeEnum;


    ValueType()
    : m_ID(value_ANY), m_bits(0), m_formatter(0) {}
    ValueType(const ValueType& other) = default;
    ValueType& operator=(const ValueType& other) = default;

    bool operator==(const ValueType& other) {return m_ID == other.m_ID;};
    bool operator!=(const ValueType& other) {return !(*this == other);};


    constexpr operator Enum() const {return m_ID;};
    constexpr unsigned int bits() const {return m_bits;};
    constexpr cmsUInt32Number cmsFormatter() const {return m_formatter;};
protected:
    constexpr ValueType(const Enum v, const unsigned int bit, const cmsUInt32Number formatter)
    : m_ID(v), m_bits(bit), m_formatter(formatter) {}
private:
    Enum m_ID;
    unsigned int m_bits;
    cmsUInt32Number m_formatter;
};


class ValueTypeEnum {
public:
    static constexpr ValueType ANY = ValueType(ValueType::value_ANY, 0, 0);
    static constexpr ValueType ANYINT = ValueType(ValueType::value_ANYINT, 0, 0);
    static constexpr ValueType ANYFLOAT = ValueType(ValueType::value_ANYFLOAT, 0, 0);
    static constexpr ValueType SAME = ValueType(ValueType::value_SAME, 0, 0);

    static constexpr ValueType uint1 = ValueType(ValueType::value_uint1, 1, BYTES_SH(sizeof(bool)));
    static constexpr ValueType uint8 = ValueType(ValueType::value_uint8, 8, BYTES_SH(sizeof(uint8_t)));
    static constexpr ValueType uint16 = ValueType(ValueType::value_uint16, 16, BYTES_SH(sizeof(uint16_t)));
    static constexpr ValueType uint32 = ValueType(ValueType::value_uint32, 32, BYTES_SH(sizeof(uint32_t)));
    static constexpr ValueType uint64 = ValueType(ValueType::value_uint64, 64, BYTES_SH(sizeof(uint64_t)));

    static constexpr ValueType floatval = ValueType(ValueType::value_float, 32, FLOAT_SH(1) | BYTES_SH(4));
    static constexpr ValueType doubleval = ValueType(ValueType::value_double, 64, FLOAT_SH(1) | BYTES_SH(0));
};


template <typename ValueDataType>
class ValueTypeInfoBase {
    public:
        typedef ValueDataType Type;

        static const Type min() {
            return std::numeric_limits<ValueDataType>::min();
        }
        static const Type max() {
            return std::numeric_limits<ValueDataType>::max();
        }
};


template <ValueType::Enum format>
class ValueTypeInfo {
};

template <>
class ValueTypeInfo<ValueType::value_uint1> : public ValueTypeInfoBase<bool> {
    public:
        typedef int_fast8_t SignedPromote;
        typedef uint_fast8_t UnsignedPromote;
};

template <>
class ValueTypeInfo<ValueType::value_uint8> : public ValueTypeInfoBase<uint8_t> {
    public:
        typedef int_fast16_t SignedPromote;
        typedef uint_fast16_t UnsignedPromote;
};

template <>
class ValueTypeInfo<ValueType::value_uint16> : public ValueTypeInfoBase<uint16_t> {
    public:
        typedef int_fast32_t SignedPromote;
        typedef uint_fast32_t UnsignedPromote;
};

template <>
class ValueTypeInfo<ValueType::value_uint32> : public ValueTypeInfoBase<uint32_t> {
    public:
        typedef int_fast64_t SignedPromote;
        typedef uint_fast64_t UnsignedPromote;
};

template <>
class ValueTypeInfo<ValueType::value_uint64> : public ValueTypeInfoBase<uint64_t> {
    public:
        typedef int_fast64_t SignedPromote;
        typedef uint_fast64_t UnsignedPromote;
};

template <>
class ValueTypeInfo<ValueType::value_float> : public ValueTypeInfoBase<float> {
    public:
        typedef double SignedPromote;
        typedef double UnsignedPromote;
};

template <>
class ValueTypeInfo<ValueType::value_double> : public ValueTypeInfoBase<double> {
    public:
        typedef double SignedPromote;
        typedef double UnsignedPromote;
};


#define case_ANYINT \
    case FotoSHOCKcore::ValueType::value_uint1: \
        FORMAT_DO_STH(FotoSHOCKcore::ValueTypeEnum::uint1, FotoSHOCKcore::ValueTypeInfo<FotoSHOCKcore::ValueType::value_uint1>::Type); \
        break; \
    case FotoSHOCKcore::ValueType::value_uint8: \
        FORMAT_DO_STH(FotoSHOCKcore::ValueTypeEnum::uint8, FotoSHOCKcore::ValueTypeInfo<FotoSHOCKcore::ValueType::value_uint8>::Type); \
        break; \
    case FotoSHOCKcore::ValueType::value_uint16: \
        FORMAT_DO_STH(FotoSHOCKcore::ValueTypeEnum::uint16, FotoSHOCKcore::ValueTypeInfo<FotoSHOCKcore::ValueType::value_uint16>::Type); \
        break; \
    case FotoSHOCKcore::ValueType::value_uint32: \
        FORMAT_DO_STH(FotoSHOCKcore::ValueTypeEnum::uint32, FotoSHOCKcore::ValueTypeInfo<FotoSHOCKcore::ValueType::value_uint32>::Type); \
        break; \
    case FotoSHOCKcore::ValueType::value_uint64: \
        FORMAT_DO_STH(FotoSHOCKcore::ValueTypeEnum::uint64, FotoSHOCKcore::ValueTypeInfo<FotoSHOCKcore::ValueType::value_uint64>::Type); \
        break


#define case_ANYFLOAT \
    case FotoSHOCKcore::ValueType::value_float: \
        FORMAT_DO_STH(FotoSHOCKcore::ValueTypeEnum::floatval, FotoSHOCKcore::ValueTypeInfo<FotoSHOCKcore::ValueType::value_float>::Type); \
        break; \
    case FotoSHOCKcore::ValueType::value_double: \
        FORMAT_DO_STH(FotoSHOCKcore::ValueTypeEnum::doubleval, FotoSHOCKcore::ValueTypeInfo<FotoSHOCKcore::ValueType::value_double>::Type); \
        break


#define case_ANY \
    case_ANYINT; \
    case_ANYFLOAT; \
    default: \
    break

}

#endif