tree/formats/newick/reader.hpp

Go to the documentation of this file.

#ifndef GENESIS_TREE_FORMATS_NEWICK_READER_H_
#define GENESIS_TREE_FORMATS_NEWICK_READER_H_
 
/*
    Genesis - A toolkit for working with phylogenetic data.
    Copyright (C) 2014-2019 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/utils/io/input_source.hpp"
 
#include <iosfwd>
#include <functional>
#include <string>
#include <utility>
#include <vector>
 
namespace genesis {
 
// =================================================================================================
//     Forward declarations
// =================================================================================================
 
namespace utils {
    class InputStream;
}
 
namespace tree {
 
class  Tree;
class  TreeNode;
class  TreeEdge;
class  TreeLink;
class  TreeSet;
 
class  NewickBroker;
struct NewickBrokerElement;
 
// =================================================================================================
//     Newick Reader
// =================================================================================================
 
class NewickReader
{
public:
 
    // -------------------------------------------------------------------------
    //     Typedefs and Enums
    // -------------------------------------------------------------------------
 
    using prepare_reading_function = std::function< void(
        NewickBroker const& broker, Tree& tree
    ) >;
 
    using finish_reading_function = std::function< void(
        Tree& tree
    ) >;
 
    using create_node_data_function = std::function< void( TreeNode& node ) >;
 
    using create_edge_data_function = std::function< void( TreeEdge& edge ) >;
 
    using element_to_node_function = std::function< void(
        NewickBrokerElement const& element, TreeNode& node
    ) >;
 
    using element_to_edge_function = std::function< void(
        NewickBrokerElement const& element, TreeEdge& edge
    ) >;
 
private:
 
    enum class TokenType
    {
        kUnknown,
        kOpeningParenthesis,
        kClosingParenthesis,
        kComma,
        kSemicolon,
        kEquals,
        kComment,
        kValue,
        kTag,
        kString,
        kEnd
    };
 
    struct Token
    {
        TokenType   type = TokenType::kEnd;
        std::string text;
        size_t      line;
        size_t      column;
 
        std::string at() const
        {
            return std::to_string( line ) + ":" + std::to_string( column );
        }
    };
 
    // -------------------------------------------------------------------------
    //     Constructor and Rule of Five
    // -------------------------------------------------------------------------
 
public:
 
    NewickReader() = default;
    virtual ~NewickReader() = default;
 
    NewickReader(NewickReader const&) = default;
    NewickReader(NewickReader&&)      = default;
 
    NewickReader& operator= (NewickReader const&) = default;
    NewickReader& operator= (NewickReader&&)      = default;
 
    // -------------------------------------------------------------------------
    //     Reading
    // -------------------------------------------------------------------------
 
    Tree read( std::shared_ptr<utils::BaseInputSource> source ) const;
 
    void read(
        std::shared_ptr<utils::BaseInputSource> source,
        TreeSet& target,
        std::string const& default_name = ""
    ) const;
 
    void read(
        std::vector<std::shared_ptr<utils::BaseInputSource>> sources,
        TreeSet& target,
        std::string const& default_name = ""
    ) const;
 
    TreeSet read(
        std::vector<std::shared_ptr<utils::BaseInputSource>> sources,
        std::string const& default_name = ""
    ) const;
 
    // -------------------------------------------------------------------------
    //     Settings
    // -------------------------------------------------------------------------
 
    NewickReader& enable_tags( bool value );
 
    bool enable_tags() const;
 
    NewickReader& stop_after_semicolon( bool value );
 
    bool stop_after_semicolon() const;
 
    // -------------------------------------------------------------------------
    //     Plugin Functions
    // -------------------------------------------------------------------------
 
    std::vector<prepare_reading_function> prepare_reading_plugins;
    std::vector<finish_reading_function>  finish_reading_plugins;
 
    create_node_data_function create_node_data_plugin;
    create_edge_data_function create_edge_data_plugin;
 
    std::vector<element_to_node_function> element_to_node_plugins;
    std::vector<element_to_edge_function> element_to_edge_plugins;
 
    // -------------------------------------------------------------------------
    //     Parsing Functions
    // -------------------------------------------------------------------------
 
    Tree parse_single_tree( utils::InputStream& input_stream ) const;
 
    void parse_multiple_trees(
        utils::InputStream& input_stream,
        TreeSet&            tree_set,
        std::string const&  default_name
    ) const;
 
    std::pair< std::string, Tree > parse_named_tree( utils::InputStream& input_stream ) const;
 
    Tree broker_to_tree( NewickBroker const& broker ) const;
 
    Tree broker_to_tree_destructive( NewickBroker& broker ) const;
 
    // -------------------------------------------------------------------------
    //     Internal Member Functions
    // -------------------------------------------------------------------------
 
private:
 
    void broker_to_tree_prepare_(
        NewickBroker const& broker,
        Tree& tree
    ) const;
 
    void broker_to_tree_element_(
        NewickBrokerElement const& broker_node,
        std::vector<TreeLink*>& link_stack,
        Tree& tree
    ) const;
 
    void broker_to_tree_finish_(
        Tree& tree
    ) const;
 
    void parse_trailing_input_( utils::InputStream& input_stream ) const;
 
    Token get_next_token_( utils::InputStream& input_stream ) const;
 
    NewickBroker parse_tree_to_broker_( utils::InputStream& input_stream ) const;
 
    // -------------------------------------------------------------------------
    //     Member Data
    // -------------------------------------------------------------------------
 
    bool enable_tags_       = false;
    bool stop_after_semicolon_ = false;
 
};
 
} // namespace tree
} // namespace genesis
 
#endif // include guard