environment.hpp

Go to the documentation of this file.

/*
 * Copyright 2020 Robert Bosch GmbH
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 * SPDX-License-Identifier: Apache-2.0
 */
#pragma once
 
#include <cassert>   // for assert
#include <map>       // for map<>
#include <optional>  // for optional<>
#include <string>    // for string
#include <utility>   // for pair<>, move, make_pair
 
namespace fable {
 
class Environment {
 public:
  ~Environment() = default;
  Environment() = default;
  Environment(const Environment&) = default;
  Environment(Environment&&) = default;
  Environment& operator=(const Environment&) = default;
  Environment& operator=(Environment&&) = default;
 
  Environment(std::initializer_list<std::pair<std::string const, std::string>> init)
      : defines_(init) {}
  Environment(const std::map<std::string, std::string>& defines) : defines_(defines) {}
  Environment(std::map<std::string, std::string>&& defines) : defines_(std::move(defines)) {}
 
  [[nodiscard]] bool prefer_external() const { return prefer_external_; }
  void prefer_external(bool value) { prefer_external_ = value; }
 
  [[nodiscard]] bool allow_undefined() const { return allow_undefined_; }
  void allow_undefined(bool value) { allow_undefined_ = value; }
 
  void insert(const std::string& key, const std::string& value) {
    assert(defines_.count(key) == 0);
    defines_.insert(std::make_pair(key, value));
  }
 
  void set(const std::string& key, const std::string& value) { defines_[key] = value; }
 
  [[nodiscard]] std::optional<std::string> get(const std::string& key) const {
    return get(key, prefer_external_);
  }
  [[nodiscard]] std::optional<std::string> get(const std::string& key, bool prefer_external) const;
 
  [[nodiscard]] std::string get_or(const std::string& key, const std::string& alternative) const {
    return get(key).value_or(alternative);
  }
  [[nodiscard]] std::string get_or(const std::string& key, const std::string& alternative,
                                   bool prefer_external) const {
    return get(key, prefer_external).value_or(alternative);
  }
 
  [[nodiscard]] std::string require(const std::string& key) const {
    return require(key, prefer_external_);
  }
  [[nodiscard]] std::string require(const std::string& key, bool prefer_external) const;
 
  [[nodiscard]] std::string evaluate(const std::string& s) const {
    return evaluate(s, prefer_external_, allow_undefined_);
  }
  [[nodiscard]] std::string evaluate(const std::string& s, bool prefer_external,
                                     bool allow_undefined) const;
 
  [[nodiscard]] std::string interpolate(const std::string& s) const {
    return interpolate(s, prefer_external_, allow_undefined_);
  }
  [[nodiscard]] std::string interpolate(const std::string& s, bool prefer_external,
                                        bool allow_undefined) const;
 
 private:
  bool prefer_external_{true};
  bool allow_undefined_{false};
  std::map<std::string, std::string> defines_;
};
 
inline std::string interpolate_vars(const std::string& s, const Environment* env = nullptr) {
  if (env != nullptr) {
    return env->interpolate(s);
  }
  return Environment().interpolate(s);
}
 
}  // namespace fable