StoreArrayLoader.h

/**************************************************************************
 * BASF2 (Belle Analysis Framework 2)                                     *
 * Copyright(C) 2017 - Belle II Collaboration                             *
 *                                                                        *
 * Author: The Belle II Collaboration                                     *
 * Contributors: Oliver Frost, Nils Braun                                 *
 *                                                                        *
 * 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 <framework/core/ModuleParamList.h>
#include <framework/datastore/StoreArray.h>
 
#include <vector>
 
namespace Belle2 {
  namespace TrackFindingCDC {
 
    template <class IOType>
    class StoreArrayLoader : public Findlet<IOType*> {
 
      using Super =  Findlet<IOType*>;
 
    public:
      StoreArrayLoader(const std::string& storeArrayName = "",
                       const std::string& classMnemomicName = "",
                       const std::string& classMnemomicDescription = "")
        : m_param_storeArrayName(storeArrayName),
          m_classMnemomicName(classMnemomicName),
          m_classMnemomicDescription(classMnemomicDescription)
      {
        if (m_classMnemomicDescription == "") {
          if (m_classMnemomicName != "") {
            m_classMnemomicDescription = m_classMnemomicName;
          } else {
            // Just a little bit of ADL, taken from StoreArraySwapper
            m_classMnemomicDescription = getClassMnemomicParameterDescription(static_cast<IOType*>(nullptr));
          }
        }
 
        if (m_classMnemomicName == "") {
          // Just a little bit of ADL, takem from StoreArraySwapper
          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));
 
        moduleParamList->addParameter(prefixed(prefix, classMnemomicCapitalName + "sStoreArrayName"),
                                      m_param_storeArrayName,
                                      "Name of the StoreArray of the " + m_classMnemomicDescription,
                                      std::string(m_param_storeArrayName));
      }
 
      std::string getDescription() override
      {
        return "Swaps an interal vector of " + m_classMnemomicDescription + "s to the DataStore";
      }
 
      void initialize() override
      {
        Super::initialize();
        StoreArray<IOType> storeArray(m_param_storeArrayName);
        storeArray.isRequired();
      }
 
      void apply(std::vector<IOType*>& output) final {
        // Swap items to the DataStore
        StoreArray<IOType> storeArray(m_param_storeArrayName);
 
        output.reserve(output.size() + storeArray.getEntries());
 
        for (auto& item : storeArray)
        {
          // cppcheck-suppress useStlAlgorithm
          output.push_back(&item);
        }
      }
 
    private:
      std::string m_param_storeArrayName;
 
      std::string m_classMnemomicName;
 
      std::string m_classMnemomicDescription;
    };
  }
}