/* -*- 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;

        last_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