195 lines
6.2 KiB
C++
195 lines
6.2 KiB
C++
/* -*- c++ -*- */
|
|
/*
|
|
* Copyright 2006,2007,2013 Free Software Foundation, Inc.
|
|
*
|
|
* This file is part of GNU Radio
|
|
*
|
|
* GNU Radio is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation; either version 3, or (at your option)
|
|
* any later version.
|
|
*
|
|
* GNU Radio 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 General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with GNU Radio; see the file COPYING. If not, write to
|
|
* the Free Software Foundation, Inc., 51 Franklin Street,
|
|
* Boston, MA 02110-1301, USA.
|
|
*/
|
|
|
|
#ifndef INCLUDED_GR_RUNTIME_FLOWGRAPH_H
|
|
#define INCLUDED_GR_RUNTIME_FLOWGRAPH_H
|
|
|
|
#include <gnuradio/api.h>
|
|
#include <gnuradio/basic_block.h>
|
|
#include <gnuradio/io_signature.h>
|
|
#include <iostream>
|
|
|
|
namespace gr {
|
|
|
|
/*!
|
|
* \brief Class representing a specific input or output graph endpoint
|
|
* \ingroup internal
|
|
*/
|
|
class GR_RUNTIME_API endpoint
|
|
{
|
|
private:
|
|
basic_block_sptr d_basic_block;
|
|
int d_port;
|
|
|
|
public:
|
|
endpoint() : d_basic_block(), d_port(0) { }
|
|
endpoint(basic_block_sptr block, int port) { d_basic_block = block; d_port = port; }
|
|
basic_block_sptr block() const { return d_basic_block; }
|
|
int port() const { return d_port; }
|
|
|
|
bool operator==(const endpoint &other) const;
|
|
};
|
|
|
|
inline bool endpoint::operator==(const endpoint &other) const
|
|
{
|
|
return (d_basic_block == other.d_basic_block &&
|
|
d_port == other.d_port);
|
|
}
|
|
|
|
// Hold vectors of gr::endpoint objects
|
|
typedef std::vector<endpoint> endpoint_vector_t;
|
|
typedef std::vector<endpoint>::iterator endpoint_viter_t;
|
|
|
|
/*!
|
|
*\brief Class representing a connection between to graph endpoints
|
|
*/
|
|
class GR_RUNTIME_API edge
|
|
{
|
|
public:
|
|
edge() : d_src(), d_dst() { };
|
|
edge(const endpoint &src, const endpoint &dst)
|
|
: d_src(src), d_dst(dst) { }
|
|
~edge();
|
|
|
|
const endpoint &src() const { return d_src; }
|
|
const endpoint &dst() const { return d_dst; }
|
|
|
|
private:
|
|
endpoint d_src;
|
|
endpoint d_dst;
|
|
};
|
|
|
|
// Hold vectors of gr::edge objects
|
|
typedef std::vector<edge> edge_vector_t;
|
|
typedef std::vector<edge>::iterator edge_viter_t;
|
|
|
|
// Create a shared pointer to a heap allocated flowgraph
|
|
// (types defined in runtime_types.h)
|
|
GR_RUNTIME_API flowgraph_sptr make_flowgraph();
|
|
|
|
/*!
|
|
* \brief Class representing a directed, acyclic graph of basic blocks
|
|
* \ingroup internal
|
|
*/
|
|
class GR_RUNTIME_API flowgraph
|
|
{
|
|
public:
|
|
friend GR_RUNTIME_API flowgraph_sptr make_flowgraph();
|
|
|
|
// Destruct an arbitrary flowgraph
|
|
~flowgraph();
|
|
|
|
// Connect two endpoints
|
|
void connect(const endpoint &src, const endpoint &dst);
|
|
|
|
// Disconnect two endpoints
|
|
void disconnect(const endpoint &src, const endpoint &dst);
|
|
|
|
// Connect an output port to an input port (convenience)
|
|
void connect(basic_block_sptr src_block, int src_port,
|
|
basic_block_sptr dst_block, int dst_port);
|
|
|
|
// Disconnect an input port from an output port (convenience)
|
|
void disconnect(basic_block_sptr src_block, int src_port,
|
|
basic_block_sptr dst_block, int dst_port);
|
|
|
|
// Validate connectivity, raise exception if invalid
|
|
void validate();
|
|
|
|
// Clear existing flowgraph
|
|
void clear();
|
|
|
|
// Return vector of edges
|
|
const edge_vector_t &edges() const { return d_edges; }
|
|
|
|
// Return vector of connected blocks
|
|
basic_block_vector_t calc_used_blocks();
|
|
|
|
// Return toplogically sorted vector of blocks. All the sources come first.
|
|
basic_block_vector_t topological_sort(basic_block_vector_t &blocks);
|
|
|
|
// Return vector of vectors of disjointly connected blocks,
|
|
// topologically sorted.
|
|
std::vector<basic_block_vector_t> partition();
|
|
|
|
protected:
|
|
basic_block_vector_t d_blocks;
|
|
edge_vector_t d_edges;
|
|
|
|
flowgraph();
|
|
std::vector<int> calc_used_ports(basic_block_sptr block, bool check_inputs);
|
|
basic_block_vector_t calc_downstream_blocks(basic_block_sptr block, int port);
|
|
edge_vector_t calc_upstream_edges(basic_block_sptr block);
|
|
bool has_block_p(basic_block_sptr block);
|
|
edge calc_upstream_edge(basic_block_sptr block, int port);
|
|
|
|
private:
|
|
void check_valid_port(gr::io_signature::sptr sig, int port);
|
|
void check_dst_not_used(const endpoint &dst);
|
|
void check_type_match(const endpoint &src, const endpoint &dst);
|
|
edge_vector_t calc_connections(basic_block_sptr block, bool check_inputs); // false=use outputs
|
|
void check_contiguity(basic_block_sptr block, const std::vector<int> &used_ports, bool check_inputs);
|
|
|
|
basic_block_vector_t calc_downstream_blocks(basic_block_sptr block);
|
|
basic_block_vector_t calc_reachable_blocks(basic_block_sptr block, basic_block_vector_t &blocks);
|
|
void reachable_dfs_visit(basic_block_sptr block, basic_block_vector_t &blocks);
|
|
basic_block_vector_t calc_adjacent_blocks(basic_block_sptr block, basic_block_vector_t &blocks);
|
|
basic_block_vector_t sort_sources_first(basic_block_vector_t &blocks);
|
|
bool source_p(basic_block_sptr block);
|
|
void topological_dfs_visit(basic_block_sptr block, basic_block_vector_t &output);
|
|
};
|
|
|
|
// Convenience functions
|
|
inline
|
|
void flowgraph::connect(basic_block_sptr src_block, int src_port,
|
|
basic_block_sptr dst_block, int dst_port)
|
|
{
|
|
connect(endpoint(src_block, src_port),
|
|
endpoint(dst_block, dst_port));
|
|
}
|
|
|
|
inline
|
|
void flowgraph::disconnect(basic_block_sptr src_block, int src_port,
|
|
basic_block_sptr dst_block, int dst_port)
|
|
{
|
|
disconnect(endpoint(src_block, src_port),
|
|
endpoint(dst_block, dst_port));
|
|
}
|
|
|
|
inline std::ostream&
|
|
operator <<(std::ostream &os, const endpoint endp)
|
|
{
|
|
os << endp.block()->alias() << ":" << endp.port();
|
|
return os;
|
|
}
|
|
|
|
inline std::ostream&
|
|
operator <<(std::ostream &os, const edge edge)
|
|
{
|
|
os << edge.src() << "->" << edge.dst();
|
|
return os;
|
|
}
|
|
|
|
} /* namespace gr */
|
|
|
|
#endif /* INCLUDED_GR_RUNTIME_FLOWGRAPH_H */
|