1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
|
/*
* key.hh - Definition of the base Key classes
* libhscript, the HorizonScript library for
* Project Horizon
*
* Copyright (c) 2019 Adélie Linux and contributors. All rights reserved.
* This code is licensed under the AGPL 3.0 license, as noted in the
* LICENSE-code file in the root directory of this repository.
*
* SPDX-License-Identifier: AGPL-3.0-only
*/
#ifndef __HSCRIPT_KEY_HH_
#define __HSCRIPT_KEY_HH_
#include <string>
#include "script.hh"
namespace Horizon {
namespace Keys {
/*! Base Key class, used by all Keys.
* A Getter method is not provided in this base Key class, because each Key may
* return a different type of data. For example, `network` may return `bool`.
*/
class Key {
protected:
/*! The line number where this Key appeared. */
int line;
Key(int _line) : line(_line) {}
public:
virtual ~Key();
/*! Create the Key object with the specified data as the entire value.
* @param data The value associated with the key.
* @param lineno The line number where the key occurs.
* @param errors Output variable: if not nullptr, ++ on each error.
* @param warnings Output variable: if not nullptr, ++ on each warning.
* @returns nullptr if data is unparsable, otherwise a pointer to a Key.
*/
#define UNUSED __attribute__((unused))
static Key *parseFromData(const std::string data UNUSED, int lineno UNUSED,
int *errors UNUSED, int *warnings UNUSED) {
return nullptr;
}
#undef UNUSED
/*! Determines if the data associated with the Key is valid. */
virtual bool validate(ScriptOptions) const = 0;
/*! Executes the action associated with this Key.
* @note Will always return `false` if `validate` is `false`.
*/
virtual bool execute(ScriptOptions) const = 0;
int lineno() const { return this->line; }
};
/*! Base Key class that parses and handles Boolean values.
* All values passed in are lowercased. Delimiters are not allowed.
* Truthy values: "true" "yes" "1"
* Falsy values: "false" "no" "0"
* Any other values will be considered invalid.
*/
class BooleanKey : public Key {
protected:
const bool value;
BooleanKey(int _line, bool my_value) : Key(_line), value(my_value) {}
/*! Parse a string into a boolean.
* @param what The string to attempt parsing.
* @param where The location of the key.
* @param key The name of the key.
* @param out Output variable: will contain the value.
* @returns true if value is parsed successfully, false otherwise.
*/
static bool parse(const std::string what, const std::string where,
const std::string key, bool *out);
public:
/*! Determines if the Key is set or not.
* @returns true if the Key is truthy, false otherwise.
*/
bool test() const { return this->value; }
/*! Key will fail to init if valid is invalid. */
bool validate(ScriptOptions) const override;
};
/*! Base Key class that parses and handles single string values. */
class StringKey : public Key {
protected:
const std::string _value;
StringKey(int _line, std::string my_str) : Key(_line), _value(my_str) {}
public:
/*! Retrieve the value of this key. */
const std::string value() const { return this->_value; }
/*! By default, key will be considered valid since it parsed.
* This method should be overridden when further consideration is needed.
*/
bool validate(ScriptOptions) const override;
};
}
}
#endif
|
