Method put

kernel/linear_algebra/CacheImplementation.h:170–352

template<class KeyClass, class ValueClass>
bool Cache<KeyClass, ValueClass>::put (const KeyClass& key,
                                       const ValueClass& value)
{
  bool keyWasContained = false;
  int oldIndexInKey = -1;
  int newIndexInKey = _key.size();  /* default to enter new (key, value)-pair
                                       is at the end of the two lists;
                                       only used in the case
                                       keyWasContained == false */
  int k = 0;
  typename std::list<KeyClass>::iterator itKey;
  // itOldValue will later only be used in the case keyWasContained == true: */
  typename std::list<ValueClass>::iterator itOldValue = _value.begin();
  /* itOldWeights will later only be used in the case
     keyWasContained == true */
  typename std::list<int>::iterator itOldWeights = _weights.begin();
  for (itKey = _key.begin(); itKey != _key.end(); itKey++)
  {
    int c = key.compare(*itKey);
    if (c == -1)
    {
      newIndexInKey = k;
      break;
    }
    if (c == 0)
    {
      keyWasContained = true;
      oldIndexInKey = k;
      break;
    }
    itOldValue++;
    itOldWeights++;
    k++;
  }
  int utility = value.getUtility();
  int newWeight = value.getWeight();
  k = 0;
  typename std::list<ValueClass>::iterator itValue = _value.begin();
  for (itValue = _value.begin(); itValue != _value.end(); itValue++)
  {
    if (itValue->getUtility() > utility) k++;
  }
  int newIndexInRank = k;

  if (keyWasContained)
  {
    /* There was already a pair of the form (key --> *). */

    /*adjusting the weight of the cache */
    ValueClass oldValue = *itOldValue;
    _weight += newWeight - *itOldWeights;

    /* overwriting old value by argument value */
    itOldValue = _value.erase(itOldValue);
    itOldWeights = _weights.erase(itOldWeights);
    ValueClass myValueCopy = value;
    _value.insert(itOldValue, myValueCopy);
    _weights.insert(itOldWeights, newWeight);