#ifndef TYPE_H_
#define TYPE_H_

#include <framework/returnvalues/HasReturnvaluesIF.h>
#include <framework/serialize/SerializeIF.h>

class Type: public SerializeIF {
public:
	enum ActualType_t {
		UINT8_T,
		INT8_T,
		UINT16_T,
		INT16_T,
		UINT32_T,
		INT32_T,
		FLOAT,
		DOUBLE,
		UNKNOWN_TYPE
	};

	Type();

	Type(ActualType_t actualType);

	Type(const Type& type);

	Type& operator=(Type rhs);

	Type& operator=(ActualType_t actualType);

	operator ActualType_t() const;

	bool operator==(const Type& rhs);
	bool operator!=(const Type& rhs);

	uint8_t getSize() const;

	ReturnValue_t getPtcPfc(uint8_t *ptc, uint8_t *pfc) const;

	static ActualType_t getActualType(uint8_t ptc, uint8_t pfc);

	virtual ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
			const uint32_t max_size, bool bigEndian) const;

	virtual uint32_t getSerializedSize() const;

	virtual ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
			bool bigEndian);

private:
	ActualType_t actualType;
};

template<typename T>
struct PodTypeConversion {
	static const Type::ActualType_t type = Type::UNKNOWN_TYPE;
};
template<>
struct PodTypeConversion<uint8_t> {
	static const Type::ActualType_t type = Type::UINT8_T;
};
template<>
struct PodTypeConversion<uint16_t> {
	static const Type::ActualType_t type = Type::UINT16_T;
};
template<>
struct PodTypeConversion<uint32_t> {
	static const Type::ActualType_t type = Type::UINT32_T;
};
template<>
struct PodTypeConversion<int8_t> {
	static const Type::ActualType_t type = Type::INT8_T;
};
template<>
struct PodTypeConversion<int16_t> {
	static const Type::ActualType_t type = Type::INT16_T;
};
template<>
struct PodTypeConversion<int32_t> {
	static const Type::ActualType_t type = Type::INT32_T;
};
template<>
struct PodTypeConversion<float> {
	static const Type::ActualType_t type = Type::FLOAT;
};
template<>
struct PodTypeConversion<double> {
	static const Type::ActualType_t type = Type::DOUBLE;
};

#endif /* TYPE_H_ */