DataSpecUtils.h

Go to the documentation of this file.

// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
// All rights not expressly granted are reserved.
//
// This software is distributed under the terms of the GNU General Public
// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
//
// In applying this license CERN does not waive the privileges and immunities
// granted to it by virtue of its status as an Intergovernmental Organization
// or submit itself to any jurisdiction.
#ifndef FRAMEWORK_DATASPECUTILS_H
#define FRAMEWORK_DATASPECUTILS_H
 
#include "Framework/OutputSpec.h"
#include "Framework/InputSpec.h"
#include "Headers/DataHeader.h"
#include "Framework/Output.h"
 
#include <optional>
 
namespace o2::framework
{
 
template <typename T>
concept HasMatcher = requires(T& t) { t.matcher; };
 
struct DataSpecUtils {
  static bool match(InputSpec const& spec, ConcreteDataMatcher const& target);
 
  static bool match(InputSpec const& spec, ConcreteDataTypeMatcher const& target);
 
  static bool match(OutputSpec const& left, OutputSpec const& right);
 
  static bool match(OutputSpec const& spec, ConcreteDataMatcher const& target);
 
  static bool match(InputSpec const& input, OutputSpec const& output);
 
  static bool match(const InputSpec& spec,
                    const o2::header::DataOrigin& origin,
                    const o2::header::DataDescription& description,
                    const o2::header::DataHeader::SubSpecificationType& subSpec);
 
  static bool match(const OutputSpec& spec,
                    const o2::header::DataOrigin& origin,
                    const o2::header::DataDescription& description,
                    const o2::header::DataHeader::SubSpecificationType& subSpec);
 
  static bool match(const InputSpec& spec, o2::header::DataHeader const& dh)
  {
    return DataSpecUtils::match(spec, dh.dataOrigin, dh.dataDescription, dh.subSpecification);
  }
 
  static bool match(const OutputSpec& spec, o2::header::DataHeader const& dh)
  {
    return DataSpecUtils::match(spec, dh.dataOrigin, dh.dataDescription, dh.subSpecification);
  }
 
  template <typename ContainerT>
  static std::optional<typename ContainerT::value_type> find(ContainerT const& container,
                                                             const o2::header::DataOrigin& origin,
                                                             const o2::header::DataDescription& description,
                                                             const o2::header::DataHeader::SubSpecificationType& subSpec)
  {
    for (auto const& spec : container) {
      if (match(spec, origin, description, subSpec)) {
        return std::make_optional<typename ContainerT::value_type>(spec);
      }
    }
    return std::nullopt;
  }
 
  static bool partialMatch(InputSpec const& spec, o2::header::DataOrigin const& origin);
 
  template <size_t N>
  static bool partialMatch(InputSpec const& spec, std::array<header::DataOrigin, N> const& origins)
  {
    return std::find_if(origins.begin(), origins.end(), [&](auto const& o) { return DataSpecUtils::asConcreteOrigin(spec) == o; }) != origins.end();
  }
 
  static bool partialMatch(OutputSpec const& spec, o2::header::DataOrigin const& origin);
 
  template <size_t N>
  static bool partialMatch(OutputSpec const& spec, std::array<header::DataOrigin, N> const& origins)
  {
    auto dataType = DataSpecUtils::asConcreteDataTypeMatcher(spec);
    return std::find_if(origins.begin(), origins.end(), [&](auto const& o) { return dataType.origin == o; }) != origins.end();
  }
 
  static bool partialMatch(InputSpec const& spec, o2::header::DataDescription const& description);
 
  static bool partialMatch(OutputSpec const& spec, o2::header::DataDescription const& description);
 
  template <typename T>
  static bool match(const T& spec, const o2::header::DataHeader& header)
  {
    return DataSpecUtils::match(spec,
                                header.dataOrigin,
                                header.dataDescription,
                                header.subSpecification);
  }
 
  static std::string describe(InputSpec const& spec);
 
  static std::string describe(OutputSpec const& spec);
 
  static std::string describe(ConcreteDataMatcher const& matcher);
 
  static std::string label(InputSpec const& spec);
 
  static std::string label(OutputSpec const& spec);
 
  static std::string restEndpoint(InputSpec const& spec);
 
  static void updateMatchingSubspec(InputSpec& in, header::DataHeader::SubSpecificationType subSpec);
  static void updateMatchingSubspec(OutputSpec& in, header::DataHeader::SubSpecificationType subSpec);
 
  static bool validate(InputSpec const& input);
 
  static bool validate(OutputSpec const& output);
 
  template <HasMatcher T>
  static size_t describe(char* buffer, size_t size, T const& spec);
 
  static ConcreteDataMatcher asConcreteDataMatcher(InputSpec const& input);
 
  static ConcreteDataMatcher asConcreteDataMatcher(OutputSpec const& spec);
 
  static std::optional<ConcreteDataMatcher> asOptionalConcreteDataMatcher(OutputSpec const& spec);
 
  static ConcreteDataTypeMatcher asConcreteDataTypeMatcher(OutputSpec const& spec);
 
  static ConcreteDataTypeMatcher asConcreteDataTypeMatcher(InputSpec const& spec);
 
  static header::DataOrigin asConcreteOrigin(InputSpec const& spec);
 
  static header::DataDescription asConcreteDataDescription(InputSpec const& spec);
 
  static OutputSpec asOutputSpec(InputSpec const& spec);
 
  static InputSpec matchingInput(OutputSpec const& spec);
 
  static InputSpec fromMetadataString(std::string s);
 
  static ConcreteDataMatcher fromString(std::string s);
 
  static std::optional<header::DataOrigin> getOptionalOrigin(InputSpec const& spec);
 
  static std::optional<header::DataDescription> getOptionalDescription(InputSpec const& spec);
 
  static std::optional<header::DataHeader::SubSpecificationType> getOptionalSubSpec(OutputSpec const& spec);
 
  static std::optional<header::DataHeader::SubSpecificationType> getOptionalSubSpec(InputSpec const& spec);
 
  static data_matcher::DataDescriptorMatcher dataDescriptorMatcherFrom(ConcreteDataMatcher const& concrete);
 
  static data_matcher::DataDescriptorMatcher dataDescriptorMatcherFrom(ConcreteDataTypeMatcher const& dataType);
 
  static data_matcher::DataDescriptorMatcher dataDescriptorMatcherFrom(header::DataOrigin const& origin);
 
  static data_matcher::DataDescriptorMatcher dataDescriptorMatcherFrom(header::DataDescription const& origin);
 
  static std::optional<framework::ConcreteDataMatcher> optionalConcreteDataMatcherFrom(data_matcher::DataDescriptorMatcher const& matcher);
 
  static bool includes(const InputSpec& left, const InputSpec& right);
 
  static void updateInputList(std::vector<InputSpec>& list, InputSpec&& input);
 
  static void updateOutputList(std::vector<OutputSpec>& list, OutputSpec&& input);
};
 
} // namespace o2::framework
 
#endif // FRAMEWORK_DATASPECUTILS_H