pipe_base.h

// -*- mode: c++; tab-width: 4; indent-tabs-mode: t; eval: (progn (c-set-style "stroustrup") (c-set-offset 'innamespace 0)); -*-
// vi:set ts=4 sts=4 sw=4 noet :
// Copyright 2011, 2012, 2013, The TPIE development team
// 
// This file is part of TPIE.
// 
// TPIE 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 3 of the License, or (at your
// option) any later version.
// 
// TPIE 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 TPIE.  If not, see <http://www.gnu.org/licenses/>
 
#ifndef __TPIE_PIPELINING_PIPE_BASE_H__
#define __TPIE_PIPELINING_PIPE_BASE_H__
 
#include <tpie/tpie_export.h>
#include <tpie/types.h>
#include <tpie/pipelining/priority_type.h>
#include <tpie/pipelining/pair_factory.h>
#include <tpie/pipelining/pipeline.h>
#include <tpie/pipelining/node_set.h>
 
#ifdef WIN32
// Silence warning C4521: multiple copy constructors specified.
// This warning is emitted since we declare both
// pipe_middle(const pipe_middle &) and
// pipe_middle(pipe_middle &).
// However, both of these are necessary to ensure that copying takes
// preference over the template <T> pipe_middle(T) constructor.
#pragma warning(push)
#pragma warning(disable: 4521)
#endif
 
namespace tpie::pipelining {
namespace bits {
 
template <typename child_t>
class pipe_base {
public:
    pipe_base() = default;
    pipe_base(pipe_base & other) = delete;
    pipe_base(pipe_base && other) = default;
    pipe_base & operator=(pipe_base & other) = delete;
    pipe_base & operator=(pipe_base && other) = default;
 
    child_t memory(double amount) {
        self().factory.memory(amount);
        return std::move(self());
    }
 
    double memory() const {
        return self().factory.memory();
    }
 
    child_t name(const std::string & n, priority_type p = PRIORITY_USER) {
        self().factory.name(n, p);
        return std::move(self());
    }
 
    child_t phase_name(const std::string & n, priority_type p = PRIORITY_USER) {
        self().factory.phase_name(n, p);
        return std::move(self());
    }
 
    
    child_t add_to_set(node_set s) {
        self().factory.add_to_set(s);
        return std::move(self());
    }
 
    child_t add_dependencies(node_set s) {
        self().factory.add_dependencies(s);
        return std::move(self());
    }
 
    child_t add_forwarding_dependencies(node_set s) {
        self().factory.add_forwarding_dependencies(s);
        return std::move(self());
    }
 
    child_t breadcrumb(const std::string & n) {
        self().factory.push_breadcrumb(n);
        return std::move(self());
    }
 
    child_t forward_any(const std::string & key, any_noncopyable value) {
        self().factory.forward(key, std::move(value));
        return std::move(self());
    }
 
    template <typename T>
    child_t forward(const std::string & key, T value) {
        return forward_any(key, any_noncopyable(value));
    }
 
protected:
    child_t & self() {return *static_cast<child_t*>(this);}
    const child_t & self() const {return *static_cast<const child_t*>(this);}
};
 
// The derived class has to pass its factory type to us as a template argument.
// See the following Stack Overflow question, dated Nov 13, 2011, for a discussion.
// http://stackoverflow.com/q/8113878
// At the time this class is instantiated, child_t is not yet complete.
// This means we cannot use child_t::factory_type as an existing type name.
template <typename child_t, typename fact_t>
class pipe_term_base : public pipe_base<child_t> {
public:
    typedef typename fact_t::constructed_type constructed_type;
 
    constructed_type construct() {
        return this->self().factory.construct();
    }
};
 
// For this class, we only use child_t::factory_type inside
// a templated member type, so at the time of its instantiation,
// child_t is complete and child_t::factory_type is valid.
template <typename child_t>
class pipe_nonterm_base : public pipe_base<child_t> {
public:
    pipe_nonterm_base() = default;
    pipe_nonterm_base(const pipe_nonterm_base &) = delete;
    pipe_nonterm_base(pipe_nonterm_base &&) = default;
    pipe_nonterm_base & operator=(const pipe_nonterm_base &) = delete;
    pipe_nonterm_base & operator=(pipe_nonterm_base &&) = default;
 
