StoreVectorSwapper.h

/**************************************************************************
 * BASF2 (Belle Analysis Framework 2)                                     *
 * Copyright(C) 2015 - Belle II Collaboration                             *
 *                                                                        *
 * Author: The Belle II Collaboration                                     *
 * Contributors: Oliver Frost                                             *
 *                                                                        *
 * This software is provided "as is" without any warranty.                *
 **************************************************************************/
#pragma once
 
#include <tracking/trackFindingCDC/findlets/base/Findlet.h>
#include <tracking/trackFindingCDC/utilities/StringManipulation.h>
#include <tracking/trackFindingCDC/rootification/StoreWrappedObjPtr.h>
 
#include <framework/core/ModuleParamList.h>
 
#include <vector>
 
namespace Belle2 {
  namespace TrackFindingCDC {
 
 
    template<class IOType, bool a_alwaysWrite = false>
    class StoreVectorSwapper:
      public Findlet<IOType> {
 
    private:
      using Super = Findlet<IOType>;
 
    public:
      explicit StoreVectorSwapper(const std::string& storeVectorName,
                                  const std::string& classMnemomicName = "",
                                  const std::string& classMnemomicDescription = "")
        : m_param_storeVectorName(storeVectorName),
          m_classMnemomicName(classMnemomicName),
          m_classMnemomicDescription(classMnemomicDescription)
      {
        if (m_classMnemomicDescription == "") {
          if (m_classMnemomicName != "") {
            m_classMnemomicDescription = m_classMnemomicName;
          } else {
            // Just a little bit of ADL
            m_classMnemomicDescription = getClassMnemomicParameterDescription(static_cast<IOType*>(nullptr));
          }
        }
 
        if (m_classMnemomicName == "") {
          // Just a little bit of ADL
          m_classMnemomicName = getClassMnemomicParameterName(static_cast<IOType*>(nullptr));
        }
      }
 
      void exposeParameters(ModuleParamList* moduleParamList, const std::string& prefix) override
      {
        std::string classMnemomicCapitalName = m_classMnemomicName;
        classMnemomicCapitalName[0] = ::toupper(classMnemomicCapitalName.at(0));
 
        if (not a_alwaysWrite) {
          moduleParamList->addParameter(prefixed(prefix, "Write" + classMnemomicCapitalName + "s"),
                                        m_param_writeStoreVector,
                                        "Switch if " + m_classMnemomicDescription +
                                        "s shall be written to the DataStore",
                                        m_param_writeStoreVector);
        }
 
        moduleParamList->addParameter(prefixed(prefix, classMnemomicCapitalName + "sStoreObjName"),
                                      m_param_storeVectorName,
                                      "Name of the output StoreObjPtr of the " + m_classMnemomicDescription +
                                      "s generated within this module.",
                                      std::string(m_param_storeVectorName));
        //FIXME: Small parameter names
      }
 
      std::string getDescription() override
      {
        return "Swaps an interal vector of " + m_classMnemomicDescription + "s to the DataStore";
      }
 
    public:
      void initialize() override
      {
        Super::initialize();
        if (m_param_writeStoreVector) {
          StoreWrappedObjPtr< std::vector<IOType> > storeVector(m_param_storeVectorName);
          storeVector.registerInDataStore(DataStore::c_DontWriteOut | DataStore::c_ErrorIfAlreadyRegistered);
        }
      }
 
      void beginEvent() override
      {
        Super::beginEvent();
 
        if (m_param_writeStoreVector) {
          StoreWrappedObjPtr< std::vector<IOType> > storeVector(m_param_storeVectorName);
          if (not storeVector.isValid()) {
            storeVector.construct();
          }
        }
        m_backup.clear();
      }
 
      void apply(std::vector<IOType>& input) final {
        // Swap items to the DataStore
        if (m_param_writeStoreVector)
        {
          StoreWrappedObjPtr< std::vector<IOType> > storeVector(m_param_storeVectorName);
          std::vector<IOType>& sink = *storeVector;
          sink.swap(input);
        } else {
          m_backup.swap(input);
        }
      }
 
    private:
      std::string m_param_storeVectorName;
 
      bool m_param_writeStoreVector = a_alwaysWrite;
 
      std::string m_classMnemomicName;
 
      std::string m_classMnemomicDescription;
 
      std::vector<IOType> m_backup;
    };
  }
}