AnimaL

Tutorial

Documentation

---

Documentation

• Overview
• Modules
• Namespace List
• Class Hierarchy
• Alphabetical List
• Compound List
• File List
• Namespace Members
• Compound Members
• File Members
• Examples

---

io.h

Go to the documentation of this file.

#ifndef ___animal_io_h____
#define ___animal_io_h____

// debug Frank Perbet 2001/07/17
// BEFORE:
// #ifdef STDTREAMS
// #include <iostream>
// #else
// #include <iostream.h>
// #endif
// NOW:
#include <iostream>
#include <utility>
// fin debug Frank Perbet 2001/07/17
#include <animal/container_traits.h>  
using std::cout;
using std::cerr;
using std::cin;
using std::endl;


namespace animal 
{

template<class T>
struct v_Output
{
    const T& t;  
    char* sep; 
    
    v_Output( const T& t, char* s ):t(t),sep(s){}
};

template<class T>
struct v_Input
{
    T& t;  
    
    v_Input( T& t):t(t){}
};


template<class T>
struct m_Output
{
    const T& t; 
    
    m_Output( const T& t):t(t){}
};

template<class T>
struct m_Input
{
    T& t; 
    
    m_Input( T& t):t(t){}
};



//==================================================================



template<class Container>
void print( const Container& container)
{
    typename Container::const_iterator c=container.begin(),
                                     end=container.end();
    for( ; c!=end; ++c )
        std::cout << *c << " ";
    std::cout << endl;
}

template<class Container>
void print( const Container& container, std::ostream& out)
{
    typename Container::const_iterator c=container.begin(),
                                     end=container.end();
    for( ; c!=end; ++c )
        out << *c << " ";
    out << endl;
}



template<class T>
v_Output<T>
v_output( const T& t, char* s=" " ) { return v_Output<T>(t,s); }

template<class T>
std::ostream& operator << (std::ostream& out, v_Output<T> ot ) 
{
    for( typename container_traits<T const>::iterator i=begin(ot.t), aend=end(ot.t); i!=aend; ++i )
        out << *i << ot.sep;
    return out; 
}

template<class T>
v_Input<T>
v_input( T& t ) { return v_Input<T>(t); }

template<class T>
std::istream& operator >> (std::istream& in, v_Input<T> it )
{
    for( typename container_traits<T>::iterator i=begin(it.t), iend=end(it.t); i!=iend; ++i )
        in >> *i;
    return in;
}



template<class T>
m_Output<T>
m_output( const T& t ) { return m_Output<T>(t); }

template<class T>
std::ostream& operator << (std::ostream& out, m_Output<T> ot ) 
{
    for( typename container_traits<T const>::iterator i=begin(ot.t), aend=end(ot.t); i!=aend; ++i )
        out << "\n" << v_output(*i) ;
    return out; 
}

template<class T>
m_Input<T>
m_input( T& t ) { return m_Input<T>(t); }

template<class T>
std::istream& operator >> (std::istream& in, m_Input<T> it )
{
    for( typename container_traits<T>::iterator i=begin(it.t), iend=end(it.t); i!=iend; ++i )
        in >> v_input(*i);
    return in;
}

//  vector and matrix input/output
//==================================================================

template<class C1,class C2>
std::ostream& operator << (std::ostream& out, const std::pair<C1,C2>& p )
{
    out << "( " <<p.first<<","<<p.second<<" )";
    return out;
}

template<class C1,class C2>
std::istream& operator >> (std::istream& in, std::pair<C1,C2>& p )
{
    in >> p.first >> p.second;
    return in;
}

}//animal

#endif

---