include/value/value_traits.hpp

Go to the documentation of this file.

// value_traits.hpp -*- C++ -*-
// Copyright (C) 2011 Martin Trenkmann
#ifndef AITOOLS_VALUE_SINGLE_TRAITS_HPP
#define AITOOLS_VALUE_SINGLE_TRAITS_HPP

#include <string>
#include <cstring>
#include <iostream>
#include <boost/utility.hpp>
#include <boost/type_traits.hpp>
#include <boost/mpl/not.hpp>

namespace aitools {
namespace value {

// -----------------------------------------------------------------------------
// value::single to std::string conversion
// -----------------------------------------------------------------------------

// the 'dummy' value is just to comply a
// unique function signature for the compiler

template <typename T>
inline std::string
name_of(T dummy = T());

template <>
inline std::string
name_of(int8_t dummy)
{
        return "int8_t";
}

template <>
inline std::string
name_of(int16_t dummy)
{
        return "int16_t";
}

template <>
inline std::string
name_of(int32_t dummy)
{
        return "int32_t";
}

template <>
inline std::string
name_of(int64_t dummy)
{
        return "int64_t";
}

template <>
inline std::string
name_of(uint8_t dummy)
{
        return "uint8_t";
}

template <>
inline std::string
name_of(uint16_t dummy)
{
        return "uint16_t";
}

template <>
inline std::string
name_of(uint32_t dummy)
{
        return "uint32_t";
}

template <>
inline std::string
name_of(uint64_t dummy)
{
        return "uint64_t";
}

template <>
inline std::string
name_of(float dummy)
{
        return "float";
}

template <>
inline std::string
name_of(double dummy)
{
        return "double";
}

// -----------------------------------------------------------------------------
// Primary template for arithmetic types (boolean, int, float, double)
// -----------------------------------------------------------------------------

template <typename T>
inline bool
print_to_os(T value, std::ostream& os)
{
        return os << value;
}

// It's safer to overload a function, rather than specializing the template.
// (http://www.gotw.ca/publications/mill17.htm)
inline bool
print_to_os(int8_t value, std::ostream& os)
{
        return os << static_cast<int16_t>(value);
}

// It's safer to overload a function, rather than specializing the template.
// (http://www.gotw.ca/publications/mill17.htm)
inline bool
print_to_os(uint8_t value, std::ostream& os)
{
        return os << static_cast<uint16_t>(value);
}

template <typename T>
struct value_traits
{
        typedef typename boost::enable_if<
                        boost::is_arithmetic<T>, T>::type value_type;
        typedef uint16_t io_size_type; // not needed for types with constant size

        static size_t
        size_of(const value_type& value)
        {
                return sizeof(value);
        }

        static char*
        copy_to(const value_type& value, char* buffer)
        {
                std::memcpy(buffer, &value, sizeof(value));
                return buffer + sizeof(value);
        }

        static const char*
        copy_from(value_type& value, const char* buffer)
        {
                std::memcpy(&value, buffer, sizeof(value));
                return buffer + sizeof(value);
        }

        static bool
        write_to(const value_type& value, FILE* file)
        {
                return std::fwrite(&value, sizeof(value), 1, file) == 1;
        }

        static bool
        read_from(value_type& value, FILE* file)
        {
                return std::fread(&value, sizeof(value), 1, file) == 1;
        }

        static bool
        print_to(const value_type& value, std::ostream& os)
        {
                return print_to_os(value, os);
        }

        static bool
        println_to(const value_type& value, std::ostream& os)
        {
                print_to(value, os);
                return os << '\n';
        }

        static bool
        parse_from(value_type& value, std::istream& is)
        {
                return is >> value;
        }

        static std::string
        type_name()
        {
                return name_of<value_type>();
        }
};

} // namespace value

using value::value_traits;

} // namespace aitools

#endif // AITOOLS_VALUE_SINGLE_TRAITS_HPP

---