Options.hpp

Go to the documentation of this file. Or view the newest version in sPHENIX GitHub for file Options.hpp

// This file is part of the Acts project.
//
// Copyright (C) 2017-2020 CERN for the benefit of the Acts project
//
// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at http://mozilla.org/MPL/2.0/.

#pragma once

#include <array>
#include <cstddef>
#include <iosfwd>
#include <optional>
#include <vector>

namespace ActsExamples {
namespace Options {


struct Interval {
  std::optional<double> lower;
  std::optional<double> upper;
};

template <size_t kSize>
class Reals : public std::array<double, kSize> {};

struct VariableReals {
  std::vector<double> values;
};

template <size_t kSize>
class Integers : public std::array<int, kSize> {};

struct VariableIntegers {
  std::vector<int> values;
};


std::istream& operator>>(std::istream& is, Interval& interval);

std::ostream& operator<<(std::ostream& os, const Interval& interval);

namespace detail {
void parseDoublesFixed(std::istream& is, size_t size, double* values);
void parseDoublesVariable(std::istream& is, std::vector<double>& values);
void printDoubles(std::ostream& os, size_t size, const double* values);
}  // namespace detail

template <size_t kSize>
inline std::istream& operator>>(std::istream& is, Reals<kSize>& values) {
  detail::parseDoublesFixed(is, kSize, values.data());
  return is;
}

inline std::istream& operator>>(std::istream& is, VariableReals& values) {
  detail::parseDoublesVariable(is, values.values);
  return is;
}

template <size_t kSize>
inline std::ostream& operator<<(std::ostream& os, const Reals<kSize>& values) {
  detail::printDoubles(os, kSize, values.data());
  return os;
}

inline std::ostream& operator<<(std::ostream& os, const VariableReals& values) {
  detail::printDoubles(os, values.values.size(), values.values.data());
  return os;
}

namespace detail {
void parseIntegersFixed(std::istream& is, size_t size, int* values);
void parseIntegersVariable(std::istream& is, std::vector<int>& values);
void printIntegers(std::ostream& os, size_t size, const int* values);
}  // namespace detail

template <size_t kSize>
inline std::istream& operator>>(std::istream& is, Integers<kSize>& values) {
  detail::parseIntegersFixed(is, kSize, values.data());
  return is;
}

inline std::istream& operator>>(std::istream& is, VariableIntegers& values) {
  detail::parseIntegersVariable(is, values.values);
  return is;
}

template <size_t kSize>
inline std::ostream& operator<<(std::ostream& os,
                                const Integers<kSize>& values) {
  detail::printIntegers(os, kSize, values.data());
  return os;
}

inline std::ostream& operator<<(std::ostream& os,
                                const VariableIntegers& values) {
  detail::printIntegers(os, values.values.size(), values.values.data());
  return os;
}

}  // namespace Options
}  // namespace ActsExamples