include/dlvhex2/Printhelpers.h

Go to the documentation of this file.

/* dlvhex -- Answer-Set Programming with external interfaces.
 * Copyright (C) 2005-2007 Roman Schindlauer
 * Copyright (C) 2006-2015 Thomas Krennwallner
 * Copyright (C) 2009-2016 Peter Schüller
 * Copyright (C) 2011-2016 Christoph Redl
 * Copyright (C) 2015-2016 Tobias Kaminski
 * Copyright (C) 2015-2016 Antonius Weinzierl
 *
 * This file is part of dlvhex.
 *
 * dlvhex is free software; you can redistribute it and/or modify it
 * under the terms of the GNU Lesser General Public License as
 * published by the Free Software Foundation; either version 2.1 of
 * the License, or (at your option) any later version.
 *
 * dlvhex is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with dlvhex; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
 * 02110-1301 USA.
 */

#ifndef PRINTHELPERS_HPP_INCLUDED__11122011
#define PRINTHELPERS_HPP_INCLUDED__11122011

#include <boost/range/iterator_range.hpp>
#include <boost/function.hpp>
#include <boost/bind.hpp>
#include <boost/optional.hpp>

#include <iostream>
#include <sstream>
#include <set>
#include <vector>

template<typename T>
class ostream_printable
{
    friend std::ostream& operator<<(std::ostream& o, const T& t)
        { return t.print(o); }
    // to be defined in derived class:
    //std::ostream& print(std::ostream& o) const;
};

// if some class has a method "std::ostream& print(std::ostream&) const"
// and you have an object o of this type
// then you can do "std::cerr << ... << print_method(o) << ... " to print it

// if some other method is used to print T foo
// e.g. std::ostream& BAR::printFOO(std::ostream& o, const FOO& p) const
// then you can do
// std::cerr << ... << print_function(boost::bind(&BAR::printFOO, &bar, _1, foo)) << ...
// e.g. std::ostream& printFOO(std::ostream& o, const FOO& p) const
// then you can do
// std::cerr << ... << print_function(boost::bind(&printFoo, _1, foo)) << ...

// std::cerr << ... << printopt(boost::optional<T>) << ...
// gives "unset" or prints T's contents

// std::cerr << ... << printptr(T* or boost::shared_ptr<T>) << ...
// gives "null" or prints T* as a void*

// std::cerr << ... << printrange(Range r) << ... prints generic ranges enclosed in "<>"
// std::cerr << ... << printvector(std::vector<T>) << ... prints generic vectors enclosed in "[]"
// std::cerr << ... << printset(std::set<T>) << ... prints generic sets enclosed in "{}"

struct print_container
{
    virtual ~print_container() {}
    virtual std::ostream& print(std::ostream& o) const = 0;
};

inline std::ostream& operator<<(std::ostream& o, print_container* c)
{
    assert(c);
    std::ostream& ret = c->print(o);
    delete c;
    return ret;
}


template<typename T>
struct print_stream_container:
public print_container
{
    T t;
    print_stream_container(const T& t): t(t) {}
    virtual ~print_stream_container() {}
    virtual std::ostream& print(std::ostream& o) const
        { return o << t; }
};

struct print_method_container:
public print_container
{
    typedef boost::function<std::ostream& (std::ostream&)>
        PrintFn;
    PrintFn fn;
    print_method_container(const PrintFn& fn): fn(fn) {}
    virtual ~print_method_container() {}
    virtual std::ostream& print(std::ostream& o) const
        { return fn(o); }
};

template<typename T>
inline print_container* print_method(const T& t)
{
    return new print_method_container(
        boost::bind(&T::print, &t, _1));
}


inline print_container* print_function(
const print_method_container::PrintFn& fn)
{
    return new print_method_container(fn);
}


template<typename T>
inline print_container* printopt(const boost::optional<T>& t)
{
    if( !!t )
        return new print_stream_container<const T&>(t.get());
    else
        return new print_stream_container<const char*>("unset");
}


template<typename T>
inline print_container* printptr(const boost::shared_ptr<T>& t)
{
    if( !!t )
        return new print_stream_container<const void*>(
            reinterpret_cast<const void*>(t.get()));
    else
        return new print_stream_container<const char*>("null");
}


template<typename T>
inline print_container* printptr(const boost::shared_ptr<const T>& t)
{
    if( t != 0 )
        return new print_stream_container<const void*>(
            reinterpret_cast<const void*>(t.get()));
    else
        return new print_stream_container<const char*>("null");
}


template<typename T>
inline print_container* printptr(const T* const t)
{
    if( t != 0 )
        return new print_stream_container<const void*>(
            reinterpret_cast<const void* const>(t));
    else
        return new print_stream_container<const char*>("null");
}


template<typename Range>
inline print_container* printrange(Range r,
const char* open="<", const char* sep=",", const char* close=">")
{
    std::ostringstream o;
    o << open;
    typename Range::const_iterator it = boost::begin(r);
    typename Range::const_iterator itend = boost::end(r);
    if( it != itend ) {
        o << *it;
        it++;
    }
    for(; it != itend; ++it)
        o << sep << *it;
    o << close;
    return new print_stream_container<std::string>(o.str());
}


template<typename T>
inline print_container* printset(const std::set<T>& t,
const char* open="{", const char* sep=",", const char* close="}")
{
    return printrange(t, open, sep, close);
}


template<typename T>
inline print_container* printvector(const std::vector<T>& t,
const char* open="[", const char* sep=",", const char* close="]")
{
    return printrange(t, open, sep, close);
}
#endif                           // PRINTHELPERS_HPP_INCLUDED__11122011

// vim:expandtab:ts=4:sw=4:
// mode: C++
// End: