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