Styling.h

/**************************************************************************
 * BASF2 (Belle Analysis Framework 2)                                     *
 * Copyright(C) 2015 - Belle II Collaboration                             *
 *                                                                        *
 * Author: The Belle II Collaboration                                     *
 * Contributors: dschneider, Oliver Frost                                 *
 *                                                                        *
 * This software is provided "as is" without any warranty.                *
 **************************************************************************/
#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 TrackFindingCDC {
    class CDCSegment2D;
 
    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 CDCSegment2D> {
 
    private:
      using Super = ChooseableStyling<const 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;
    };
  }
}