hyprlang/include/hyprlang.hpp

461 lines
13 KiB
C++
Raw Normal View History

#pragma once
#ifndef HYPRLANG_HPP
#define HYPRLANG_HPP
#include <any>
#include <memory>
#include <string>
#include <fstream>
2024-02-17 20:01:35 +01:00
#include <vector>
class CConfigImpl;
2023-12-29 19:35:23 +01:00
struct SConfigDefaultValue;
struct SSpecialCategory;
#define HYPRLANG_END_MAGIC 0x1337BEEF
namespace Hyprlang {
2023-12-31 14:20:50 +01:00
struct SVector2D;
class CConfigCustomValueType;
/* Variable typedefs */
/*!
Basic integer config type
*/
typedef int64_t INT;
/*!
Basic float config type
*/
typedef float FLOAT;
/*!
Basic string config type
*/
typedef const char* STRING;
/*!
Basic vec2 config type
*/
typedef SVector2D VEC2;
/*!
Custom config type
*/
typedef CConfigCustomValueType CUSTOMTYPE;
2023-12-30 14:31:48 +01:00
/*!
A very simple vector type
*/
struct SVector2D {
float x = 0, y = 0;
//
bool operator==(const SVector2D& rhs) const {
return x == rhs.x && y == rhs.y;
}
friend std::ostream& operator<<(std::ostream& os, const SVector2D& rhs) {
return os << "[" << rhs.x << ", " << rhs.y << "]";
}
};
class CParseResult {
public:
bool error = false;
2023-12-30 14:31:48 +01:00
/*!
Get this ParseResult's error string.
Pointer valid until the error string is changed or this
object gets destroyed.
*/
const char* getError() const {
return errorString;
}
2023-12-30 14:31:48 +01:00
/*!
Set an error contained by this ParseResult.
Creates a copy of the string, does not take ownership.
*/
void setError(const char* err);
private:
void setError(const std::string& err);
std::string errorStdString = "";
const char* errorString = nullptr;
friend class CConfig;
};
2023-12-30 14:31:48 +01:00
/*!
Generic struct for options for the config parser
*/
2023-12-30 13:30:46 +01:00
struct SConfigOptions {
2023-12-30 14:31:48 +01:00
/*!
Don't throw errors on missing values.
*/
int verifyOnly = false;
2023-12-30 13:30:46 +01:00
2023-12-30 14:31:48 +01:00
/*!
Return all errors instead of just the first
*/
int throwAllErrors = false;
2023-12-31 01:59:37 +01:00
/*!
2023-12-31 14:15:03 +01:00
\since 0.2.0
2023-12-31 14:28:36 +01:00
2023-12-31 01:59:37 +01:00
Don't throw on a missing config file. Carry on as if nothing happened.
*/
int allowMissingConfig = false;
/*!
\since 0.4.2
Treat configPath as a raw config stream.
*/
int pathIsStream = false;
// INTERNAL: DO NOT MODIFY
int __internal_struct_end = HYPRLANG_END_MAGIC;
2023-12-30 13:30:46 +01:00
};
2023-12-30 14:31:48 +01:00
/*!
Generic struct for options for handlers
*/
struct SHandlerOptions {
/*!
Allow flags for this handler
*/
bool allowFlags = false;
// INTERNAL: DO NOT MODIFY
int __internal_struct_end = HYPRLANG_END_MAGIC;
};
2023-12-30 14:31:48 +01:00
/*!
Generic struct for options for special categories
*/
struct SSpecialCategoryOptions {
2023-12-30 14:31:48 +01:00
/*!
a key is the name of a value that will be the identifier of a special category
can be left null for no key, aka a generic one
keys are always strings. Default key value is "0"
*/
const char* key = nullptr;
2023-12-30 14:31:48 +01:00
/*!
don't pop up an error if the config value is missing
*/
int ignoreMissing = false;
2024-02-17 23:38:10 +01:00
/*!
Make this category an anonymous special one.
key has to be nullptr.
Anonymous special categories behave like key-based ones, but the keys
will be automatically assigned without user input.
\since 0.4.0
*/
int anonymousKeyBased = false;
// INTERNAL: DO NOT MODIFY
int __internal_struct_end = HYPRLANG_END_MAGIC;
};
2023-12-30 14:31:48 +01:00
/*!
typedefs
*/
typedef CParseResult (*PCONFIGHANDLERFUNC)(const char* COMMAND, const char* VALUE);
2023-12-29 19:35:23 +01:00
typedef CParseResult (*PCONFIGCUSTOMVALUEHANDLERFUNC)(const char* VALUE, void** data);
typedef void (*PCONFIGCUSTOMVALUEDESTRUCTOR)(void** data);
2023-12-30 14:31:48 +01:00
/*!
Container for a custom config value type
When creating, pass your handler.
Handler will receive a void** that points to a void* that you can set to your own
thing. Pass a dtor to free whatever you allocated when the custom value type is being released.
data may always be pointing to a nullptr.
2023-12-29 19:35:23 +01:00
*/
class CConfigCustomValueType {
public:
CConfigCustomValueType(PCONFIGCUSTOMVALUEHANDLERFUNC handler_, PCONFIGCUSTOMVALUEDESTRUCTOR dtor_, const char* defaultValue);
~CConfigCustomValueType();
/*!
\since 0.3.0
get the data pointer for the custom value type.
*/
void* getData() {
return data;
}
2023-12-29 19:35:23 +01:00
private:
PCONFIGCUSTOMVALUEHANDLERFUNC handler = nullptr;
PCONFIGCUSTOMVALUEDESTRUCTOR dtor = nullptr;
void* data = nullptr;
std::string defaultVal = "";
std::string lastVal = "";
2023-12-29 19:35:23 +01:00
friend class CConfigValue;
friend class CConfig;
};
2023-12-30 14:31:48 +01:00
/*!
Container for a config value
*/
class CConfigValue {
public:
CConfigValue();
2023-12-31 14:20:50 +01:00
CConfigValue(const INT value);
CConfigValue(const FLOAT value);
CConfigValue(const STRING value);
CConfigValue(const VEC2 value);
CConfigValue(CUSTOMTYPE&& value);
2023-12-29 19:35:23 +01:00
CConfigValue(CConfigValue&&) = delete;
CConfigValue(const CConfigValue&&) = delete;
CConfigValue(CConfigValue&) = delete;
/*!
\since 0.3.0
*/
CConfigValue(const CConfigValue&);
~CConfigValue();
2023-12-30 14:31:48 +01:00
/*!
2023-12-31 14:15:03 +01:00
Return a pointer to the data. Prefer getDataStaticPtr()
2023-12-30 14:31:48 +01:00
*/
void* dataPtr() const;
2023-12-31 14:15:03 +01:00
/*!
\since 0.2.0
2023-12-31 14:28:36 +01:00
2023-12-31 14:15:03 +01:00
Return a static pointer to the m_pData.
As long as this configValue is alive, this pointer is valid.
CConfigValues are alive as long as the owning CConfig is alive.
2024-02-15 03:27:27 +01:00
Please note only the first (outer) pointer is static. The second
may (and most likely will) be changing.
For all types except STRING typeof(**retval) is the config value type
(e.g. INT or FLOAT)
Please note STRING is a special type and instead of
typeof(**retval) being const char*, typeof(\*retval) is a const char*.
2023-12-31 14:15:03 +01:00
*/
void* const* getDataStaticPtr() const;
2023-12-30 14:31:48 +01:00
/*!
Get the contained value as an std::any.
For strings, this is a const char*.
For custom data types, this is a CConfigCustomValueType*.
*/
std::any getValue() const {
switch (m_eType) {
case CONFIGDATATYPE_EMPTY: throw;
2023-12-31 14:20:50 +01:00
case CONFIGDATATYPE_INT: return std::any(*reinterpret_cast<INT*>(m_pData));
case CONFIGDATATYPE_FLOAT: return std::any(*reinterpret_cast<FLOAT*>(m_pData));
case CONFIGDATATYPE_STR: return std::any(reinterpret_cast<STRING>(m_pData));
case CONFIGDATATYPE_VEC2: return std::any(*reinterpret_cast<VEC2*>(m_pData));
case CONFIGDATATYPE_CUSTOM: return std::any(reinterpret_cast<CUSTOMTYPE*>(m_pData)->data);
default: throw;
}
return {}; // unreachable
}
/*!
\since 0.3.0
a flag to notify whether this value has been set explicitly by the user,
or not.
*/
bool m_bSetByUser = false;
private:
2023-12-29 19:35:23 +01:00
// remember to also edit config.hpp if editing
enum eDataType {
CONFIGDATATYPE_EMPTY,
CONFIGDATATYPE_INT,
CONFIGDATATYPE_FLOAT,
CONFIGDATATYPE_STR,
CONFIGDATATYPE_VEC2,
2023-12-29 19:35:23 +01:00
CONFIGDATATYPE_CUSTOM,
};
eDataType m_eType = eDataType::CONFIGDATATYPE_EMPTY;
void* m_pData = nullptr;
2023-12-29 19:35:23 +01:00
void defaultFrom(SConfigDefaultValue& ref);
void setFrom(std::any ref);
void setFrom(const CConfigValue* const ref);
friend class CConfig;
};
2023-12-30 14:31:48 +01:00
/*!
Base class for a config file
*/
class CConfig {
public:
2023-12-30 13:30:46 +01:00
CConfig(const char* configPath, const SConfigOptions& options);
~CConfig();
2023-12-30 14:31:48 +01:00
/*!
Add a config value, for example myCategory:myValue.
This has to be done before commence()
Value provided becomes default.
*/
2023-12-29 19:35:23 +01:00
void addConfigValue(const char* name, const CConfigValue& value);
2023-12-30 14:31:48 +01:00
/*!
Register a handler. Can be called anytime, though not recommended
to do this dynamically .
*/
void registerHandler(PCONFIGHANDLERFUNC func, const char* name, SHandlerOptions options);
/*!
\since 0.3.0
Unregister a handler.
*/
void unregisterHandler(const char* name);
2023-12-30 14:31:48 +01:00
/*!
Commence the config state. Config becomes immutable, as in
no new values may be added or removed. Required for parsing.
*/
void commence();
2023-12-30 14:31:48 +01:00
/*!
Add a special category. Can be done dynamically.
*/
void addSpecialCategory(const char* name, SSpecialCategoryOptions options);
/*!
\since 0.3.0
Remove a special category. Can be done dynamically.
*/
void removeSpecialCategory(const char* name);
2023-12-30 14:31:48 +01:00
/*!
\since 0.3.2
2023-12-30 14:31:48 +01:00
Add a config value to a special category.
\note Before 0.3.2, this takes a `const CConfigValue` (non-ref)
2023-12-30 14:31:48 +01:00
*/
void addSpecialConfigValue(const char* cat, const char* name, const CConfigValue& value);
/*!
Remove a config value from a special category.
*/
void removeSpecialConfigValue(const char* cat, const char* name);
2023-12-30 14:31:48 +01:00
/*!
Parse the config. Refresh the values.
*/
CParseResult parse();
2023-12-30 14:31:48 +01:00
/*!
Same as parse(), but parse a specific file, without any refreshing.
recommended to use for stuff like source = path.conf
*/
2024-02-09 04:28:07 +01:00
CParseResult parseFile(const char* file);
2023-12-30 14:31:48 +01:00
/*!
Parse a single "line", dynamically.
Values set by this are temporary and will be overwritten
by default / config on the next parse()
*/
CParseResult parseDynamic(const char* line);
CParseResult parseDynamic(const char* command, const char* value);
2023-12-30 14:31:48 +01:00
/*!
Get a config's value ptr. These are static.
nullptr on fail
*/
CConfigValue* getConfigValuePtr(const char* name);
2023-12-30 14:31:48 +01:00
/*!
Get a special category's config value ptr. These are only static for static (key-less)
2024-02-15 03:34:04 +01:00
categories.
key can be nullptr for static categories. Cannot be nullptr for id-based categories.
2023-12-30 14:31:48 +01:00
nullptr on fail.
*/
CConfigValue* getSpecialConfigValuePtr(const char* category, const char* name, const char* key = nullptr);
2023-12-30 14:31:48 +01:00
/*!
Get a config value's stored value. Empty on fail
*/
std::any getConfigValue(const char* name) {
CConfigValue* val = getConfigValuePtr(name);
if (!val)
return {};
return val->getValue();
}
2023-12-30 14:31:48 +01:00
/*!
Get a special config value's stored value. Empty on fail.
*/
std::any getSpecialConfigValue(const char* category, const char* name, const char* key = nullptr) {
CConfigValue* val = getSpecialConfigValuePtr(category, name, key);
if (!val)
return {};
return val->getValue();
}
/*!
Check whether a special category with the provided key value exists
\since 0.3.0
*/
bool specialCategoryExistsForKey(const char* category, const char* key);
2024-02-17 20:01:35 +01:00
/*!
Get a vector with all registered keys for a special category
It's an error to query this for a static or non-existent category
\since 0.4.0
*/
std::vector<std::string> listKeysForSpecialCategory(const char* category) {
const char** cats = nullptr;
size_t len = 0;
retrieveKeysForCat(category, &cats, &len);
if (len == 0)
return {};
std::vector<std::string> result;
for (size_t i = 0; i < len; ++i) {
result.push_back(cats[i]);
}
free(cats);
return result;
}
private:
bool m_bCommenced = false;
CConfigImpl* impl;
CParseResult parseLine(std::string line, bool dynamic = false);
CParseResult configSetValueSafe(const std::string& command, const std::string& value);
CParseResult parseVariable(const std::string& lhs, const std::string& rhs, bool dynamic = false);
void clearState();
2023-12-29 19:35:23 +01:00
void applyDefaultsToCat(SSpecialCategory& cat);
2024-02-17 20:01:35 +01:00
void retrieveKeysForCat(const char* category, const char*** out, size_t* len);
CParseResult parseRawStream(const std::string& stream);
};
};
#ifndef HYPRLANG_INTERNAL
#undef HYPRLANG_END_MAGIC
#endif
#endif