Dispatcher.hh

Go to the documentation of this file.

#ifndef __DIADES__UTILS__DISPATCHER__HH
#define __DIADES__UTILS__DISPATCHER__HH


#include<stack>
#include<iostream>
#include<array>



namespace Diades {
    namespace Utils {
        
        using namespace std;
        
        
        
        template<long unsigned int Size>
        class Dispatcher {
        public:
            using Array = std::array<unsigned, Size>;

            
            Dispatcher(unsigned n) : _current(), _stack(), _n(n) {
            }

            const Array & init() {
                _current.fill(0);
                if (_current.size() > 1) {
                    _stack.push({0, _n});
                    _stack.push({_n, 0});
                    _current[_stack.size() - 2] = _stack.top().first;
                }
                return _current;
            }

            const Array & next() {
                if (_stack.empty()) {
                    return _current;
                } else {
                    if (!hasNext()) {
                        // this the case the current node is (_n,0) and associates _n tokens to _current[_current.size()-1]
                        // so the current configuration is the last one in the enumeration, there is no next
                        while (!_stack.empty()) {
                            _stack.pop();
                        }
                        _current.fill(0);
                    } else {

                        // the current node is like this: (n1,n2) with at least n1 non-null
                        // as it contains the last non-null dispatch
                        // we move to a new configuration when we dispatch n1-1 at this level and 1 below
                        auto tempPair = _stack.top();
                        _current[_stack.size() - 2] = 0;
                        _stack.pop();
                        _stack.push({tempPair.first - 1, tempPair.second + 1});
                        if (_stack.size() == _current.size() + 1) {
                            // this new configuration is not working as we need to do more dispatching (tempPair.second+1)
                            // but we are already at the end of the array
                            // by construction of the enumeration, we need to pop back to a node (n1,n2) with n1 \= 0
                            // and branch again as above
                            _stack.pop();
                            while (_stack.top().first == 0) {
                                _stack.pop();
                            }
                            tempPair = _stack.top();
                            _stack.pop();
                            _stack.push({tempPair.first - 1, tempPair.second + 1});
                        }
                        _current[_stack.size() - 2] = _stack.top().first;
                        _stack.push({tempPair.second + 1, 0});
                        _current[_stack.size() - 2] = _stack.top().first;
                    }
                }
                return _current;
            }

            bool hasNext() const {
                return !(_stack.empty() || ((_stack.size() == _current.size() + 1) && (_stack.top().first == _n)));
            }

            bool empty() const {
                return _current.size() == 0;
            }
            
            
            unsigned nbElements() const
            {
                return _n;
            }
            
            const long unsigned int size() const
            {
                return Size;
            }
            
            
        private:
            Array _current;
            std::stack< std::pair<unsigned, unsigned> > _stack;
            
            unsigned _n;
        };


    }
}



#endif /* __DIADES__UTILS__DISPATCHER__HH */