Since we talked about the open issues and add(ed) them to the 
tracker, I think, we can close this issue here.

As per Gabi's email, the integration of this is done. Should we get rid of the
"new-open-lists" branch then, or are there still open issues? If there are, can
you put them into the tracker?

We plan a slightly more invasive re-design of all the open list stuff:

The search will be able to access two objects:
An "Evaluator" with the following public interface:
    void evaluate(const State &state, int g, bool preferred)
    bool is_dead_end()
    void get_preferred_operators(std::vector<const Operator *> &result);

and the actual OpenList<Entry> with the following interface:
    void insert(const Entry &entry);
    Entry remove_min();
    bool empty() const;


(if we don't really need the template parameter at the
end, we might remove it).
The open list will know its evaluator and will get all 
relevant information from there.

So when the search handles a state, it will have to take
care that the Evaluator is evaluated for that state before
its other methods or adds the state to the open list.

Some words on the role of the Evaluator: Evaluators can be
combinations of heuristics, heuristics (in the long term,
it might be the case that Heuristic will inherit from 
Evaluator), preferredness information, the g-value, ...

We discussed this some more. The insert method will require access to the g
value of the state as well as all h values and the preferredness information.

It may make sense to add a "reward_progress" method similar to the one currently
contained in the search code, or alternatively require that this is part of what
"insert" does.

The current statistics output (both intermediate and at the end) should probably
also be partially or fully delegated to the open lists. For this, we'll need to
check what kind of information the open lists require.

We should implement a common base class for open lists.
Both search implementations will be able to use any of these open lists.
The interface for an open list will consists of:
    insert(state, ???)
    remove_min()

Derived classes will be
    Normal open list (should be based on the map implementation - but check 
efficiency first)
    Tie Breaking 
    Pareto Optimal
    Alternation

The open list will implement the calculcation of f based on g and h (h will be 
taken from the Heuristic class)