FixedSizeNamedFloatTuple.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/varsets/NamedFloatTuple.h>
 
#include <string>
#include <cassert>
 
namespace Belle2 {
  namespace TrackFindingCDC {
 
    constexpr
    bool strequal(char const* s1, char const* s2)
    {
      return (not * s1 and not * s2) or (*s1 and * s2 and * s1 == *s2 and strequal(s1 + 1, s2 + 1));
    }
 
    template <size_t nVars>
    constexpr int index(const char* const(&names)[nVars], const char* name, size_t iName = 0)
    {
      return ((nVars == iName) ?
              iName :
              strequal(names[iName], name) ? iName : index(names, name, iName + 1));
    }
 
    template<size_t nVars>
    constexpr
    int index(const char* (getName(int)),
              const char* const name,
              const size_t iName = 0)
    {
      return ((nVars == iName) ?
              iName :
              strequal(getName(iName), name) ? iName : index<nVars>(getName, name, iName + 1));
    }
 
    // *INDENT-OFF*
    template <class T, size_t N>
    constexpr size_t size(T (&array)[N] __attribute__((unused)))
    {
      return N;
    }
    // *INDENT-ON*
 
    template<class ANames>
    class FixedSizeNamedFloatTuple : public NamedFloatTuple {
 
    private:
      static const size_t nVars = ANames::nVars;
 
    protected:
      constexpr static int named(const char* name)
      {
        return index<nVars>(ANames::getName, name);
      }
 
    public:
      size_t size() const final
      {
        return ANames::nVars;
      }
 
      int getNameIndex(const char* name) const final
      {
        return named(name);
      }
 
      std::string getName(int iValue) const final
      {
        assert(iValue < (int)nVars);
        assert(iValue >= 0);
        return ANames::getName(iValue);
      }
 
    public:
      template<int I>
      void set(Float_t value)
      {
        static_assert(nVars != I, "Requested name not found in names.");
        assert(I < (int)nVars);
        assert(I >= 0);
        m_values[I] = value;
      }
 
      void set(int iValue, Float_t value) final {
        assert(iValue < (int)nVars);
        assert(iValue >= 0);
        m_values[iValue] = value;
      }
 
      void set(const char* name, Float_t value)
      {
        set(named(name), value);
      }
 
      template<int I>
      Float_t get() const
      {
        static_assert(nVars != I, "Requested name not found in names.");
        assert(I < (int)nVars);
        assert(I >= 0);
        return m_values[I];
      }
 
      Float_t get(int iValue) const final
      {
        assert(iValue < (int)nVars);
        assert(iValue >= 0);
        return m_values[iValue];
      }
 
      Float_t get(const char* name) const
      {
        return get(named(name));
      }
 
      template<int I>
      Float_t& var()
      {
        static_assert(nVars != I, "Requested name not found in names.");
        assert(I < (int)nVars);
        assert(I >= 0);
        return m_values[I];
      }
 
      Float_t& operator[](int iValue) final {
        assert(iValue < (int)nVars);
        assert(iValue >= 0);
        return m_values[iValue];
      }
 
      Float_t& operator[](const char* name)
      {
        return this->var(named(name));
      }
 
    public:
      Float_t m_values[nVars] = {};
 
    };
  }
}