    template <typename dest_t>
    class constructed {
    public:
        using type = typename child_t::factory_type::template constructed_type<dest_t>;
    };
    
    template <typename dest_t>
    using constructed_type = typename constructed<dest_t>::type;
 
    template <typename dest_t>
    constructed_type<dest_t> construct(const dest_t & dest) {
        return this->self().factory.construct(dest);
    }
};
 
} // namespace bits
 
template <typename fact_t>
class pipe_end : public bits::pipe_term_base<pipe_end<fact_t>, fact_t> {
public:
    typedef fact_t factory_type;
 
    template <typename ... T_ARGS>
    pipe_end(T_ARGS && ... args) : factory(std::forward<T_ARGS>(args)...) {}
 
    fact_t factory;
};
 
 
class empty_pipe_middle;
 
template <typename fact_t>
class pipe_middle : public bits::pipe_nonterm_base<pipe_middle<fact_t> > {
public:
    typedef fact_t factory_type;
 
    pipe_middle(const pipe_middle &) = delete;
    pipe_middle(pipe_middle &&) = default;
    pipe_middle & operator=(const pipe_middle &) = delete;
    pipe_middle & operator=(pipe_middle &&) = default;
 
    pipe_middle(const fact_t && o) = delete;
    pipe_middle(fact_t && o): factory(std::move(o)) {}
    pipe_middle & operator=(const fact_t &) = delete;
    pipe_middle & operator=(fact_t && o) {factory = std::move(o);}
 
 
 
    template <typename ... T_ARGS>
    pipe_middle(T_ARGS && ... args) : factory(std::forward<T_ARGS>(args)...) {}
 
    template <typename fact2_t>
    pipe_middle<bits::pair_factory<fact_t, fact2_t> >
    operator|(pipe_middle<fact2_t> && r) {
        factory.set_destination_kind_push();
        return bits::pair_factory<fact_t, fact2_t>(std::move(factory), std::move(r.factory));
    }
 
    pipe_middle operator|(empty_pipe_middle &&) {return pipe_middle(std::move(factory));}
 
    template <typename fact2_t>
    pipe_end<bits::termpair_factory<fact_t, fact2_t> >
    operator|(pipe_end<fact2_t> && r) {
        factory.set_destination_kind_push();
        return bits::termpair_factory<fact_t, fact2_t>(std::move(factory), std::move(r.factory));
    }
 
    fact_t factory;
};
 
class empty_pipe_middle : public bits::pipe_nonterm_base<empty_pipe_middle> {
public:
    empty_pipe_middle() = default;
    empty_pipe_middle(const empty_pipe_middle &) = delete;
    empty_pipe_middle(empty_pipe_middle &&) = default;
    empty_pipe_middle & operator=(const empty_pipe_middle &) = delete;
    empty_pipe_middle & operator=(empty_pipe_middle &&) = default;
 
    template <typename fact_t>
    pipe_middle<fact_t> operator|(pipe_middle<fact_t> && r) const {return std::move(r);}
 
    template <typename fact_t>
    pipe_end<fact_t> operator|(pipe_end<fact_t> && r) const {return std::move(r);}
};
 
 
template <typename fact_t>
class pipe_begin : public bits::pipe_nonterm_base<pipe_begin<fact_t> > {
public:
    pipe_begin(const pipe_begin<fact_t> &) = default;
    pipe_begin(pipe_begin<fact_t> &&) = default;
    pipe_begin & operator=(const pipe_begin<fact_t> &) = delete;
    pipe_begin & operator=(pipe_begin<fact_t> &&) = default;
 
    pipe_begin(fact_t && f): factory(std::move(f)) {}
 
    typedef fact_t factory_type;
 
    //pipe_begin(fact_t && f) : factory(std::move(f)) {};
 
