broker.hpp

Go to the documentation of this file.

#ifndef GENESIS_TREE_FORMATS_NEWICK_BROKER_H_
#define GENESIS_TREE_FORMATS_NEWICK_BROKER_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 <deque>
#include <stdexcept>
#include <string>
#include <vector>
 
#include "genesis/tree/formats/newick/element.hpp"
 
namespace genesis {
namespace tree {
 
// =================================================================================================
//     NewickBroker
// =================================================================================================
 
class NewickBroker
{
public:
 
    // -------------------------------------------------------------------------
    //     Typedefs and Enums
    // -------------------------------------------------------------------------
 
    typedef std::deque<NewickBrokerElement>::iterator               iterator;
    typedef std::deque<NewickBrokerElement>::const_iterator         const_iterator;
    typedef std::deque<NewickBrokerElement>::reverse_iterator       reverse_iterator;
    typedef std::deque<NewickBrokerElement>::const_reverse_iterator const_reverse_iterator;
 
    // -------------------------------------------------------------------------
    //     Constructor and Rule of Five
    // -------------------------------------------------------------------------
 
    NewickBroker() = default;
    ~NewickBroker() = default;
 
    NewickBroker(NewickBroker const&) = default;
    NewickBroker(NewickBroker&&)      = default;
 
    NewickBroker& operator= (NewickBroker const&) = default;
    NewickBroker& operator= (NewickBroker&&)      = default;
 
    // -------------------------------------------------------------------------
    //     Modifiers
    // -------------------------------------------------------------------------
 
    void clear();
 
    void push_top (NewickBrokerElement const& node);
    void push_top (NewickBrokerElement&& node);
 
    void push_bottom (NewickBrokerElement const& node);
    void push_bottom (NewickBrokerElement&& node);
 
    void pop_top();
    void pop_bottom();
 
    // -------------------------------------------------------------------------
    //     State Functions
    // -------------------------------------------------------------------------
 
    void assign_ranks() const;
 
    size_t leaf_count() const;
 
    size_t inner_count() const;
 
    size_t node_count() const;
 
    long max_rank() const;
 
    bool is_bifurcating() const;
 
    // -------------------------------------------------------------------------
    //     Properties
    // -------------------------------------------------------------------------
 
    bool   empty() const;
 
    size_t size()  const;
 
    // -------------------------------------------------------------------------
    //     Element Access
    // -------------------------------------------------------------------------
 
    NewickBrokerElement      & operator [] (std::size_t index);
    NewickBrokerElement const& operator [] (std::size_t index) const;
 
    NewickBrokerElement      & at(std::size_t index);
    NewickBrokerElement const& at(std::size_t index) const;
 
    NewickBrokerElement      & top();
    NewickBrokerElement const& top() const;
 
    NewickBrokerElement      & bottom();
    NewickBrokerElement const& bottom() const;
 
    // -------------------------------------------------------------------------
    //     Iteration
    // -------------------------------------------------------------------------
 
    iterator begin();
 
    const_iterator begin() const;
 
    iterator end();
 
    const_iterator end() const;
 
    const_iterator cbegin() const;
 
    const_iterator cend() const;
 
    reverse_iterator rbegin();
 
    const_reverse_iterator rbegin() const;
 
    reverse_iterator rend();
 
    const_reverse_iterator rend() const;
 
    const_reverse_iterator crbegin();
 
    const_reverse_iterator crend();
 
    // -------------------------------------------------------------------------
    //     Dump and Debug
    // -------------------------------------------------------------------------
 
    bool validate() const;
 
    std::string dump() const;
 
    // -------------------------------------------------------------------------
    //     Data Members
    // -------------------------------------------------------------------------
 
private:
 
    std::deque<NewickBrokerElement> stack_;
};
 
} // namespace tree
} // namespace genesis
 
#endif // include guard