List.h

#ifndef ROSE_Tree_List_H
#define ROSE_Tree_List_H
#include <Rose/Tree/Base.h>

namespace Rose {
namespace Tree {

template<class T>
class List: public Base {
private:
    using EdgeVector = std::vector<std::unique_ptr<Edge<T>>>;

public:
    using Ptr = std::shared_ptr<List>;

    using Child = T;

    using ChildPtr = std::shared_ptr<T>;

    // These are for compatibility with std::vector
    using value_type = Edge<T>;                                   
    using size_type = typename EdgeVector::size_type;             
    using difference_type = typename EdgeVector::difference_type; 
    using reference = value_type&;                                
    using const_reference = const value_type&;                    
    using pointer = value_type*;                                  
    using const_pointer = const value_type*;                      
private:
    EdgeVector elmts_;

public:
    class iterator {
        friend class List;
        typename EdgeVector::iterator base_;
        iterator() = delete;
        iterator(typename EdgeVector::iterator base)
            : base_(base) {}

    public:
        iterator& operator++() {
            ++base_;
            return *this;
        }
        iterator operator++(int) {
            auto temp = *this;
            ++base_;
            return temp;
        }
        iterator& operator--() {
            --base_;
            return *this;
        }
        iterator operator--(int) {
            auto temp = *this;
            --base_;
            return temp;
        }
        iterator& operator+=(difference_type n) {
            base_ += n;
            return *this;
        }
        iterator operator+(difference_type n) const {
            iterator retval = *this;
            retval += n;
            return retval;
        }
        iterator& operator-=(difference_type n) {
            base_ -= n;
            return *this;
        }
        iterator operator-(difference_type n) const {
            iterator retval = *this;
            retval -= n;
            return retval;
        }
        difference_type operator-(const iterator &other) const {
            return other.base_ - base_;
        }

        Edge<T>& operator[](difference_type n) const {
            ASSERT_not_null(base_[n]);
            return *base_[n];
        }

        Edge<T>& operator*() {
            ASSERT_not_null(*base_);
            return **base_;
        }

        Edge<T>* operator->() {
            ASSERT_not_null(*base_);
            return &**base_;
        }

        iterator& operator=(const iterator &other) {
            base_ = other.base_;
            return *this;
        }

        bool operator==(const iterator &other) const {
            return base_ == other.base_;
        }
        bool operator!=(const iterator &other) const {
            return base_ != other.base_;
        }
        bool operator<(const iterator &other) const {
            return base_ < other.base_;
        }
        bool operator<=(const iterator &other) const {
            return base_ <= other.base_;
        }
        bool operator>(const iterator &other) const {
            return base_ > other.base_;
        }
        bool operator>=(const iterator &other) const {
            return base_ >= other.base_;
        }
    };

protected:
    List() {}

public:
    static std::shared_ptr<List> instance() {
        return std::shared_ptr<List>(new List);
    }

    bool empty() const {
        return elmts_.empty();
    }

    size_t size() const {
        return elmts_.size();
    }

    void reserve(size_t n) {
        elmts_.reserve(n);
    }

    size_t capacity() const {
        return elmts_.capacity();
    }

    Edge<T>& push_back(const std::shared_ptr<T>& elmt) {
        elmts_.push_back(std::make_unique<Edge<T>>(*this, elmt));
        return *elmts_.back();
    }

    BasePtr pop_back() {
        ASSERT_forbid(elmts_.empty());
        BasePtr retval = (*elmts_.back())();
        elmts_.pop_back();
        return retval;
    }

    const Edge<T>& operator[](size_t i) const {
        return *elmts_.at(i);
    }
    Edge<T>& operator[](size_t i) {
        return *elmts_.at(i);
    }
    const Edge<T>& at(size_t i) const {
        return *elmts_.at(i);
    }
    Edge<T>& at(size_t i) {
        return *elmts_.at(i);
    }
    iterator begin() {
        return iterator(elmts_.begin());
    }

    iterator end() {
        return iterator(elmts_.end());
    }

    Edge<T>& front() {
        ASSERT_forbid(elmts_.empty());
        return *elmts_.front();
    }

    Edge<T>& back() {
        ASSERT_forbid(elmts_.empty());
        return *elmts_.back();
    }

protected:
    virtual ChildDescriptor findChild(size_t i) const override {
        if (i < elmts_.size()) {
            return ChildDescriptor{i, boost::lexical_cast<std::string>(i), (*elmts_[i])()};
        } else {
            return ChildDescriptor{elmts_.size(), "", nullptr};
        }
    }
};

} // namespace
} // namespace
#endif