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
#ifndef FABLE_ENVIRONMENT_HPP_
#define FABLE_ENVIRONMENT_HPP_

#include <cassert>  // for assert
#include <map>      // for map<>
#include <string>   // for string
#include <utility>  // for pair<>, move, make_pair

#include <boost/optional.hpp>  // for optional<>

namespace fable {

class Environment {
 public:
  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)) {}
  ~Environment() = default;

  bool prefer_external() const { return prefer_external_; }
  void prefer_external(bool value) { prefer_external_ = value; }

  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; }

  boost::optional<std::string> get(const std::string& key) const {
    return get(key, prefer_external_);
  }
  boost::optional<std::string> get(const std::string& key, bool prefer_external) const;

  std::string get_or(const std::string& key, const std::string& alternative) const {
    return get(key).value_or(alternative);
  }
  std::string get_or(const std::string& key, const std::string& alternative,
                     bool prefer_external) const {
    return get(key, prefer_external).value_or(alternative);
  }

  std::string require(const std::string& key) const { return require(key, prefer_external_); }
  std::string require(const std::string& key, bool prefer_external) const;

  std::string evaluate(const std::string& s) const {
    return evaluate(s, prefer_external_, allow_undefined_);
  }
  std::string evaluate(const std::string& s, bool prefer_external, bool allow_undefined) const;

  std::string interpolate(const std::string& s) const {
    return interpolate(s, prefer_external_, allow_undefined_);
  }
  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);
  } else {
    return Environment().interpolate(s);
  }
}

}  // namespace fable

#endif  // FABLE_ENVIRONMENT_HPP_