All input/output operators are confined to this namespace. More...

Functions
template<typename D >
std::ostream &	operator<< (std::ostream &s, const Ask_Tell< D > &x)

template<typename Row >
std::ostream &	operator<< (std::ostream &s, const Linear_Expression_Impl< Row > &e)

std::ostream &	operator<< (std::ostream &os, const PIP_Tree_Node &x)

std::ostream &	operator<< (std::ostream &os, const PIP_Tree_Node::Artificial_Parameter &x)

std::string	wrap_string (const std::string &src_string, unsigned indent_depth, unsigned preferred_first_line_length, unsigned preferred_line_length)
	Utility function for the wrapping of lines of text. More...

Detailed Description

All input/output operators are confined to this namespace.

This is done so that the library's input/output operators do not interfere with those the user might want to define. In fact, it is highly unlikely that any predefined I/O operator will suit the needs of a client application. On the other hand, those applications for which the PPL I/O operator are enough can easily obtain access to them. For example, a directive like

using namespace Parma_Polyhedra_Library::IO_Operators;

would suffice for most uses. In more complex situations, such as

const Constraint_System& cs = ...;
copy(cs.begin(), cs.end(),
     ostream_iterator<Constraint>(cout, "\n"));

the Parma_Polyhedra_Library namespace must be suitably extended. This can be done as follows:

namespace Parma_Polyhedra_Library {
  // Import all the output operators into the main PPL namespace.
  using IO_Operators::operator<<;
}

Function Documentation

template<typename D >

std::ostream& Parma_Polyhedra_Library::IO_Operators::operator<<	(	std::ostream &	s,
		const Ask_Tell< D > &	x
	)

Referenced by Parma_Polyhedra_Library::Grid_Generator::fancy_print(), Parma_Polyhedra_Library::Generator::fancy_print(), and Parma_Polyhedra_Library::Linear_Expression_Impl< Row >::print().

                                                 {
   if (x.is_top()) {
     s << "true";
   }
   else if (x.is_bottom()) {
     s << "false";
   }
   else {
     for (typename Ask_Tell<D>::const_iterator xi = x.begin(),
            x_end = x.end(); xi != x_end; ++xi)
       s << "(" << xi->ask() << " -> " << xi->tell() << ")";
   }
   return s;
 }

template<typename Row >

std::ostream& Parma_Polyhedra_Library::IO_Operators::operator<<	(	std::ostream &	s,
		const Linear_Expression_Impl< Row > &	e
	)

                                                                 {
   e.print(s);
   return s;
 }

std::ostream& Parma_Polyhedra_Library::IO_Operators::operator<<	(	std::ostream &	os,
		const PIP_Tree_Node &	x
	)

References Parma_Polyhedra_Library::PIP_Tree_Node::print().

                                                    {
   x.print(os);
   return os;
 }

std::ostream& Parma_Polyhedra_Library::IO_Operators::operator<<	(	std::ostream &	os,
		const PIP_Tree_Node::Artificial_Parameter &	x
	)

References Parma_Polyhedra_Library::PIP_Tree_Node::Artificial_Parameter::denominator().

                                                                        {
   const Linear_Expression& expr = static_cast<const Linear_Expression&>(x);
   os << "(" << expr << ") div " << x.denominator();
   return os;
 }

std::string Parma_Polyhedra_Library::IO_Operators::wrap_string	(	const std::string &	src_string,
		unsigned	indent_depth,
		unsigned	preferred_first_line_length,
		unsigned	preferred_line_length
	)

Utility function for the wrapping of lines of text.

Parameters

src_string	The source string holding the lines to wrap.
indent_depth	The indentation depth.
preferred_first_line_length	The preferred length for the first line of text.
preferred_line_length	The preferred length for all the lines but the first one.

Returns: The wrapped string.

Definition at line 34 of file wrap_string.cc.

References Parma_Polyhedra_Library::is_space().

                                                   {
   const unsigned npos = C_Integer<unsigned>::max;
   std::string dst_string;
   const char *src = src_string.c_str();
   for (unsigned line = 0; ; ++line) {
     const unsigned line_length = ((line == 0)
                                   ? preferred_first_line_length
                                   : preferred_line_length);
     unsigned last_comma = npos;
     unsigned last_space = npos;
     unsigned split_pos = npos;
     unsigned idx;
     for (idx = 0; idx <= line_length; ++idx) {
       if (src[idx] == '\0' || src[idx] == '\n') {
         split_pos = idx;
         break;
       }
       if (src[idx] == ',' && idx < line_length) {
         last_comma = idx;
       }
       if (is_space(src[idx]) && (idx == 0 || !is_space(src[idx-1]))) {
         last_space = idx;
       }
     }
     if (split_pos == npos) {
       if (last_comma != npos) {
         split_pos = last_comma + 1;
       }
       else if (last_space != npos) {
         split_pos = last_space;
       }
       else {
         for ( ; src[idx] != '\0'; ++idx) {
           if (src[idx] == ',') {
             ++idx;
             break;
           }
           if (is_space(src[idx])) {
             break;
           }
         }
         split_pos = idx;
       }
     }
     PPL_ASSERT(split_pos != npos);
     if (split_pos > 0 && line > 0 && indent_depth > 0) {
       dst_string.append(indent_depth, ' ');
     }
     dst_string.append(src, split_pos);
     src += split_pos;
     if (is_space(*src)) {
       ++src;
     }
     while (*src == ' ') {
       ++src;
     }
     if (*src == '\0') {
       break;
     }
     dst_string.push_back('\n');
   }
   return dst_string;
 }

Functions

Detailed Description

Function Documentation