Functional.hh

Go to the documentation of this file.

 
#pragma once
 
#include <functional>
#include "Storage.hh"
 
namespace cadabra {
 
 
    void do_list(const Ex& tr, Ex::iterator it, std::function<bool(Ex::iterator)> f);
 
    
    void do_sum(const Ex& sum, Ex::iterator it, std::function<bool(Ex::iterator)> f);
    
 
    int list_size(const Ex& tr, Ex::iterator it);
 
 
    Ex::iterator find_in_list(const Ex& tr, Ex::iterator it, std::function<Ex::iterator(Ex::iterator)> f);
 
 
    Ex::iterator find_in_subtree(const Ex& tr, Ex::iterator it, std::function<bool(Ex::iterator)> f, bool including_head=true);
 
 
    std::vector<Ex::iterator> find_in_sum_multiple();
    
 
    Ex make_list(Ex el);
 
 
    template<typename T>
    typename T::iterator do_subtree(const T& tr, typename T::iterator it, std::function<typename T::iterator(typename T::iterator)> f)
        {
        if(it==tr.end()) return it;
 
        class T::post_order_iterator walk=it, last=it;
        ++last;
        walk.descend_all();
 
        do {
            auto nxt=walk;
            ++nxt;
 
            bool cpy=false;
            if(walk==it) cpy=true;
            walk = f(walk);
            if(cpy) it=walk;
 
            walk=nxt;
            }
        while(walk!=last);
 
        return it;
        }
 
    // Iterate over the children of 'it' if the node is named 'delim', otherwise only
    // iterate over the single node. Note: this yields iterators, not str_nodes.
    struct split_it
    {
        struct iterator {
            using value_type = Ex::sibling_iterator;
            using difference_type = ptrdiff_t;
            using reference = value_type&;
            using const_reference = const value_type&;
            using pointer = value_type*;
            using const_pointer = const value_type*;
            using iterator_category = std::input_iterator_tag;
 
            iterator() {}
            iterator(Ex::sibling_iterator it) : it(it) {}
 
            bool operator == (const iterator& other) { return it == other.it; }
            bool operator != (const iterator& other) { return !(*this == other); }
            reference operator* () { return it; }
            pointer operator-> () { return &it; }
            reference operator ++ () { return ++it; }
            value_type operator ++ (int) { return it++; }
 
 
            Ex::sibling_iterator it;
        };
 
        split_it(Ex::iterator it, const std::string& delim = "")
        {
            if (delim == "" || *it->name == delim) {
                begin_ = it.begin();
                end_ = it.end();
            }
            else {
                begin_ = it;
                end_ = it;
                ++end_;
            }
        }
 
        iterator begin() { return iterator(begin_); }
        iterator end() { return iterator(end_); }
 
    private:
        Ex::sibling_iterator begin_, end_;
    };
 
    };