• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1//! codegenerated rust flag lib
2use aconfig_storage_read_api::\{Mmap, AconfigStorageError, StorageFileType, PackageReadContext, get_mapped_storage_file, get_boolean_flag_value, get_package_read_context};
3use std::collections::BTreeMap;
4use std::path::Path;
5use std::io::Write;
6use std::sync::\{LazyLock, Mutex};
7use log::\{log, LevelFilter, Level};
8
9/// flag provider
10pub struct FlagProvider \{
11    overrides: BTreeMap<&'static str, bool>,
12}
13
14{{ if has_readwrite- }}
15static PACKAGE_OFFSET: LazyLock<Result<Option<u32>, AconfigStorageError>> = LazyLock::new(|| unsafe \{
16    get_mapped_storage_file("{container}", StorageFileType::PackageMap)
17    .and_then(|package_map| get_package_read_context(&package_map, "{package}"))
18    .map(|context| context.map(|c| c.boolean_start_index))
19});
20
21static FLAG_VAL_MAP: LazyLock<Result<Mmap, AconfigStorageError>> = LazyLock::new(|| unsafe \{
22    get_mapped_storage_file("{container}", StorageFileType::FlagVal)
23});
24
25{{ -for flag in template_flags }}
26{{ -if flag.readwrite }}
27/// flag value cache for {flag.name}
28static CACHED_{flag.name}: LazyLock<bool> = LazyLock::new(|| \{
29
30    // This will be called multiple times. Subsequent calls after the first are noops.
31    logger::init(
32        logger::Config::default()
33            .with_tag_on_device("aconfig_rust_codegen")
34            .with_max_level(LevelFilter::Info));
35
36    let flag_value_result = FLAG_VAL_MAP
37        .as_ref()
38        .map_err(|err| format!("failed to get flag val map: \{err}"))
39        .and_then(|flag_val_map| \{
40            PACKAGE_OFFSET
41                .as_ref()
42                .map_err(|err| format!("failed to get package read offset: \{err}"))
43                .and_then(|package_offset| \{
44                    match package_offset \{
45                        Some(offset) => \{
46                            get_boolean_flag_value(&flag_val_map, offset + {flag.flag_offset})
47                                .map_err(|err| format!("failed to get flag: \{err}"))
48                        },
49                        None => \{
50                            log!(Level::Error, "no context found for package {package}");
51                            Err(format!("failed to flag package {package}"))
52                        }
53                    }
54                })
55            });
56
57    match flag_value_result \{
58        Ok(flag_value) => \{
59            return flag_value;
60        },
61        Err(err) => \{
62            log!(Level::Error, "aconfig_rust_codegen: error: \{err}");
63            return {flag.default_value};
64        }
65    }
66
67});
68{{ -endif }}
69{{ -endfor }}
70{{ -endif }}
71
72impl FlagProvider \{
73{{ for flag in template_flags }}
74    /// query flag {flag.name}
75    pub fn {flag.name}(&self) -> bool \{
76        self.overrides.get("{flag.name}").copied().unwrap_or(
77        {{ if flag.readwrite -}}
78           *CACHED_{flag.name}
79        {{ -else- }}
80           {flag.default_value}
81        {{ -endif }}
82        )
83    }
84
85    /// set flag {flag.name}
86    pub fn set_{flag.name}(&mut self, val: bool) \{
87        self.overrides.insert("{flag.name}", val);
88    }
89{{ endfor }}
90
91    /// clear all flag overrides
92    pub fn reset_flags(&mut self) \{
93        self.overrides.clear();
94    }
95}
96
97/// flag provider
98pub static PROVIDER: Mutex<FlagProvider> = Mutex::new(
99    FlagProvider \{overrides: BTreeMap::new()}
100);
101
102{{ for flag in template_flags }}
103/// query flag {flag.name}
104#[inline(always)]
105pub fn {flag.name}() -> bool \{
106    PROVIDER.lock().unwrap().{flag.name}()
107}
108
109/// set flag {flag.name}
110#[inline(always)]
111pub fn set_{flag.name}(val: bool) \{
112    PROVIDER.lock().unwrap().set_{flag.name}(val);
113}
114{{ endfor }}
115
116/// clear all flag override
117pub fn reset_flags() \{
118    PROVIDER.lock().unwrap().reset_flags()
119}
120