include/value/triple_traits.hpp

Go to the documentation of this file.

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

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

namespace aitools {
namespace value {

// -----------------------------------------------------------------------------
// Partial specialization for triple<T1, T2, T3>
// -----------------------------------------------------------------------------

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

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

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

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

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

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

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

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

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

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

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

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

} // namespace value

using value::value_traits;

} // namespace aitools

#endif // AITOOLS_VALUE_TRIPLE_TRAITS_HPP

---