tree/common_tree/newick_writer.hpp

Go to the documentation of this file.

#ifndef GENESIS_TREE_COMMON_TREE_NEWICK_WRITER_H_
#define GENESIS_TREE_COMMON_TREE_NEWICK_WRITER_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/writer.hpp"
#include "genesis/tree/function/functions.hpp"
#include "genesis/utils/core/std.hpp"
#include "genesis/utils/text/string.hpp"
 
namespace genesis {
namespace tree {
 
// =================================================================================================
//     Common Tree Newick Writer Plugin
// =================================================================================================
 
class CommonTreeNewickWriterPlugin
{
public:
 
    // -------------------------------------------------------------------------
    //     Typedefs and Enums
    // -------------------------------------------------------------------------
 
    using self_type = CommonTreeNewickWriterPlugin;
 
    // -------------------------------------------------------------------------
    //     Constructor and Rule of Five
    // -------------------------------------------------------------------------
 
    CommonTreeNewickWriterPlugin() = default;
    virtual ~CommonTreeNewickWriterPlugin() = default;
 
    CommonTreeNewickWriterPlugin(CommonTreeNewickWriterPlugin const&) = default;
    CommonTreeNewickWriterPlugin(CommonTreeNewickWriterPlugin&&)      = default;
 
    CommonTreeNewickWriterPlugin& operator= (CommonTreeNewickWriterPlugin const&) = default;
    CommonTreeNewickWriterPlugin& operator= (CommonTreeNewickWriterPlugin&&)      = default;
 
    // -------------------------------------------------------------------------
    //     Properties
    // -------------------------------------------------------------------------
 
    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_spaces() const
    {
        return replace_name_spaces_;
    }
 
    self_type& replace_name_spaces( bool value )
    {
        replace_name_spaces_ = value;
        return *this;
    }
 
    self_type& enable_names( bool value )
    {
        enable_names_ = value;
        return *this;
    }
 
    bool enable_names() const
    {
        return enable_names_;
    }
 
    self_type& enable_branch_lengths( bool value )
    {
        enable_branch_lengths_ = value;
        return *this;
    }
 
    bool enable_branch_lengths() const
    {
        return enable_branch_lengths_;
    }
 
    int branch_length_precision() const
    {
        return branch_length_precision_;
    }
 
    self_type& branch_length_precision( int value )
    {
        branch_length_precision_ = value;
        return *this;
    }
 
    // -------------------------------------------------------------------------
    //     Plugin Functions
    // -------------------------------------------------------------------------
 
    void node_to_element( TreeNode const& node, NewickBrokerElement& element ) const
    {
        if (enable_names_) {
            std::string name = node.data<CommonNodeData>().name;
 
            // Handle spaces/underscores.
            if( replace_name_spaces_ ) {
                name = utils::replace_all(name, " ", "_");
            }
 
            // Filter out default names if needed.
            if( use_default_names_ && (
                ( is_leaf( node )  && name == default_leaf_name_  ) ||
                ( is_inner( node ) && name == default_inner_name_ ) ||
                ( is_root( node )  && name == default_root_name_  )
            )) {
                name = "";
            }
 
            element.name = name;
        }
    }
 
    void edge_to_element( TreeEdge const& edge, NewickBrokerElement& element ) const
    {
        if (enable_branch_lengths_) {
            auto const& edge_data = edge.data<CommonEdgeData>();
            auto bl = utils::to_string_rounded( edge_data.branch_length, branch_length_precision_ );
            element.values.insert (element.values.begin(), bl );
        }
    }
 
    void register_with( NewickWriter& writer ) const
    {
        // Add node functions.
        writer.node_to_element_plugins.push_back(
            [&]( TreeNode const& node, NewickBrokerElement& element ) {
                node_to_element( node, element );
            }
        );
 
        // Add edge functions.
        writer.edge_to_element_plugins.push_back(
            [&]( TreeEdge const& edge, NewickBrokerElement& element ) {
                edge_to_element( edge, element );
            }
        );
    }
 
    // -------------------------------------------------------------------------
    //     Data Members
    // -------------------------------------------------------------------------
 
private:
 
    int branch_length_precision_ = 6;
 
    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_spaces_ = true;
 
    bool enable_names_          = true;
    bool enable_branch_lengths_ = true;
 
};
 
// =================================================================================================
//     Common Tree Newick Writer
// =================================================================================================
 
class CommonTreeNewickWriter
    : public NewickWriter
    , public CommonTreeNewickWriterPlugin
{
public:
 
    // -------------------------------------------------------------------------
    //     Constructor and Rule of Five
    // -------------------------------------------------------------------------
 
    CommonTreeNewickWriter()
    {
        register_with( *this );
    }
};
 
} // namespace tree
} // namespace genesis
 
#endif // include guard