tree/function/operators.hpp

Go to the documentation of this file.

#ifndef GENESIS_TREE_FUNCTION_OPERATORS_H_
#define GENESIS_TREE_FUNCTION_OPERATORS_H_
 
/*
    Genesis - A toolkit for working with phylogenetic data.
    Copyright (C) 2014-2020 Lucas Czech and HITS gGmbH
 
    This program 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 of the License, or
    (at your option) any later version.
 
    This program 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 this program.  If not, see <http://www.gnu.org/licenses/>.
 
    Contact:
    Lucas Czech <lucas.czech@h-its.org>
    Exelixis Lab, Heidelberg Institute for Theoretical Studies
    Schloss-Wolfsbrunnenweg 35, D-69118 Heidelberg, Germany
*/
 
#include "genesis/tree/tree.hpp"
 
#include <cassert>
#include <functional>
#include <iosfwd>
#include <memory>
#include <typeinfo>
 
namespace genesis {
namespace tree {
 
// =================================================================================================
//     Forward Declarations
// =================================================================================================
 
class BaseNodeData;
class BaseEdgeData;
class Subtree;
 
// =================================================================================================
//     Data Type Checks
// =================================================================================================
 
template< class NodeDataType, class EdgeDataType >
bool tree_data_is( Tree const& tree, bool allow_null = false )
{
    // Check node data types.
    for( auto const& node : tree.nodes() ) {
        if( ! node.has_data() ) {
            if( allow_null ) {
                continue;
            } else {
                return false;
            }
        }
        assert( node.data_ptr() );
        auto const& ref = *node.data_ptr();
        if( typeid( ref ) != typeid( NodeDataType )) {
            return false;
        }
    }
 
    // Check edge data types.
    for( auto const& edge : tree.edges() ) {
        if( ! edge.has_data() ) {
            if( allow_null ) {
                continue;
            } else {
                return false;
            }
        }
        assert( edge.data_ptr() );
        auto const& ref = *edge.data_ptr();
        if( typeid( ref ) != typeid( EdgeDataType )) {
            return false;
        }
    }
 
    return true;
}
 
template< class NodeDataType, class EdgeDataType >
bool tree_data_is_derived_from( Tree const& tree, bool allow_null = false )
{
    // Check node data types.
    for( auto const& node : tree.nodes() ) {
        if( ! node.has_data() ) {
            if( allow_null ) {
                continue;
            } else {
                return false;
            }
        }
        assert( node.data_ptr() );
        if( dynamic_cast< NodeDataType const* >( node.data_ptr() ) == nullptr ) {
            return false;
        }
    }
 
    // Check edge data types.
    for( auto const& edge : tree.edges() ) {
        if( ! edge.has_data() ) {
            if( allow_null ) {
                continue;
            } else {
                return false;
            }
        }
        assert( edge.data_ptr() );
        if( dynamic_cast< EdgeDataType const* >( edge.data_ptr() ) == nullptr ) {
            return false;
        }
    }
 
    return true;
}
 
// =================================================================================================
//     Conversion
// =================================================================================================
 
Tree convert(
    Tree const& source,
    std::function< std::unique_ptr<BaseNodeData>( BaseNodeData const& node_data )> node_data_converter,
    std::function< std::unique_ptr<BaseEdgeData>( BaseEdgeData const& edge_data )> edge_data_converter
);
 
// =================================================================================================
//     Equality and Identity
// =================================================================================================
 
bool equal(
    Tree const& lhs,
    Tree const& rhs,
    std::function<bool ( TreeNode const&, TreeNode const&) > node_comparator,
    std::function<bool ( TreeEdge const&, TreeEdge const&) > edge_comparator
);
 
bool equal(
    std::vector<Tree> const& trees,
    std::function<bool ( TreeNode const&, TreeNode const&) > node_comparator,
    std::function<bool ( TreeEdge const&, TreeEdge const&) > edge_comparator
);
 
// bool equal( Tree const& lhs, Tree const& rhs);
 
bool identical_topology( Tree const& lhs, Tree const& rhs, bool identical_indices = true );
 
bool identical_topology( std::vector<Tree> const& trees, bool identical_indices = true );
 
// =================================================================================================
//     Element Ownership Checks
// =================================================================================================
 
bool belongs_to( Tree     const& tree, TreeNode const& node );
 
bool belongs_to( TreeNode const& node, Tree     const& tree );
 
bool belongs_to( Tree     const& tree, TreeEdge const& edge );
 
bool belongs_to( TreeEdge const& edge, Tree     const& tree );
 
bool belongs_to( Tree     const& tree, TreeLink const& link );
 
bool belongs_to( TreeLink const& link, Tree     const& tree );
 
bool belongs_to( Tree     const& tree, Subtree  const& subt );
 
bool belongs_to( Subtree  const& subt, Tree     const& tree );
 
TreeEdge*       edge_between( TreeNode& lhs,       TreeNode& rhs );
 
TreeEdge const* edge_between( TreeNode const& lhs, TreeNode const& rhs );
 
// =================================================================================================
//     Output
// =================================================================================================
 
std::string print_info( Tree const& tree );
std::string print_info( TreeEdge const& edge );
std::string print_info( TreeLink const& link );
std::string print_info( TreeNode const& node );
 
std::string print_gist( Tree const& tree, long items = 10 );
 
std::ostream& operator << ( std::ostream& out, Tree const& tree );
std::ostream& operator << ( std::ostream& out, TreeEdge const& edge );
std::ostream& operator << ( std::ostream& out, TreeLink const& link );
std::ostream& operator << ( std::ostream& out, TreeNode const& node );
 
// =================================================================================================
//     Validate
// =================================================================================================
 
bool validate_topology( Tree const& tree );
 
} // namespace tree
} // namespace genesis
 
#endif // include guard