RhodeCode

/* -*- mode: C++; indent-tabs-mode: nil; -*-
 *
 * This file is a part of LEMON, a generic C++ optimization library.
 *
 * Copyright (C) 2003-2008
 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
 * (Egervary Research Group on Combinatorial Optimization, EGRES).
 *
 * Permission to use, modify and distribute this software is granted
 * provided that this copyright notice appears in all copies. For
 * precise terms see the accompanying LICENSE file.
 *
 * This software is provided "AS IS" with no warranty of any kind,
 * express or implied, and with no claim as to its suitability for any
 * purpose.
 *
 */

#ifndef LEMON_BITS_LP_SOLVER_ID_H
#define LEMON_BITS_LP_SOLVER_ID_H

namespace lemon {

  namespace _lp_bits {

    struct LpIdImpl {
      std::vector<int> index;
      std::vector<int> cross;
      int first_index;
      int first_free;
    };

    class LpId {
    public:

      class IdHandler {
      public:
        virtual ~IdHandler() {}
        virtual int addId(LpIdImpl&) = 0;
        virtual void eraseId(LpIdImpl&, int xn) = 0;
      };

      LpId(int min_index = 0) {
        id_handler = 0;
        impl.first_free = -1;
        impl.first_index = min_index;
        impl.cross.resize(impl.first_index);
      }

      LpId(const LpId& li) {
        id_handler = 0;
        impl = li.impl;
      }

      LpId& operator=(const LpId& li) {
        id_handler = 0;
        impl = li.impl;
        return *this;
      }

      void setIdHandler(IdHandler& ih) {
        id_handler = &ih;
      }

      int fixId(int fn) const {return impl.cross[fn];}
      int floatingId(int xn) const {return impl.index[xn];}

      int addId() {
        if (id_handler == 0) {
          int xn, fn = impl.cross.size();
          if (impl.first_free == -1) {
            xn = impl.index.size();
            impl.index.push_back(fn);
          } else {
            xn = impl.first_free;
            impl.first_free = impl.index[impl.first_free];
            impl.index[xn] = fn;
          }
          impl.cross.push_back(xn);
          return xn;
        } else {
          return id_handler->addId(impl);
        }
      }

      void eraseId(int xn) {
        if (id_handler == 0) {
          int fn = impl.index[xn];
          impl.index[xn] = impl.first_free;
          impl.first_free = xn;
          for(int i = fn + 1; i < int(impl.cross.size()); ++i) {
            impl.cross[i - 1] = impl.cross[i];
            impl.index[impl.cross[i]]--;
          }
          impl.cross.pop_back();
        } else {
          id_handler->eraseId(impl, xn);
        }
      }

      void firstFloating(int& fn) const {
        fn = impl.first_index;
        if (fn == int(impl.cross.size())) fn = -1;
      }

      void nextFloating(int& fn) const {
        ++fn;
        if (fn == int(impl.cross.size())) fn = -1;
      }

      void firstFix(int& xn) const {
        int fn;
        firstFloating(fn);
        xn = fn != -1 ? fixId(fn) : -1;
      }

      void nextFix(int& xn) const {
        int fn = floatingId(xn);
        nextFloating(fn);
        xn = fn != -1 ? fixId(fn) : -1;
      }

    protected:
      LpIdImpl impl;
      IdHandler *id_handler;
    };

    class RelocateIdHandler : public LpId::IdHandler {
    public:

      virtual int addId(LpIdImpl& impl) {
        int xn, fn = impl.cross.size();
        if (impl.first_free == -1) {
          xn = impl.index.size();
          impl.index.push_back(fn);
        } else {
          xn = impl.first_free;
          impl.first_free = impl.index[impl.first_free];
          impl.index[xn] = fn;
        }
        impl.cross.push_back(xn);
        return xn;
      }

      virtual void eraseId(LpIdImpl& impl, int xn) {
        int fn = impl.index[xn];
        impl.index[xn] = impl.first_free;
        impl.first_free = xn;
        impl.cross[fn] = impl.cross.back();
        impl.index[impl.cross.back()] = fn;
        impl.cross.pop_back();
      }
    };
  }
}

#endif