    // template <typename T1, typename ... T_ARGS, typename = typename std::enable_if<!std::is_same<pipe_begin, T1>::value, T1>::type>
    // explicit inline pipe_begin(T1 && t1, T_ARGS && ... t) : factory(std::forward(t1), std::forward<T_ARGS>(t)...) {}
 
    template <typename ... T_ARGS>
    pipe_begin(T_ARGS && ... args) : factory(std::forward<T_ARGS>(args)...) {}
 
 
    template <typename fact2_t>
    pipe_begin<bits::pair_factory<fact_t, fact2_t> >
    operator|(pipe_middle<fact2_t> && r) {
        factory.set_destination_kind_push();
        return bits::pair_factory<fact_t, fact2_t>(std::move(factory), std::move(r.factory));
    }
 
    pipe_begin operator|(empty_pipe_middle &&) {return pipe_begin(std::move(factory));}
 
    template <typename fact2_t>
    bits::pipeline_impl<bits::termpair_factory<fact_t, fact2_t> >
    operator|(pipe_end<fact2_t> && r) {
        factory.set_destination_kind_push();
        return bits::termpair_factory<fact_t, fact2_t>(std::move(factory), std::move(r.factory)).finalize();
    }
 
    fact_t factory;
};
 
template <typename fact_t>
class pullpipe_end : public bits::pipe_nonterm_base<pullpipe_end<fact_t> > {
public:
    typedef fact_t factory_type;
 
    template <typename ... T_ARGS>
    pullpipe_end(T_ARGS && ... args) : factory(std::forward<T_ARGS>(args)...) {}
 
    fact_t factory;
};
 
template <typename fact_t>
class pullpipe_middle : public bits::pipe_nonterm_base<pullpipe_middle<fact_t> > {
public:
    typedef fact_t factory_type;
 
    template <typename ... T_ARGS>
    pullpipe_middle(T_ARGS && ... args) : factory(std::forward<T_ARGS>(args)...) {}
 
    template <typename fact2_t>
    pullpipe_middle<bits::pair_factory<fact2_t, fact_t> >
    operator|(pipe_middle<fact2_t> && r) {
        fact2_t f = std::move(r.factory);
        f.set_destination_kind_pull();
        return bits::pair_factory<fact2_t, fact_t>(std::move(f), std::move(factory));
    }
 
    template <typename fact2_t>
    pullpipe_end<bits::termpair_factory<fact2_t, fact_t> >
    operator|(pipe_end<fact2_t> && r) {
        fact2_t f = std::move(r.factory);
        f.set_destination_kind_pull();
        return bits::termpair_factory<fact2_t, fact_t>(std::move(f), std::move(factory));
    }
 
    fact_t factory;
};
 
template <typename fact_t>
class pullpipe_begin : public bits::pipe_term_base<pullpipe_begin<fact_t>, fact_t> {
public:
    typedef fact_t factory_type;
 
    template <typename ... T_ARGS>
    pullpipe_begin(T_ARGS && ... args) : factory(std::forward<T_ARGS>(args)...) {}
 
    template <typename fact2_t>
    pullpipe_begin<bits::termpair_factory<fact2_t, fact_t> >
    operator|(pullpipe_middle<fact2_t> && r) {
        fact2_t f = std::move(r.factory);
        f.set_destination_kind_pull();
        return bits::termpair_factory<fact2_t, fact_t>(std::move(f), std::move(factory));
    }
 
    template <typename fact2_t>
    bits::pipeline_impl<bits::termpair_factory<fact2_t, fact_t> >
    operator|(pullpipe_end<fact2_t> && r) {
        fact2_t f = std::move(r.factory);
        f.set_destination_kind_pull();
        return bits::termpair_factory<fact2_t, fact_t>(std::move(f), std::move(factory)).finalize();
    }
 
    fact_t factory;
};
 
} // namespace tpie::pipelining
 
#ifdef WIN32
#pragma warning(pop)
#endif
 
#endif // __TPIE_PIPELINING_PIPE_BASE_H__