tree/common_tree/newick_reader.hpp

Go to the documentation of this file.

#ifndef GENESIS_TREE_COMMON_TREE_NEWICK_READER_H_
#define GENESIS_TREE_COMMON_TREE_NEWICK_READER_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/common_tree/tree.hpp"
#include "genesis/tree/formats/newick/element.hpp"
#include "genesis/tree/formats/newick/reader.hpp"
#include "genesis/utils/core/std.hpp"
#include "genesis/utils/text/string.hpp"
 
namespace genesis {
namespace tree {
 
// =================================================================================================
//     Common Tree Newick Reader Plugin
// =================================================================================================
 
class CommonTreeNewickReaderPlugin
{
public:
 
    // -------------------------------------------------------------------------
    //     Typedefs and Enums
    // -------------------------------------------------------------------------
 
    using self_type = CommonTreeNewickReaderPlugin;
 
    // -------------------------------------------------------------------------
    //     Constructor and Rule of Five
    // -------------------------------------------------------------------------
 
    CommonTreeNewickReaderPlugin() = default;
    virtual ~CommonTreeNewickReaderPlugin() = default;
 
    CommonTreeNewickReaderPlugin(CommonTreeNewickReaderPlugin const&) = default;
    CommonTreeNewickReaderPlugin(CommonTreeNewickReaderPlugin&&)      = default;
 
    CommonTreeNewickReaderPlugin& operator= (CommonTreeNewickReaderPlugin const&) = default;
    CommonTreeNewickReaderPlugin& operator= (CommonTreeNewickReaderPlugin&&)      = default;
 
    // -------------------------------------------------------------------------
    //     Settings
    // -------------------------------------------------------------------------
 
    double default_branch_length() const
    {
        return default_branch_length_;
    }
 
    self_type& default_branch_length( double value )
    {
        default_branch_length_ = value;
        return *this;
    }
 
    std::string const& default_leaf_name() const
    {
        return default_leaf_name_;
    }
 
    self_type& default_leaf_name( std::string const& value )
    {
        default_leaf_name_ = value;
        return *this;
    }
 
    std::string const& default_inner_name() const
    {
        return default_inner_name_;
    }
 
    self_type& default_inner_name( std::string const& value )
    {
        default_inner_name_ = value;
        return *this;
    }
 
    std::string const& default_root_name() const
    {
        return default_root_name_;
    }
 
    self_type& default_root_name( std::string const& value )
    {
        default_root_name_ = value;
        return *this;
    }
 
    self_type& set_default_names( std::string const& value )
    {
        default_leaf_name_ = value;
        default_inner_name_ = value;
        default_root_name_ = value;
        return *this;
    }
 
    bool use_default_names() const
    {
        return use_default_names_;
    }
 
    self_type& use_default_names( bool value )
    {
        use_default_names_ = value;
        return *this;
    }
 
    bool replace_name_underscores() const
    {
        return replace_name_underscores_;
    }
 
    self_type& replace_name_underscores( bool value )
    {
        replace_name_underscores_ = value;
        return *this;
    }
 
    // -------------------------------------------------------------------------
    //     Plugin Functions
    // -------------------------------------------------------------------------
 
    void element_to_node( NewickBrokerElement const& element, TreeNode& node ) const
    {
        std::string name = element.name;
 
        // Insert default names if needed.
        if( name.empty() && use_default_names_ ) {
            if( element.is_leaf() ) {
                name = default_leaf_name_;
            } else if( element.is_root() ) {
                name = default_root_name_;
            } else {
                name = default_inner_name_;
            }
        }
 
        // Handle underscores/spaces.
        if( replace_name_underscores_ ) {
            name = utils::replace_all(name, "_", " ");
        }
 
        node.data<CommonNodeData>().name = name;
    }
 
    void element_to_edge( NewickBrokerElement const& element, TreeEdge& edge ) const
    {
        // We assume that the branch length is always the first (or only) value.
        // If there is an interpretation where this is not the case, it is best to introduce
        // an array index for this as a paramter of this class.
        if( element.values.size() > 0 ) {
            edge.data<CommonEdgeData>().branch_length = std::stod( element.values[0] );
        } else {
            edge.data<CommonEdgeData>().branch_length = default_branch_length_;
        }
    }
 
    void register_with( NewickReader& reader ) const
    {
        // Set node data creation function.
        reader.create_node_data_plugin = []( TreeNode& node ){
            node.reset_data( CommonNodeData::create() );
        };
 
        // Set edge data creation function.
        reader.create_edge_data_plugin = []( TreeEdge& edge ){
            edge.reset_data( CommonEdgeData::create() );
        };
 
        // Add node manipulation functions.
        reader.element_to_node_plugins.push_back(
            [&]( NewickBrokerElement const& element, TreeNode& node ) {
                element_to_node( element, node );
            }
        );
 
        // Add edge manipulation functions.
        reader.element_to_edge_plugins.push_back(
            [&]( NewickBrokerElement const& element, TreeEdge& edge ) {
                element_to_edge( element, edge );
            }
        );
 
        // Alternative version using bind.
        // reader.element_to_edge_plugins.push_back(
        //     std::bind(
        //         &CommonTreeNewickReaderPlugin::element_to_edge,
        //         this,
        //         std::placeholders::_1,
        //         std::placeholders::_2
        //     )
        // );
    }
 
    // -------------------------------------------------------------------------
    //     Data Members
    // -------------------------------------------------------------------------
 
private:
 
    double default_branch_length_ = 1.0;
 
    std::string default_leaf_name_  = "Leaf_Node";
    std::string default_inner_name_ = "Inner_Node";
    std::string default_root_name_  = "Root_Node";
 
    bool        use_default_names_        = false;
    bool        replace_name_underscores_ = false;
 
};
 
// =================================================================================================
//     Common Tree Newick Reader
// =================================================================================================
 
class CommonTreeNewickReader
    : public NewickReader
    , public CommonTreeNewickReaderPlugin
{
public:
 
    // -------------------------------------------------------------------------
    //     Constructor and Rule of Five
    // -------------------------------------------------------------------------
 
    CommonTreeNewickReader()
    {
        // This is mindfuck. We derive from two classes - the function register_with() calls
        // the plugin function of CommonTreeNewickReaderPlugin, and uses our own inherited
        // NewickReader instance as argument. Thus, it registeres its own plugin part with its own
        // reader part.
        register_with( *this );
    }
};
 
} // namespace tree
} // namespace genesis
 
#endif // include guard