include/value/quadruple_traits.hpp

Go to the documentation of this file.

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

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

namespace aitools {
namespace value {

// -----------------------------------------------------------------------------
// Partial specialization for quadruple<T1, T2, T3, T4>
// -----------------------------------------------------------------------------

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

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

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

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

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

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

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

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

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

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

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

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

} // namespace value

using value::value_traits;

} // namespace aitools

#endif // AITOOLS_VALUE_QUADRUPLE_TRAITS_HPP

---