tree/formats/newick/writer.hpp

Go to the documentation of this file.

#ifndef GENESIS_TREE_FORMATS_NEWICK_WRITER_H_
#define GENESIS_TREE_FORMATS_NEWICK_WRITER_H_
 
/*
    Genesis - A toolkit for working with phylogenetic data.
    Copyright (C) 2014-2023 Lucas Czech
 
    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 <lczech@carnegiescience.edu>
    Department of Plant Biology, Carnegie Institution For Science
    260 Panama Street, Stanford, CA 94305, USA
*/
 
#include "genesis/utils/io/output_target.hpp"
 
#include <iosfwd>
#include <functional>
#include <string>
#include <vector>
 
namespace genesis {
namespace tree {
 
// =================================================================================================
//     Forward Declarations
// =================================================================================================
 
class  Tree;
class  TreeNode;
class  TreeEdge;
class  TreeSet;
 
class  NewickBroker;
struct NewickBrokerElement;
 
// =================================================================================================
//     Newick Writer
// =================================================================================================
 
class NewickWriter
{
public:
 
    // -------------------------------------------------------------------------
    //     Typedefs and Enums
    // -------------------------------------------------------------------------
 
    using prepare_writing_function = std::function< void(
        Tree const& tree, NewickBroker& broker
    ) >;
 
    using finish_writing_function = std::function< void(
        Tree const& tree, NewickBroker& broker
    ) >;
 
    using node_to_element_function = std::function< void(
        TreeNode const& node, NewickBrokerElement& element
    ) >;
 
    using edge_to_element_function = std::function< void(
        TreeEdge const& edge, NewickBrokerElement& element
    ) >;
 
    // -------------------------------------------------------------------------
    //     Constructor and Rule of Five
    // -------------------------------------------------------------------------
 
    NewickWriter() = default;
    virtual ~NewickWriter() = default;
 
    NewickWriter(NewickWriter const&) = default;
    NewickWriter(NewickWriter&&)      = default;
 
    NewickWriter& operator= (NewickWriter const&) = default;
    NewickWriter& operator= (NewickWriter&&)      = default;
 
    // -------------------------------------------------------------------------
    //     Writing
    // -------------------------------------------------------------------------
 
    void write( Tree const& tree, std::shared_ptr<utils::BaseOutputTarget> target ) const;
 
    void write(
        TreeSet const& tree_set,
        std::shared_ptr<utils::BaseOutputTarget> target,
        bool with_names = false
    ) const;
 
    std::string to_string( Tree const& tree ) const;
 
    // -------------------------------------------------------------------------
    //     Plugin Functions
    // -------------------------------------------------------------------------
 
    std::vector<prepare_writing_function> prepare_writing_plugins;
 
    std::vector<finish_writing_function>  finish_writing_plugins;
 
    std::vector<node_to_element_function> node_to_element_plugins;
 
    std::vector<edge_to_element_function> edge_to_element_plugins;
 
    // -------------------------------------------------------------------------
    //     Settings
    // -------------------------------------------------------------------------
 
    NewickWriter& quotation_mark( char value )
    {
        quotation_mark_ = value;
        return *this;
    }
 
    char quotation_mark() const
    {
        return quotation_mark_;
    }
 
    NewickWriter& force_quotation_marks( bool value )
    {
        force_quot_marks_ = value;
        return *this;
    }
 
    bool force_quotation_marks() const
    {
        return force_quot_marks_;
    }
 
    NewickWriter& line_length( size_t value )
    {
        line_length_ = value;
        return *this;
    }
 
    size_t line_length() const
    {
        return line_length_;
    }
 
    NewickWriter& trailing_new_line( bool value )
    {
        trailing_new_line_ = value;
        return *this;
    }
 
    bool trailing_new_line() const
    {
        return trailing_new_line_;
    }
 
    NewickWriter& write_names( bool value )
    {
        write_names_ = value;
        return *this;
    }
 
    bool write_names() const
    {
        return write_names_;
    }
 
    NewickWriter& write_values( bool value )
    {
        write_values_ = value;
        return *this;
    }
 
    bool write_values() const
    {
        return write_values_;
    }
 
    NewickWriter& write_comments( bool value )
    {
        write_comments_ = value;
        return *this;
    }
 
    bool write_comments() const
    {
        return write_comments_;
    }
 
    NewickWriter& write_tags( bool value )
    {
        write_tags_ = value;
        return *this;
    }
 
    bool write_tags() const
    {
        return write_tags_;
    }
 
    // -------------------------------------------------------------------------
    //      Intermediate Functions
    // -------------------------------------------------------------------------
 
    NewickBroker tree_to_broker( Tree const& tree ) const;
 
    void write( NewickBroker const& broker, std::shared_ptr<utils::BaseOutputTarget> target ) const;
 
    // -------------------------------------------------------------------------
    //     Internal Functions
    // -------------------------------------------------------------------------
 
private:
 
    size_t write_( NewickBrokerElement const& bn, std::ostream& os ) const;
 
    // std::string to_string_rec_( NewickBroker const& broker, size_t pos ) const;
 
    // -------------------------------------------------------------------------
    //     Member Data
    // -------------------------------------------------------------------------
 
    bool force_quot_marks_ = false;
    char quotation_mark_  = '\"';
    size_t line_length_ = 0;
    bool trailing_new_line_ = true;
 
    bool write_names_    = true;
    bool write_values_   = true;
    bool write_comments_ = true;
    bool write_tags_     = true;
 
};
 
} // namespace tree
} // namespace genesis
 
#endif // include guard