RhodeCode

    int _highest_active;

    void copy(Item i, Vit p)

    {

    }

    void copy(Vit s, Vit p)

    {

      if(s!=p)

        {

          Item i=*s;

          *p=i;

        }

    }

    void swap(Vit i, Vit j)

    {

      Item ti=*i;

      Vit ct = _where[ti];

      *j=ti;

    }

  public:

    ///Lift the item returned by highestActive() by one.

    ///

    void liftHighestActive()

    {

      swap(_last_active[_highest_active]--,_last_active[_highest_active+1]);

      --_first[++_highest_active];

    }

          copy(--_first[l+1],_first[l]);

          --_last_active[l];

        }

      copy(li,_first[new_level]);

      _highest_active=new_level;

    }

    ///Lift the highest active item.

          --_last_active[l];

        }

      copy(li,_first[_max_level]);

      --_last_active[_max_level];

      while(_highest_active>=0 &&

            _last_active[_highest_active]<_first[_highest_active])

        _highest_active--;

    ///Lifts the active item returned by \c activeOn() member function

    ///by one.

    Item liftActiveOn(int level)

    {

      swap(_last_active[level]--, --_first[level+1]);

      if (level+1>_highest_active) ++_highest_active;

    }

          copy(_last_active[l],_first[l]);

          copy(--_first[l+1], _last_active[l]--);

        }

      copy(ai,_first[new_level]);

      if (new_level>_highest_active) _highest_active=new_level;

    }

    ///Lifts the active item returned by \c activeOn() member function.

          copy(--_first[l+1], _last_active[l]--);

        }

      copy(ai,_first[_max_level]);

      --_last_active[_max_level];

      if (_highest_active==level) {

        while(_highest_active>=0 &&

              _last_active[_highest_active]<_first[_highest_active])

          copy(_last_active[l],_first[l]);

          copy(--_first[l+1],_last_active[l]--);

        }

      copy(i,_first[new_level]);

      if(new_level>_highest_active) _highest_active=new_level;

    }

    ///Move an inactive item to the top but one level (in a dirty way).

    ///It makes the underlying datastructure corrupt, so use is only if

    ///you really know what it is for.

    ///\pre The item is on the top level.

    void dirtyTopButOne(Item i) {

    }

    ///Lift all items on and above a level to the top (and deactivate them).

    {

      const Vit f=_first[l];

      const Vit tl=_first[_max_level];

      for(Vit i=f;i!=tl;++i)

      for(int i=l;i<=_max_level;i++)

        {

          _first[i]=f;

          _last_active[i]=f-1;

      Vit n=&_items[0];

      for(typename ItemSetTraits<Graph,Item>::ItemIt i(_g);i!=INVALID;++i)

        {

          *n=i;

          ++n;

        }

    }

    ///Add an item to the current level.

    void initAddItem(Item i)

    {

      ++_init_num;

    }

    ///Start a new level.