ParametrizableCollection.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: The Bio++ Development Group
//
// SPDX-License-Identifier: CECILL-2.1

#ifndef BPP_NUMERIC_PARAMETRIZABLECOLLECTION_H
#define BPP_NUMERIC_PARAMETRIZABLECOLLECTION_H


#include "AbstractParameterAliasable.h"
#include "Parametrizable.h"

// From the STL:
#include <map>
#include <memory>

namespace bpp
{
template<class N>
class ParametrizableCollection :
  public AbstractParameterAliasable
{
protected:
  std::map<size_t, std::shared_ptr<N>> objectsSet_;

  std::vector<size_t> vChanged_;

public:
  ParametrizableCollection() :
    AbstractParameterAliasable(""),
    objectsSet_(),
    vChanged_()
  {}

  ParametrizableCollection(const ParametrizableCollection<N>& set) :
    AbstractParameterAliasable(set),
    objectsSet_(),
    vChanged_(set.vChanged_)
  {
    // Duplicate all objects:

    for (const auto& it:set.objectsSet_)
    {
      objectsSet_[it.first] = std::shared_ptr<N>(it.second->clone());
    }
  }

  ParametrizableCollection<N>& operator=(const ParametrizableCollection<N>& set)
  {
    clear();

    AbstractParameterAliasable::operator=(set);
    vChanged_ = set.vChanged_;

    // Duplicate all objects:

    for (const auto& it:set.objectsSet_)
    {
      objectsSet_[it.first] = std::shared_ptr<N>(it.second->clone());
    }

    return *this;
  }

  void clear()
  {
    resetParameters_();

    objectsSet_.clear();
    vChanged_.empty();
  }

  ~ParametrizableCollection()
  {
    clear();
  }

  ParametrizableCollection<N>* clone() const { return new ParametrizableCollection<N>(*this); }

public:
  void fireParameterChanged(const ParameterList& parameters)
  {
    vChanged_.clear();

    std::vector<size_t> vCh;

    std::map<size_t, ParameterList > mNumPl;

    for (size_t i = 0; i < parameters.size(); i++)
    {
      std::string n = parameters[i].getName();
      size_t t = n.rfind("_");
      if (t == std::string::npos)
        continue;
      size_t num = (size_t)atoi(n.substr(t + 1).c_str());
      mNumPl[num].addParameter(Parameter(n.substr(0, t), parameters[i].getValue()));
    }

    std::map<size_t, ParameterList >::iterator it;

    // Then we update all objects in the set:
    for (it = mNumPl.begin(); it != mNumPl.end(); it++)
    {
      if (hasObject(it->first) && objectsSet_[it->first]->matchParametersValues(it->second))
        vChanged_.push_back(it->first);
    }
  }

  std::vector<size_t> hasChanged() const
  {
    return vChanged_;
  }

  void clearChanged()
  {
    vChanged_.clear();
  }

  size_t getNumberOfObjects() const { return objectsSet_.size(); }

  bool hasObject(size_t objectIndex) const
  {
    return objectsSet_.find(objectIndex) != objectsSet_.end();
  }

  bool hasObject(std::shared_ptr<N> object) const
  {
    for (const auto key : objectsSet_)
    {
      if (key.second == object)
        return true;
    }
    return false;
  }

  size_t getFirstKey(std::shared_ptr<N> object) const
  {
    for (const auto key:objectsSet_)
    {
      if (key.second == object)
        return key.first;
    }

    throw Exception("ParametrizableCollection::getFirstKey: Unknown object");
    return 0;
  }

  const std::vector<size_t> keys() const
  {
    std::vector<size_t> vkeys;

    for (const auto& it:objectsSet_)
    {
      vkeys.push_back(it.first);
    }

    return vkeys;
  }

  std::shared_ptr<const N> operator[](size_t objectIndex) const
  {
    const auto it = objectsSet_.find(objectIndex);
    if (it == objectsSet_.end())
      throw BadIntegerException("ParametrizableCollection::getObject().", (int)objectIndex);

    return std::dynamic_pointer_cast<const N>(it->second);
  }

  std::shared_ptr<N> operator[](size_t objectIndex)
  {
    auto it = objectsSet_.find(objectIndex);
    if (it == objectsSet_.end())
      throw BadIntegerException("ParametrizableCollection::getObject().", (int)objectIndex);

    return it->second;
  }

  ParameterList getParametersForObject(size_t objectIndex) const
  {
    ParameterList pl;
    const auto it = objectsSet_.find(objectIndex);

    if (it != objectsSet_.end())
    {
      if (std::dynamic_pointer_cast<const ParameterAliasable>(it->second) != NULL)
        pl = std::dynamic_pointer_cast<const ParameterAliasable>(it->second)->getIndependentParameters();
      else
        pl = it->second->getParameters();

      for (size_t i = 0; i < pl.size(); i++)
      {
        pl[i].setName(pl[i].getName() + "_" + TextTools::toString(objectIndex));
      }
    }
    return pl;
  }

  void addObject(std::shared_ptr<N> object, size_t objectIndex)
  {
    auto it = objectsSet_.find(objectIndex);
    if (it != objectsSet_.end())
      throw BadIntegerException("ParametrizableCollection<N>::addObject. Object objectIndex already used", (int)objectIndex);

    objectsSet_[objectIndex] = object;

    // Associate parameters:
    std::vector<std::string> nplm;
    nplm = object->getParameters().getParameterNames();

    for (const auto& pname:nplm)
    {
      Parameter* p = new Parameter(object->getParameters().parameter(pname));
      p->setName(pname + "_" + TextTools::toString(objectIndex));
      addParameter_(p);
    }

    if (std::dynamic_pointer_cast<ParameterAliasable>(object))
    {
      auto ppa = std::dynamic_pointer_cast<ParameterAliasable>(object);
      for (const auto& name:nplm)
      {
        std::vector<std::string> va = ppa->getAlias(name);
        for (const auto& alias:va)
        {
          aliasParameters(name + "_" + TextTools::toString(objectIndex), alias + "_" + TextTools::toString(objectIndex));
        }
      }
    }
  }

  std::shared_ptr<N> removeObject(size_t objectIndex)
  {
    if (objectsSet_.find(objectIndex) == objectsSet_.end())
      throw BadIntegerException("ParametrizableCollection<N>::removeObject. None Object at this objectIndex", (int)objectIndex);

    auto pm = objectsSet_[objectIndex];
    objectsSet_.erase(objectIndex);

    // Erase all parameter references to this object and translate other indices...

    ParameterList pl = getParameters();

    for (size_t i = pl.size(); i > 0; i--)
    {
      std::string pn = pl[i - 1].getName();

      size_t pu = pn.rfind("_");
      int nm = atoi(pn.substr(pu + 1).c_str());
      if (nm == (int)objectIndex)
      {
        std::vector<std::string> alpn = getAlias(pn);
        for (unsigned j = 0; j < alpn.size(); j++)
        {
          try
          {
            unaliasParameters(alpn[j], pn);
          }
          catch (Exception& e)
          {
            continue;
          }
        }
        deleteParameter_(i - 1);
      }
    }

    return pm;
  }

  std::shared_ptr<N> replaceObject(std::shared_ptr<N> object, size_t objectIndex)
  {
    auto pm = removeObject(objectIndex);
    addObject(object, objectIndex);
    return pm;
  }
};
} // end of namespace bpp.
#endif // BPP_NUMERIC_PARAMETRIZABLECOLLECTION_H