BCP_vector_change.hpp

Go to the documentation of this file.

// Copyright (C) 2000, International Business Machines
// Corporation and others.  All Rights Reserved.
#ifndef _BCP_VECTOR_CHANGE_H
#define _BCP_VECTOR_CHANGE_H

// This file is fully docified.

#include "CoinHelperFunctions.hpp"
#include "BCP_enum.hpp"
#include "BCP_vector.hpp"
#include "BCP_buffer.hpp"

template <class T> class BCP_vec_change {
 private:
  BCP_storage_t _storage;
  BCP_vec<int>  _del_pos;
  BCP_vec<int>  _change_pos;
  BCP_vec<T>    _values;

 public:
    BCP_vec_change(const BCP_storage_t st) : _storage(st) {}

    BCP_vec_change(const T* first, const T* last) :
    _storage(BCP_Storage_Explicit) {
      _values.append(first, last);
    }

    BCP_vec_change(const BCP_vec_change<T>& old_vec,
                   const BCP_vec_change<T>& new_vec,
                   const BCP_vec<int>& del_pos) :
    _storage(BCP_Storage_WrtParent), _del_pos(del_pos) {
      const BCP_vec<T>& ov = old_vec.explicit_vector();
      const BCP_vec<T>& nv = new_vec.explicit_vector();
      const int new_size = nv.size();
      const int old_size = ov.size();
      const int del_size = del_pos.size();
      int i, j, k; // runs on old_vec/new_vec/del_pos
      for (i = 0, j = 0, k = 0; i < old_size && k < del_size; ++i) {
        if (del_pos[k] == i) {
          ++k;
          continue;
        }
        if (ov[i] != nv[j]) {
          _change_pos.push_back(j);
        }
        ++j;
      }
      if (old_size - i > new_size - j)
        throw BCP_fatal_error("BCP_vec_change::BCP_vec_change() : \n  \
old_vec has entries not in new_vec but not listed in del_pos.\n");
      for ( ; i < old_size; ++i, ++j) {
        if (ov[i] != nv[j]) {
          _change_pos.push_back(j);
        }
      }
      const int change_size = _change_pos.size();
      _values.reserve(change_size + new_size - j);
      for (i = 0; i < change_size; ++i) {
        _values.unchecked_push_back(nv[_change_pos[i]]);
      }
      _values.append(nv.entry(j), nv.end());
    }
      
    BCP_vec_change(const BCP_vec_change<T>& old_vec,
                   const BCP_vec_change<T>& new_vec,
                   const BCP_vec<int>& del_pos, const double etol) :
    _storage(BCP_Storage_WrtParent), _del_pos(del_pos) {
      const BCP_vec<T>& ov = old_vec.explicit_vector();
      const BCP_vec<T>& nv = new_vec.explicit_vector();
      const int new_size = nv.size();
      const int old_size = ov.size();
      const int del_size = del_pos.size();
      int i, j, k; // runs on old_vec/new_vec/del_pos
      for (i = 0, j = 0, k = 0; i < old_size && k < del_size; ++i) {
        if (del_pos[k] == i) {
          ++k;
          continue;
        }
        if (CoinAbs(ov[i] - nv[j]) > etol) {
          _change_pos.push_back(j);
        }
        ++j;
      }
      if (old_size - i > new_size - j)
        throw BCP_fatal_error("BCP_vec_change::BCP_vec_change() : \n  \
old_vec has entries not in new_vec but not listed in del_pos.\n");
      for ( ; i < old_size; ++i, ++j) {
        if (CoinAbs(ov[i] - nv[j]) > etol) {
          _change_pos.push_back(j);
        }
      }
      const int change_size = _change_pos.size();
      _values.reserve(change_size + new_size - j);
      for (i = 0; i < change_size; ++i) {
        _values.unchecked_push_back(nv[_change_pos[i]]);
      }
      _values.append(nv.entry(j), nv.end());
    }

    BCP_vec_change(BCP_buffer& buf) {
      unpack(buf);
    }

    ~BCP_vec_change() {}
    BCP_storage_t storage() const { return _storage; }

    const BCP_vec<T>& explicit_vector() const {
      if (_storage != BCP_Storage_Explicit)
        throw BCP_fatal_error("\
BCP_vec_change::explicit_vector() : non-explicit storage!\n");
      return _values;
    }
      
    int storage_size() const {
      return (_del_pos.size() + _change_pos.size()) * sizeof(int) +
        _values.size() * sizeof(T);
    }
      
    void update(const BCP_vec_change<T>& change) {
      switch (change.storage()) {
      case BCP_Storage_Explicit:
        _storage = BCP_Storage_Explicit;
        _del_pos.clear();
        _change_pos.clear();
        _values = change._values;
        return;

      case BCP_Storage_NoData:
        _storage = BCP_Storage_NoData;
        _del_pos.clear();
        _change_pos.clear();
        _values.clear();
        return;

      default: // must be BCP_Storage_WrtParent:
        if (_storage != BCP_Storage_Explicit)
          throw BCP_fatal_error("\
trying to update a non-explicit storage with another non-explicit!\n");
        _values.erase_by_index(change._del_pos);
        const int ch_size = change._change_pos.size();
        for (int i = 0; i < ch_size; ++i) {
          _values[change._change_pos[i]] = change._values[i];
        }
        _values.append(change._values.entry(ch_size), change._values.end());
      }
    }
    void pack(BCP_buffer& buf) const {
      const int st = _storage;
      buf.pack(st).pack(_del_pos).pack(_change_pos).pack(_values);
    }
    void unpack(BCP_buffer& buf) {
      _del_pos.clear();
      _change_pos.clear();
      _values.clear();
      int st;
      buf.unpack(st).unpack(_del_pos).unpack(_change_pos).unpack(_values);
      _storage = static_cast<BCP_storage_t>(st);
    }
};

#endif