build/tools/aconfig/templates/cpp_source_file.template

#include "{header}.h"
{{ if readwrite }}
#include <server_configurable_flags/get_flags.h>
{{ endif }}
{{ if for_test }}
#include <unordered_map>
#include <string>
{{ endif }}

namespace {cpp_namespace} \{

{{ if for_test }}
    class flag_provider : public flag_provider_interface \{
    private:
        std::unordered_map<std::string, bool> overrides_;

    public:
        flag_provider()
            : overrides_()
        \{}

        {{ for item in class_elements}}
        virtual bool {item.flag_name}() override \{
            auto it = overrides_.find("{item.flag_name}");
              if (it != overrides_.end()) \{
                  return it->second;
            } else \{
              {{ if item.readwrite- }}
              return server_configurable_flags::GetServerConfigurableFlag(
                  "aconfig_flags.{item.device_config_namespace}",
                  "{item.device_config_flag}",
                  "{item.default_value}") == "true";
              {{ -else- }}
                  return {item.default_value};
              {{ -endif }}
            }
        }

        virtual void {item.flag_name}(bool val) override \{
            overrides_["{item.flag_name}"] = val;
        }
        {{ endfor }}

        virtual void reset_flags() override \{
            overrides_.clear();
        }
    };

{{ -else- }}

    class flag_provider : public flag_provider_interface \{
    public:
        {{ for item in class_elements}}
        virtual bool {item.flag_name}() override \{
            {{ if item.readwrite- }}
            if (cache_[{item.readwrite_idx}] == -1) \{
                cache_[{item.readwrite_idx}] = server_configurable_flags::GetServerConfigurableFlag(
                    "aconfig_flags.{item.device_config_namespace}",
                    "{item.device_config_flag}",
                    "{item.default_value}") == "true";
            }
            return cache_[{item.readwrite_idx}];
            {{ -else- }}
            {{ if item.is_fixed_read_only }}
            return {package_macro}_{item.flag_macro};
            {{ -else- }}
            return {item.default_value};
            {{ -endif }}
            {{ -endif }}
        }
        {{ endfor }}
    };

    std::vector<int8_t> cache_ = std::vector<int8_t>({readwrite_count}, -1);

{{ -endif }}

std::unique_ptr<flag_provider_interface> provider_ =
    std::make_unique<flag_provider>();


}


{{ for item in class_elements}}
bool {header}_{item.flag_name}() \{
    {{ if for_test }}
    return {cpp_namespace}::{item.flag_name}();
    {{ -else- }}
    {{ if item.readwrite- }}
    return {cpp_namespace}::{item.flag_name}();
    {{ -else- }}
    {{ if item.is_fixed_read_only }}
    return {package_macro}_{item.flag_macro};
    {{ -else- }}
    return {item.default_value};
    {{ -endif }}
    {{ -endif }}
    {{ -endif }}
}

{{ if for_test }}
void set_{header}_{item.flag_name}(bool val) \{
    {cpp_namespace}::{item.flag_name}(val);
}
{{ -endif }}
{{ endfor -}}

{{ if for_test }}
void {header}_reset_flags() \{
     {cpp_namespace}::reset_flags();
}
{{ -endif }}