Styling.h

/**************************************************************************
 * basf2 (Belle II Analysis Software Framework)                           *
 * Author: The Belle II Collaboration                                     *
 *                                                                        *
 * See git log for contributors and copyright holders.                    *
 * This file is licensed under LGPL-3.0, see LICENSE.md.                  *
 **************************************************************************/
#pragma once
 
#include <tracking/trackFindingCDC/display/ColorMapping.h>
#include <tracking/trackFindingCDC/display/Mapping.h>
#include <tracking/trackFindingCDC/display/AttributeMap.h>
 
 
#include <map>
#include <sstream>
#include <memory>
 
namespace Belle2 {
  class RecoTrack;
  class CDCHit;
 
  namespace TrackingUtilities {
    class CDCSegment2D;
  }
  namespace TrackFindingCDC {

    template <class AObject>
    class Styling {
 
    public:
      virtual ~Styling() = default;

      virtual AttributeMap map(int index __attribute__((unused)),
                               AObject& object __attribute__((unused)))
      {
        return {};
      }

      virtual std::string info()
      {
        return "(no info available)\n";
      }
    };

    template <class AObject>
    class FixedStyling : public Styling<AObject> {
 
    public:
      AttributeMap map(int index __attribute__((unused)),
                       AObject& object __attribute__((unused))) override
      {
        return m_attributeMap;
      }

      std::string info() override
      {
        std::ostringstream oss;
        for (const auto& keyValue : m_attributeMap) {
          oss << keyValue.first << ": " << keyValue.second << '\n';
        }
        return oss.str();
      }

      void set(const std::string& key, const std::string& value)
      {
        m_attributeMap.emplace(key, value);
      }

      void setStroke(const std::string& value)
      {
        set("stroke", value);
      }

      void setStrokeWidth(const std::string& value)
      {
        set("stroke-width", value);
      }
 
    private:
      AttributeMap m_attributeMap;
    };

    template <class AObject>
    class ChooseableStyling : public Styling<AObject> {
 
    public:
      using ObjectMapping = Mapping<AObject>;
 
    public:
      AttributeMap map(int index, AObject& object) override
      {
        AttributeMap attributeMap;
        for (const auto& keyMapping : m_mappingsByKey) {
          const std::string& key = keyMapping.first;
          const std::unique_ptr<ObjectMapping>& mapping = keyMapping.second;
          attributeMap[key] = mapping->map(index, object);
        }
        return attributeMap;
      }

      std::string info() override
      {
        std::ostringstream oss;
        for (const auto& keyMapping : m_mappingsByKey) {
          const std::string& key = keyMapping.first;
          const std::unique_ptr<ObjectMapping>& mapping = keyMapping.second;
          oss << key << ": " << mapping->info();
        }
        return oss.str();
      }

      virtual std::unique_ptr<ObjectMapping> createMapping(const std::string& mappingName)
      {
        return std::make_unique<ConstantMapping<AObject>>(mappingName);
      }

      void set(const std::string& key, std::unique_ptr<ObjectMapping> mapping)
      {
        if (mapping) {
          m_mappingsByKey[key] = std::move(mapping);
        }
      }

      void set(const std::string& key, const std::string& mappingName)
      {
        std::unique_ptr<ObjectMapping> objectMapping = this->createMapping(mappingName);
        if (objectMapping) {
          set(key, std::move(objectMapping));
        }
      }

      void setStroke(const std::string& mappingName)
      {
        set("stroke", mappingName);
      }

      void setStrokeWidth(const std::string& mappingName)
      {
        set("stroke-width", mappingName);
      }
 
    protected:
      std::map<std::string, std::unique_ptr<ObjectMapping> > m_mappingsByKey;
    };

    template <class AObject>
    class DefaultColorCycleStyling : public ChooseableStyling<AObject> {
    public:
      DefaultColorCycleStyling() : ChooseableStyling<AObject>()
      {
        this->set("stroke", std::make_unique<DefaultColorCycleMapping<AObject>>());
      }
    };

    class ChooseableRecoTrackStyling : public ChooseableStyling<const RecoTrack> {
 
    private:
      using Super = ChooseableStyling<const RecoTrack>;

      using Super::ObjectMapping;
 
    public:
      std::unique_ptr<ObjectMapping> createMapping(const std::string& mappingName) override;
    };

    class ChooseableSegmentStyling : public ChooseableStyling<const TrackingUtilities::CDCSegment2D> {
 
    private:
      using Super = ChooseableStyling<const TrackingUtilities::CDCSegment2D>;

      using Super::ObjectMapping;
 
    public:
      std::unique_ptr<ObjectMapping> createMapping(const std::string& mappingName) override;
    };

    class ChooseableHitStyling : public ChooseableStyling<const CDCHit> {
 
    private:
      using Super = ChooseableStyling<const CDCHit>;

      using Super::ObjectMapping;
 
    public:
      std::unique_ptr<ObjectMapping> createMapping(const std::string& mappingName) override;
    };
  }
}