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-2018 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 <functional>
#include <iosfwd>
#include <memory>
#include <typeinfo>

namespace genesis {
namespace tree {

// =================================================================================================
//     Forward Declarations
// =================================================================================================

class BaseNodeData;
class BaseEdgeData;

// =================================================================================================
//     Data Type Checks
// =================================================================================================

template< class NodeDataType, class EdgeDataType >
bool tree_data_is( Tree const& tree )
{
    // Check node data types.
    for( auto const& node : tree.nodes() ) {
        if( ! node->has_data() ) {
            return false;
        }
        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() ) {
            return false;
        }
        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 )
{
    // Check node data types.
    for( auto const& node : tree.nodes() ) {
        if( dynamic_cast< NodeDataType const* >( node->data_ptr() ) == nullptr ) {
            return false;
        }
    }

    // Check edge data types.
    for( auto const& edge : tree.edges() ) {
        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
// =================================================================================================

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( Tree const& lhs, Tree const& rhs);

bool identical_topology( Tree const& lhs, Tree const& rhs);

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 );

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, int 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