factory_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_FACTORY_BASE_H__
#define __TPIE_PIPELINING_FACTORY_BASE_H__
 
#include <tpie/tpie_export.h>
#include <tpie/pipelining/node_set.h>
#include <tpie/pipelining/node.h>
#include <tpie/pipelining/tokens.h>
 
namespace tpie::pipelining {
 
class factory_init_hook {
public:
    virtual void init_node(node & r) = 0;
    virtual ~factory_init_hook() {
    }
};
 
struct destination_kind {
    enum type {
        none,
        push,
        pull
    };
};
 
class TPIE_EXPORT factory_base {
public:
    factory_base() = default;
    factory_base(const factory_base & other) = delete;
    factory_base(factory_base &&) = default;
    factory_base & operator=(const factory_base & other) = delete;
    factory_base & operator=(factory_base &&) = default;
 
    inline void memory(double amount) noexcept {
        m_amount = amount;
        m_set = true;
    }
 
    inline double memory() const noexcept {
        return m_amount;
    }
 
    void hook_initialization(factory_init_hook * hook);
 
    void copy_hooks_to(factory_base & other) const;
 
    void init_node(node & r);
 
    void init_sub_node(node & r);
    
    void add_default_edge(node & r, const node & dest) const;
 
    void add_default_edge(node & r, const node_token & dest) const;
    
    void add_node_set_edges(node & r) const;
    
    inline void name(const std::string & n, priority_type p) {
        m_name = n;
        m_namePriority = p;
    }
 
    inline void phase_name(const std::string & n, priority_type p) {
        m_phaseName = n;
        m_phaseNamePriority = p;
    }
 
    
    inline void push_breadcrumb(const std::string & n) {
        if (m_breadcrumbs.empty()) m_breadcrumbs = n;
        else m_breadcrumbs = n + " | " + m_breadcrumbs;
    }
 
    void set_destination_kind_push() noexcept {
        m_destinationKind = destination_kind::push;
    }
 
    void set_destination_kind_pull() noexcept {
        m_destinationKind = destination_kind::pull;
    }
 
    void add_to_set(node_set s);
 
    void add_dependencies(node_set s);
 
    void add_forwarding_dependencies(node_set s);
 
    void forward(const std::string & key, any_noncopyable value);
 
private:
    void init_common(node & r);
 
    double m_amount = 0;
    bool m_set = false;
    destination_kind::type m_destinationKind = destination_kind::none;
    std::string m_name, m_phaseName;
    std::string m_breadcrumbs;
    priority_type m_namePriority = PRIORITY_NO_NAME, m_phaseNamePriority = PRIORITY_NO_NAME;
    std::vector<factory_init_hook *> m_hooks;
    std::vector<node_set> m_add_to_set;
    std::vector<std::pair<node_set, bits::node_relation> > m_add_relations;
    std::vector<std::pair<std::string, any_noncopyable> > m_forwards;
};
 
} // namespace tpie::pipelining
 
#endif // __TPIE_PIPELINING_FACTORY_BASE_H__