keyed_newick_reader.hpp

Go to the documentation of this file.

#ifndef GENESIS_TREE_ATTRIBUTE_TREE_KEYED_NEWICK_READER_H_
#define GENESIS_TREE_ATTRIBUTE_TREE_KEYED_NEWICK_READER_H_
 
/*
    Genesis - A toolkit for working with phylogenetic data.
    Copyright (C) 2014-2020 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/attribute_tree/tree.hpp"
#include "genesis/tree/common_tree/newick_reader.hpp"
#include "genesis/tree/formats/newick/element.hpp"
#include "genesis/tree/formats/newick/reader.hpp"
 
#include <functional>
#include <map>
#include <string>
#include <vector>
 
namespace genesis {
namespace tree {
 
// =================================================================================================
//     Keyed Attribute Tree Newick Reader Plugin
// =================================================================================================
 
class KeyedAttributeTreeNewickReaderPlugin
{
public:
 
    // -------------------------------------------------------------------------
    //     Typedefs and Enums
    // -------------------------------------------------------------------------
 
    using self_type = KeyedAttributeTreeNewickReaderPlugin;
 
    enum class Target
    {
        kNode,
 
        kEdge
    };
 
    // -------------------------------------------------------------------------
    //     Constructor and Rule of Five
    // -------------------------------------------------------------------------
 
    KeyedAttributeTreeNewickReaderPlugin() = default;
    virtual ~KeyedAttributeTreeNewickReaderPlugin() = default;
 
    KeyedAttributeTreeNewickReaderPlugin(KeyedAttributeTreeNewickReaderPlugin const&) = default;
    KeyedAttributeTreeNewickReaderPlugin(KeyedAttributeTreeNewickReaderPlugin&&)      = default;
 
    self_type& operator= (KeyedAttributeTreeNewickReaderPlugin const&) = default;
    self_type& operator= (KeyedAttributeTreeNewickReaderPlugin&&)      = default;
 
    // -------------------------------------------------------------------------
    //     Settings
    // -------------------------------------------------------------------------
 
    self_type& add_attribute(
        std::string const& key,
        Target             target
    );
 
    self_type& add_attribute(
        std::string const& source_key,
        Target             target,
        std::string const& target_key
    );
 
    self_type& add_attribute(
        std::string const& source_key,
        Target             target,
        std::string const& target_key,
        std::string const& default_value
    );
 
    self_type& add_catch_all( Target target = Target::kNode );
 
    self_type& add_nhx_attributes();
 
    self_type& set_nhx_delimiters();
 
    self_type& set_delimiters(
        std::string const& prefix,
        std::string const& separator,
        std::string const& assigner = "="
    ) {
        prefix_    = prefix;
        separator_ = separator;
        assigner_  = assigner;
        return *this;
    }
 
    self_type& prefix( std::string const& value )
    {
        prefix_ = value;
        return *this;
    }
 
    std::string prefix() const
    {
        return prefix_;
    }
 
    self_type& separator( std::string const& value )
    {
        separator_ = value;
        return *this;
    }
 
    std::string separator() const
    {
        return separator_;
    }
 
    self_type& assigner( std::string const& value )
    {
        assigner_ = value;
        return *this;
    }
 
    std::string assigner() const
    {
        return assigner_;
    }
 
    self_type& trim( bool value )
    {
        trim_ = value;
        return *this;
    }
 
    bool trim() const
    {
        return trim_;
    }
 
    void clear();
 
    // -------------------------------------------------------------------------
    //     Plugin Functions
    // -------------------------------------------------------------------------
 
    void element_to_node( NewickBrokerElement const& element, TreeNode& node ) const;
 
    void element_to_edge( NewickBrokerElement const& element, TreeEdge& edge ) const;
 
    void register_with( NewickReader& reader ) const;
 
    // -------------------------------------------------------------------------
    //     Internal Functions
    // -------------------------------------------------------------------------
 
private:
 
    using KeyValuePair = std::pair<std::string, std::string>;
    using PairList     = std::vector<KeyValuePair>;
 
    bool has_attributes_for_target_( Target target ) const;
 
    PairList get_data_( NewickBrokerElement const& element ) const;
 
    void process_keyed_attributes_(
        PairList const& data,
        AttributeTreeMap& attributes,
        Target target
    ) const;
 
    void process_catch_all_attributes_(
        PairList const& data,
        AttributeTreeMap& attributes,
        Target target
    ) const;
 
    // -------------------------------------------------------------------------
    //     Data Members
    // -------------------------------------------------------------------------
 
private:
 
    struct AttributeDescriptor
    {
        std::string source_key;
        Target      target;
        std::string target_key;
        std::string default_value;
        bool        use_default;
    };
 
    std::string prefix_    = "&";
    std::string separator_ = ",";
    std::string assigner_  = "=";
 
    bool trim_ = true;
 
    std::vector<AttributeDescriptor> keyed_attributes_;
    std::vector<AttributeDescriptor> catch_all_attributes_;
 
    static std::vector<AttributeDescriptor> nhx_attributes_;
 
};
 
// =================================================================================================
//     Attribute Tree Newick Reader
// =================================================================================================
 
class KeyedAttributeTreeNewickReader
    : public NewickReader
    , public CommonTreeNewickReaderPlugin
    , public KeyedAttributeTreeNewickReaderPlugin
{
public:
 
    // -------------------------------------------------------------------------
    //     Constructor and Rule of Five
    // -------------------------------------------------------------------------
 
    KeyedAttributeTreeNewickReader()
    {
        // We first register the default reader, then the placement reader, because the latter
        // overwrites the data creation functions.
        CommonTreeNewickReaderPlugin::register_with( *this );
        KeyedAttributeTreeNewickReaderPlugin::register_with( *this );
    }
};
 
} // namespace tree
} // namespace genesis
 
#endif // include guard