/*
 * IndexedValue_impl.hpp
 *
 *  Created on: 29.07.2012
 *      Author: heber
 */

#ifndef INDEXEDVALUE_IMPL_HPP_
#define INDEXEDVALUE_IMPL_HPP_

// include config.h
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

#include "CodePatterns/Assert.hpp"

#include "IndexedValue.hpp"

#include "CodePatterns/Log.hpp"

#include <iostream>

#include "Fragmentation/Summation/ZeroInstance.hpp"

template <class value>
const typename IndexedValue<value>::index_t IndexedValue<value>::DropIndex(-1);

template <class value>
IndexedValue<value>::IndexedValue(
    const IndexedValue<value>::indices_t &_indices,
    const IndexedValue<value>::values_t &_values)
{
  ASSERT(_indices.size() == _values.size(),
      "IndexedVectors::IndexedVectors() - vector of indices and values don't match in size.");
  typename indices_t::const_iterator indexiter = _indices.begin();
  typename values_t::const_iterator vectoriter = _values.begin();
  for (; vectoriter != _values.end(); ++indexiter, ++vectoriter) {
    if (*indexiter != DropIndex) { // skip all force values associated to -1
#ifndef NDEBUG
      std::pair<typename indexedvalues_t::iterator, bool> inserter =
#endif
      values.insert( std::make_pair( *indexiter, *vectoriter) );
      ASSERT( inserter.second,
          "IndexedValue<>::IndexedValue() - index "
          +toString(inserter.first->first)+" already present with vector "
          +toString(inserter.first->second)+".");
    }
  }
}

template <class value>
IndexedValue<value>& IndexedValue<value>::operator=(const IndexedValue<value> &other)
{
  // check for self-assignment
  if (this != &other) {
    values.clear();
    values = other.values;
  }
  return *this;
}

template <class value>
void IndexedValue<value>::superposeOtherIndexedVectors(const IndexedValue<value> &other, const double prefactor)
{
  for (typename indexedvalues_t::const_iterator otheriter = other.values.begin();
      otheriter != other.values.end(); ++otheriter) {
    typename indexedvalues_t::iterator iter = values.find(otheriter->first);
    if (iter == values.end()) {
      // index does not exist
      std::pair<typename indexedvalues_t::iterator, bool> inserter =
          values.insert( std::make_pair( otheriter->first, ZeroInstance<value>()) );
      ASSERT( inserter.second,
          "IndexedValue<>::superposeOtherIndexedVectors() - index is present though unfound before?");
      iter = inserter.first;
    }
    iter->second.superposeOtherIndexedVectors(otheriter->second, prefactor);
  }
}

template <class value>
bool IndexedValue<value>::operator==(const IndexedValue<value>& other) const
{
  bool status = (values == other.values);
  return status;
}

template <class value>
std::ostream & operator<<(std::ostream &ost, const IndexedValue<value> &other)
{
  for (typename IndexedValue<value>::indexedvalues_t::const_iterator iter = other.values.begin();
      iter != other.values.end(); ++iter)
    ost << "(" << iter->first << "," << iter->second << ") ";
  return ost;
}


#endif /* INDEXEDVALUE_IMPL_HPP_ */