include/value/pair_traits.hpp

Go to the documentation of this file.

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

#include "value/pair.hpp"
#include "value/value_traits.hpp"

namespace aitools {
namespace value {

// -----------------------------------------------------------------------------
// Partial specialization for pair<T1, T2>
// -----------------------------------------------------------------------------

template <typename T1, typename T2>
struct value_traits<pair<T1, T2> >
{
        typedef pair<T1, T2> value_type;
        typedef uint16_t     io_size_type;

        static size_t
        size_of(const value_type& pair)
        {
                return
                        value_traits<T1>::size_of(pair.e1()) +
                        value_traits<T2>::size_of(pair.e2());
        }

        static char*
        copy_to(const value_type& pair, char* buffer)
        {
                buffer = value_traits<T1>::copy_to(pair.e1(), buffer);
                return   value_traits<T2>::copy_to(pair.e2(), buffer);
        }

        static const char*
        copy_from(value_type& pair, const char* buffer)
        {
                buffer = value_traits<T1>::copy_from(pair.e1(), buffer);
                return   value_traits<T2>::copy_from(pair.e2(), buffer);
        }

        static bool
        write_to(const value_type& pair, FILE* file)
        {
                return
                        value_traits<T1>::write_to(pair.e1(), file) &&
                        value_traits<T2>::write_to(pair.e2(), file);
        }

        static bool
        read_from(value_type& pair, FILE* file)
        {
                return
                        value_traits<T1>::read_from(pair.e1(), file) &&
                        value_traits<T2>::read_from(pair.e2(), file);
        }

        static bool
        print_to(const value_type& pair, std::ostream& os)
        {
                return
                        value_traits<T1>::print_to(pair.e1(), os) &&
                        (os << ' ') && // do not use value_traits<char>::print_to here
                        value_traits<T2>::print_to(pair.e2(), os);
        }

        static bool
        println_to(const value_type& pair, std::ostream& os)
        {
                // do not use value_traits<char>::print_to here
                return print_to(pair, os) && (os << '\n');
        }

        static bool
        parse_from(value_type& pair, std::istream& is)
        {
                return
                        value_traits<T1>::parse_from(pair.e1(), is) &&
                        value_traits<T2>::parse_from(pair.e2(), is);
        }

        static std::string
        type_name()
        {
                std::string name("pair<");
                name += value_traits<T1>::type_name();
                name += ", ";
                name += value_traits<T2>::type_name();
                name += '>';
                return name;
        }
};

// -----------------------------------------------------------------------------
// Operators
// -----------------------------------------------------------------------------

template <typename T1, typename T2>
std::ostream&
operator<<(std::ostream& os, const pair<T1, T2>& value)
{
        if (os) value_traits<pair<T1, T2> >::print_to(value, os);
        return os;
}

} // namespace value

using value::value_traits;

} // namespace aitools

#endif // AITOOLS_VALUE_PAIR_TRAITS_HPP

---