RhodeCode

/* -*- mode: C++; indent-tabs-mode: nil; -*-
 *
 * This file is a part of LEMON, a generic C++ optimization library.
 *
 * Copyright (C) 2003-2011
 * 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_SOLVER_BITS_H
#define LEMON_BITS_SOLVER_BITS_H

#include <vector>

namespace lemon {

  namespace _solver_bits {

    class VarIndex {
    private:
      struct ItemT {
        int prev, next;
        int index;
      };
      std::vector<ItemT> items;
      int first_item, last_item, first_free_item;

      std::vector<int> cross;

    public:

      VarIndex()
        : first_item(-1), last_item(-1), first_free_item(-1) {
      }

      void clear() {
        first_item = -1;
        first_free_item = -1;
        items.clear();
        cross.clear();
      }

      int addIndex(int idx) {
        int n;
        if (first_free_item == -1) {
          n = items.size();
          items.push_back(ItemT());
        } else {
          n = first_free_item;
          first_free_item = items[n].next;
          if (first_free_item != -1) {
            items[first_free_item].prev = -1;
          }
        }
        items[n].index = idx;
        if (static_cast<int>(cross.size()) <= idx) {
          cross.resize(idx + 1, -1);
        }
        cross[idx] = n;

        items[n].prev = last_item;
        items[n].next = -1;
        if (last_item != -1) {
          items[last_item].next = n;
        } else {
          first_item = n;
        }
        last_item = n;

        return n;
      }

      int addIndex(int idx, int n) {
        while (n >= static_cast<int>(items.size())) {
          items.push_back(ItemT());
          items.back().prev = -1;
          items.back().next = first_free_item;
          if (first_free_item != -1) {
            items[first_free_item].prev = items.size() - 1;
          }
          first_free_item = items.size() - 1;
        }
        if (items[n].next != -1) {
          items[items[n].next].prev = items[n].prev;
        }
        if (items[n].prev != -1) {
          items[items[n].prev].next = items[n].next;
        } else {
          first_free_item = items[n].next;
        }

        items[n].index = idx;
        if (static_cast<int>(cross.size()) <= idx) {
          cross.resize(idx + 1, -1);
        }
        cross[idx] = n;

        items[n].prev = last_item;
        items[n].next = -1;
        if (last_item != -1) {
          items[last_item].next = n;
        } else {
          first_item = n;
        }
        last_item = n;

        return n;
      }

      void eraseIndex(int idx) {
        int n = cross[idx];

        if (items[n].prev != -1) {
          items[items[n].prev].next = items[n].next;
        } else {
          first_item = items[n].next;
        }
        if (items[n].next != -1) {
          items[items[n].next].prev = items[n].prev;
        } else {
          last_item = items[n].prev;
        }

        if (first_free_item != -1) {
          items[first_free_item].prev = n;
        }
        items[n].next = first_free_item;
        items[n].prev = -1;
        first_free_item = n;

        while (!cross.empty() && cross.back() == -1) {
          cross.pop_back();
        }
      }

      int maxIndex() const {
        return cross.size() - 1;
      }

      void shiftIndices(int idx) {
        for (int i = idx + 1; i < static_cast<int>(cross.size()); ++i) {
          cross[i - 1] = cross[i];
          if (cross[i] != -1) {
            --items[cross[i]].index;
          }
        }
        cross.back() = -1;
        cross.pop_back();
        while (!cross.empty() && cross.back() == -1) {
          cross.pop_back();
        }
      }

      void relocateIndex(int idx, int jdx) {
        cross[idx] = cross[jdx];
        items[cross[jdx]].index = idx;
        cross[jdx] = -1;

        while (!cross.empty() && cross.back() == -1) {
          cross.pop_back();
        }
      }

      int operator[](int idx) const {
        return cross[idx];
      }

      int operator()(int fdx) const {
        return items[fdx].index;
      }

      void firstItem(int& fdx) const {
        fdx = first_item;
      }

      void nextItem(int& fdx) const {
        fdx = items[fdx].next;
      }

    };
  }
}

#endif