PulseStudio/VoxelEngine
1
1
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 1 Wiki Activity

format: reformat project

Browse Source 
Signed-off-by: Vyacheslav Ivanov <islavaivanov76@gmail.com>
This commit is contained in:
Vyacheslav Ivanov
2024-08-03 19:53:48 +03:00
committed by Pugemon
parent 736cd175d5
commit bbf33e8e4d
202 changed files with 7389 additions and 5609 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/data/dynamic.cpp
+77 -46
View File
@@ -14,7 +14,9 @@ std::ostream& operator<<(std::ostream& stream, const dynamic::Map_sptr& value) {
return stream;
}
std::ostream& operator<<(std::ostream& stream, const dynamic::List_sptr& value) {
std::ostream& operator<<(
std::ostream& stream, const dynamic::List_sptr& value
) {
stream << json::stringify(value, false, " ");
return stream;
}
@@ -22,10 +24,14 @@ std::ostream& operator<<(std::ostream& stream, const dynamic::List_sptr& value)
std::string List::str(size_t index) const {
const auto& value = values[index];
switch (static_cast<Type>(value.index())) {
case Type::string: return std::get<std::string>(value);
case Type::boolean: return std::get<bool>(value) ? "true" : "false";
case Type::number: return std::to_string(std::get<double>(value));
case Type::integer: return std::to_string(std::get<int64_t>(value));
case Type::string:
return std::get<std::string>(value);
case Type::boolean:
return std::get<bool>(value) ? "true" : "false";
case Type::number:
return std::to_string(std::get<double>(value));
case Type::integer:
return std::to_string(std::get<int64_t>(value));
default:
throw std::runtime_error("type error");
}
@@ -34,10 +40,14 @@ std::string List::str(size_t index) const {
number_t List::num(size_t index) const {
const auto& value = values[index];
switch (static_cast<Type>(value.index())) {
case Type::number: return std::get<number_t>(value);
case Type::integer: return std::get<integer_t>(value);
case Type::string: return std::stoll(std::get<std::string>(value));
case Type::boolean: return std::get<bool>(value);
case Type::number:
return std::get<number_t>(value);
case Type::integer:
return std::get<integer_t>(value);
case Type::string:
return std::stoll(std::get<std::string>(value));
case Type::boolean:
return std::get<bool>(value);
default:
throw std::runtime_error("type error");
}
@@ -46,10 +56,14 @@ number_t List::num(size_t index) const {
integer_t List::integer(size_t index) const {
const auto& value = values[index];
switch (static_cast<Type>(value.index())) {
case Type::number: return std::get<number_t>(value);
case Type::integer: return std::get<integer_t>(value);
case Type::string: return std::stoll(std::get<std::string>(value));
case Type::boolean: return std::get<bool>(value);
case Type::number:
return std::get<number_t>(value);
case Type::integer:
return std::get<integer_t>(value);
case Type::string:
return std::stoll(std::get<std::string>(value));
case Type::boolean:
return std::get<bool>(value);
default:
throw std::runtime_error("type error");
}
@@ -74,8 +88,10 @@ List* List::list(size_t index) const {
bool List::flag(size_t index) const {
const auto& value = values[index];
switch (static_cast<Type>(value.index())) {
case Type::integer: return std::get<integer_t>(value);
case Type::boolean: return std::get<bool>(value);
case Type::integer:
return std::get<integer_t>(value);
case Type::boolean:
return std::get<bool>(value);
default:
throw std::runtime_error("type error");
}
@@ -112,55 +128,69 @@ void Map::str(const std::string& key, std::string& dst) const {
std::string Map::get(const std::string& key, const std::string& def) const {
auto found = values.find(key);
if (found == values.end())
return def;
if (found == values.end()) return def;
auto& value = found->second;
switch (static_cast<Type>(value.index())) {
case Type::string: return std::get<std::string>(value);
case Type::boolean: return std::get<bool>(value) ? "true" : "false";
case Type::number: return std::to_string(std::get<number_t>(value));
case Type::integer: return std::to_string(std::get<integer_t>(value));
default: throw std::runtime_error("type error");
case Type::string:
return std::get<std::string>(value);
case Type::boolean:
return std::get<bool>(value) ? "true" : "false";
case Type::number:
return std::to_string(std::get<number_t>(value));
case Type::integer:
return std::to_string(std::get<integer_t>(value));
default:
throw std::runtime_error("type error");
}
}
number_t Map::get(const std::string& key, double def) const {
auto found = values.find(key);
if (found == values.end())
return def;
if (found == values.end()) return def;
auto& value = found->second;
switch (static_cast<Type>(value.index())) {
case Type::number: return std::get<number_t>(value);
case Type::integer: return std::get<integer_t>(value);
case Type::string: return std::stoull(std::get<std::string>(value));
case Type::boolean: return std::get<bool>(value);
default: throw std::runtime_error("type error");
case Type::number:
return std::get<number_t>(value);
case Type::integer:
return std::get<integer_t>(value);
case Type::string:
return std::stoull(std::get<std::string>(value));
case Type::boolean:
return std::get<bool>(value);
default:
throw std::runtime_error("type error");
}
}
integer_t Map::get(const std::string& key, integer_t def) const {
auto found = values.find(key);
if (found == values.end())
return def;
if (found == values.end()) return def;
auto& value = found->second;
switch (static_cast<Type>(value.index())) {
case Type::number: return std::get<number_t>(value);
case Type::integer: return std::get<integer_t>(value);
case Type::string: return std::stoull(std::get<std::string>(value));
case Type::boolean: return std::get<bool>(value);
default: throw std::runtime_error("type error");
case Type::number:
return std::get<number_t>(value);
case Type::integer:
return std::get<integer_t>(value);
case Type::string:
return std::stoull(std::get<std::string>(value));
case Type::boolean:
return std::get<bool>(value);
default:
throw std::runtime_error("type error");
}
}
bool Map::get(const std::string& key, bool def) const {
auto found = values.find(key);
if (found == values.end())
return def;
if (found == values.end()) return def;
auto& value = found->second;
switch (static_cast<Type>(value.index())) {
case Type::integer: return std::get<integer_t>(value);
case Type::boolean: return std::get<bool>(value);
default: throw std::runtime_error("type error");
case Type::integer:
return std::get<integer_t>(value);
case Type::boolean:
return std::get<bool>(value);
default:
throw std::runtime_error("type error");
}
}
@@ -204,8 +234,7 @@ Map_sptr Map::map(const std::string& key) const {
List_sptr Map::list(const std::string& key) const {
auto found = values.find(key);
if (found != values.end())
return std::get<List_sptr>(found->second);
if (found != values.end()) return std::get<List_sptr>(found->second);
return nullptr;
}
@@ -260,7 +289,9 @@ List_sptr dynamic::create_list(std::initializer_list<Value> values) {
return std::make_shared<List>(values);
}
Map_sptr dynamic::create_map(std::initializer_list<std::pair<const std::string, Value>> entries) {
Map_sptr dynamic::create_map(
std::initializer_list<std::pair<const std::string, Value>> entries
) {
return std::make_shared<Map>(entries);
}
@@ -270,12 +301,12 @@ number_t dynamic::get_number(const Value& value) {
} else if (auto num = std::get_if<integer_t>(&value)) {
return *num;
}
throw std::runtime_error("cannot cast "+type_name(value)+" to number");
throw std::runtime_error("cannot cast " + type_name(value) + " to number");
}
integer_t dynamic::get_integer(const Value& value) {
if (auto num = std::get_if<integer_t>(&value)) {
return *num;
}
throw std::runtime_error("cannot cast "+type_name(value)+" to integer");
throw std::runtime_error("cannot cast " + type_name(value) + " to integer");
}
src/data/dynamic.hpp
+17 -17
View File
@@ -1,28 +1,27 @@
#ifndef DATA_DYNAMIC_HPP_
#define DATA_DYNAMIC_HPP_
#include "dynamic_fwd.hpp"
#include <cmath>
#include <string>
#include <vector>
#include <memory>
#include <ostream>
#include <stdexcept>
#include <string>
#include <unordered_map>
#include <vector>
#include "dynamic_fwd.hpp"
namespace dynamic {
enum class Type {
none=0, map, list, string, number, boolean, integer
};
enum class Type { none = 0, map, list, string, number, boolean, integer };
const std::string& type_name(const Value& value);
List_sptr create_list(std::initializer_list<Value> values={});
Map_sptr create_map(std::initializer_list<std::pair<const std::string, Value>> entries={});
List_sptr create_list(std::initializer_list<Value> values = {});
Map_sptr create_map(
std::initializer_list<std::pair<const std::string, Value>> entries = {}
);
number_t get_number(const Value& value);
integer_t get_integer(const Value& value);
inline bool is_numeric(const Value& value) {
return std::holds_alternative<number_t>(value) ||
std::holds_alternative<integer_t>(value);
@@ -42,7 +41,8 @@ namespace dynamic {
std::vector<Value> values;
List() = default;
List(std::vector<Value> values) : values(std::move(values)) {}
List(std::vector<Value> values) : values(std::move(values)) {
}
std::string str(size_t index) const;
number_t num(size_t index) const;
@@ -80,13 +80,13 @@ namespace dynamic {
std::unordered_map<std::string, Value> values;
Map() = default;
Map(std::unordered_map<std::string, Value> values)
: values(std::move(values)) {};
Map(std::unordered_map<std::string, Value> values)
: values(std::move(values)) {};
template<typename T>
template <typename T>
T get(const std::string& key) const {
if (!has(key)) {
throw std::runtime_error("missing key '"+key+"'");
throw std::runtime_error("missing key '" + key + "'");
}
return get(key, T());
}
@@ -164,4 +164,4 @@ std::ostream& operator<<(std::ostream& stream, const dynamic::Value& value);
std::ostream& operator<<(std::ostream& stream, const dynamic::Map_sptr& value);
std::ostream& operator<<(std::ostream& stream, const dynamic::List_sptr& value);
#endif // DATA_DYNAMIC_HPP_
#endif // DATA_DYNAMIC_HPP_
src/data/dynamic_fwd.hpp
+5 -6
View File
@@ -1,12 +1,12 @@
#ifndef DATA_DYNAMIC_FWD_HPP_
#define DATA_DYNAMIC_FWD_HPP_
#include "../typedefs.hpp"
#include <functional>
#include <memory>
#include <string>
#include <variant>
#include <functional>
#include "../typedefs.hpp"
namespace dynamic {
class Map;
@@ -26,10 +26,9 @@ namespace dynamic {
std::string,
number_t,
bool,
integer_t
>;
integer_t>;
using to_string_func = std::function<std::string(const Value&)>;
}
#endif // DATA_DYNAMIC_FWD_HPP_
#endif // DATA_DYNAMIC_FWD_HPP_
src/data/dynamic_util.hpp
+27 -15
View File
@@ -1,12 +1,12 @@
#ifndef DATA_DYNAMIC_UTIL_HPP_
#define DATA_DYNAMIC_UTIL_HPP_
#include "dynamic.hpp"
#include <glm/glm.hpp>
#include "dynamic.hpp"
namespace dynamic {
template<int n>
template <int n>
inline dynamic::List_sptr to_value(glm::vec<n, float> vec) {
auto list = dynamic::create_list();
for (size_t i = 0; i < n; i++) {
@@ -15,7 +15,7 @@ namespace dynamic {
return list;
}
template<int n, int m>
template <int n, int m>
inline dynamic::List_sptr to_value(glm::mat<n, m, float> mat) {
auto list = dynamic::create_list();
for (size_t i = 0; i < n; i++) {
@@ -26,8 +26,12 @@ namespace dynamic {
return list;
}
template<int n>
void get_vec(const dynamic::Map_sptr& root, const std::string& name, glm::vec<n, float>& vec) {
template <int n>
void get_vec(
const dynamic::Map_sptr& root,
const std::string& name,
glm::vec<n, float>& vec
) {
if (const auto& list = root->list(name)) {
for (size_t i = 0; i < n; i++) {
vec[i] = list->num(i);
@@ -35,8 +39,10 @@ namespace dynamic {
}
}
template<int n>
void get_vec(const dynamic::List_sptr& root, size_t index, glm::vec<n, float>& vec) {
template <int n>
void get_vec(
const dynamic::List_sptr& root, size_t index, glm::vec<n, float>& vec
) {
if (const auto& list = root->list(index)) {
for (size_t i = 0; i < n; i++) {
vec[i] = list->num(i);
@@ -44,27 +50,33 @@ namespace dynamic {
}
}
template<int n, int m>
void get_mat(const dynamic::Map_sptr& root, const std::string& name, glm::mat<n, m, float>& mat) {
template <int n, int m>
void get_mat(
const dynamic::Map_sptr& root,
const std::string& name,
glm::mat<n, m, float>& mat
) {
if (const auto& list = root->list(name)) {
for (size_t y = 0; y < n; y++) {
for (size_t x = 0; x < m; x++) {
mat[y][x] = list->num(y*m+x);
mat[y][x] = list->num(y * m + x);
}
}
}
}
template<int n, int m>
void get_mat(const dynamic::List_sptr& root, size_t index, glm::mat<n, m, float>& mat) {
template <int n, int m>
void get_mat(
const dynamic::List_sptr& root, size_t index, glm::mat<n, m, float>& mat
) {
if (const auto& list = root->list(index)) {
for (size_t y = 0; y < n; y++) {
for (size_t x = 0; x < m; x++) {
mat[y][x] = list->num(y*m+x);
mat[y][x] = list->num(y * m + x);
}
}
}
}
}
#endif // DATA_DYNAMIC_UTIL_HPP_
#endif // DATA_DYNAMIC_UTIL_HPP_
src/data/setting.cpp
+2 -1
View File
@@ -7,7 +7,8 @@ std::string NumberSetting::toString() const {
case setting_format::simple:
return util::to_string(value);
case setting_format::percent:
return std::to_string(static_cast<integer_t>(round(value * 100))) + "%";
return std::to_string(static_cast<integer_t>(round(value * 100))) +
"%";
default:
return "invalid format";
}
src/data/setting.hpp
+32 -34
View File
@@ -3,15 +3,13 @@
#include <limits>
#include <string>
#include <vector>
#include <unordered_map>
#include <vector>
#include "../typedefs.hpp"
#include "../delegates.hpp"
#include "../typedefs.hpp"
enum class setting_format {
simple, percent
};
enum class setting_format { simple, percent };
class Setting {
protected:
@@ -20,7 +18,8 @@ public:
Setting(setting_format format) : format(format) {
}
virtual ~Setting() {}
virtual ~Setting() {
}
virtual void resetToDefault() = 0;
@@ -31,7 +30,7 @@ public:
virtual std::string toString() const = 0;
};
template<class T>
template <class T>
class ObservableSetting : public Setting {
int nextid = 1;
std::unordered_map<int, consumer<T>> observers;
@@ -39,10 +38,11 @@ protected:
T initial;
T value;
public:
ObservableSetting(T value, setting_format format)
: Setting(format), initial(value), value(value) {}
ObservableSetting(T value, setting_format format)
: Setting(format), initial(value), value(value) {
}
observer_handler observe(consumer<T> callback, bool callOnStart=false) {
observer_handler observe(consumer<T> callback, bool callOnStart = false) {
const int id = nextid++;
observers.emplace(id, callback);
if (callOnStart) {
@@ -87,14 +87,13 @@ protected:
number_t max;
public:
NumberSetting(
number_t value,
number_t min=std::numeric_limits<number_t>::min(),
number_t max=std::numeric_limits<number_t>::max(),
setting_format format=setting_format::simple
) : ObservableSetting(value, format),
min(min),
max(max)
{}
number_t value,
number_t min = std::numeric_limits<number_t>::min(),
number_t max = std::numeric_limits<number_t>::max(),
setting_format format = setting_format::simple
)
: ObservableSetting(value, format), min(min), max(max) {
}
number_t& operator*() {
return value;
@@ -129,14 +128,13 @@ protected:
integer_t max;
public:
IntegerSetting(
integer_t value,
integer_t min=std::numeric_limits<integer_t>::min(),
integer_t max=std::numeric_limits<integer_t>::max(),
setting_format format=setting_format::simple
) : ObservableSetting(value, format),
min(min),
max(max)
{}
integer_t value,
integer_t min = std::numeric_limits<integer_t>::min(),
integer_t max = std::numeric_limits<integer_t>::max(),
setting_format format = setting_format::simple
)
: ObservableSetting(value, format), min(min), max(max) {
}
integer_t getMin() const {
return min;
@@ -155,10 +153,9 @@ public:
class FlagSetting : public ObservableSetting<bool> {
public:
FlagSetting(
bool value,
setting_format format=setting_format::simple
) : ObservableSetting(value, format) {}
FlagSetting(bool value, setting_format format = setting_format::simple)
: ObservableSetting(value, format) {
}
void toggle() {
set(!get());
@@ -170,11 +167,12 @@ public:
class StringSetting : public ObservableSetting<std::string> {
public:
StringSetting(
std::string value,
setting_format format=setting_format::simple
) : ObservableSetting(value, format) {}
std::string value, setting_format format = setting_format::simple
)
: ObservableSetting(value, format) {
}
virtual std::string toString() const override;
};
#endif // DATA_SETTING_HPP_
#endif // DATA_SETTING_HPP_