xbot/include/libconfig-1.7.3/contrib/chained/libconfig_chained.h

542 lines
14 KiB
C
Raw Normal View History

2024-02-13 07:22:10 +00:00
/* ----------------------------------------------------------------------------
libconfig - A library for processing structured configuration files
libconfig chained - Extension for reading the configuration and defining
the configuration specification at once.
Copyright (C) 2016 Richard Schubert
This file is part of libconfig contributions.
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public License
as published by the Free Software Foundation; either version 2.1 of
the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Library General Public
License along with this library; if not, see
<http://www.gnu.org/licenses/>.
----------------------------------------------------------------------------
*/
#pragma once
#ifndef _CHAINED_LIBCONFIG_H_
#define _CHAINED_LIBCONFIG_H_
#include <libconfig.h++>
#include <cassert>
#include <fstream>
#include <sstream>
#include <iostream>
namespace libconfig
{
class ChainedSetting
{
struct Variant
{
private:
bool isSet;
Setting::Type type;
bool value_bool;
int64_t value_int;
double value_float;
std::string value_string;
public:
Variant()
: isSet(false)
, type(Setting::TypeNone)
{
}
Variant(bool value)
{
value_bool = value;
isSet = true;
type = Setting::TypeBoolean;
}
Variant(int32_t value)
{
value_int = value;
isSet = true;
type = Setting::TypeInt;
}
Variant(int64_t value)
{
value_int = value;
isSet = true;
type = Setting::TypeInt64;
}
Variant(double value)
{
value_float = value;
isSet = true;
type = Setting::TypeFloat;
}
Variant(std::string& value)
{
value_string = value;
isSet = true;
type = Setting::TypeString;
}
Variant(const char* value)
{
value_string = value;
isSet = true;
type = Setting::TypeString;
}
operator bool() const { return value_bool; }
operator int() const { return (int)value_int; }
operator unsigned int() const { return (unsigned int)value_int; }
operator long() const { return (long)value_int; }
operator unsigned long() const { return (unsigned long)value_int; }
operator long long() const { return (long long)value_int; }
operator unsigned long long() const { return (unsigned long long)value_int; }
operator double() const { return value_float; }
operator float() const { return (float)value_float; }
operator std::string() const { return value_string; }
const bool IsSet() const
{
return isSet;
}
const Setting::Type GetType() const
{
return type;
}
};
public:
// Starting point for method chained libconfig.
// Pass a custom ostream to intercept any error messages (useful for Applications with UI).
ChainedSetting(Setting& setting, std::ostream& err = std::cerr)
: name(setting.isRoot() ? "<root>" : (setting.getName() ? setting.getName() : ""))
, index(setting.getIndex())
, parent(NULL)
, setting(&setting)
, err(err)
, isSettingMandatory(false)
, anySettingIsMissing(false)
, anyMandatorySettingIsMissing(false)
, capturedSpecification(NULL)
, capturedSetting(NULL)
{
}
// Starts capturing any configuration readings into the temporary config object.
void captureExpectedSpecification(Config* temporaryConfigSpecification)
{
capturedSpecification = temporaryConfigSpecification;
capturedSetting = &capturedSpecification->getRoot();
}
// Returns the captured configuration specification,
// premised captureExpectedSpecification() was called earlier.
// The path parameter is needed to write the configuration
// to disk before it can be read into a usable string.
std::string getCapturedSpecification(const std::string& tempFilePath)
{
try
{
capturedSpecification->writeFile(tempFilePath.c_str());
}
catch (const FileIOException&)
{
err << "I/O error while writing temporary setting file: " << tempFilePath << std::endl;
return "";
}
std::ifstream t(tempFilePath);
if (!t.is_open())
{
err << "I/O error while reading temporary setting file: " << tempFilePath << std::endl;
return "";
}
std::stringstream buffer;
buffer << t.rdbuf();
capturedSpecification = NULL;
return buffer.str();
}
// Defines the default value for this setting if missing from config file.
template<typename T>
ChainedSetting& defaultValue(T defaultValue)
{
defaultVal = defaultValue;
return *this;
}
// Defines the inclusive minimum value for this setting.
// A lesser value set in a configuration file will be clamped to this limit.
template<typename T>
ChainedSetting& min(T min)
{
minVal = min;
return *this;
}
// Defines the inclusive maximum value for this setting.
// A greater value set in a configuration file will be clamped to this limit.
template<typename T>
ChainedSetting& max(T max)
{
maxVal = max;
return *this;
}
// Defines this setting to be mandatory.
// Any mandatory value missing in the configuration file will raise an error.
// Use isAnyMandatorySettingMissing() to check for any violations.
ChainedSetting& isMandatory()
{
isSettingMandatory = true;
if (parent) parent->isMandatory();
return *this;
}
template<typename T>
operator T()
{
auto requestedType = GetRequestedType<T>();
CheckType(defaultVal, requestedType);
CheckType(minVal, requestedType);
CheckType(maxVal, requestedType);
CaptureSetting<T>(requestedType);
if (!setting)
{
if (isSettingMandatory)
{
AlertMandatorySettingMissing<T>();
}
PropagateAnySettingIsMissing();
return GetDefaultValue<T>();
}
try
{
T value = *setting;
if (minVal.IsSet())
{
T min = minVal;
if (value < min)
{
err << "'" << setting->getPath() << "' setting is out of valid bounds (min: " << min << "). Value was: " << value << std::endl;
value = min;
}
}
if (maxVal.IsSet())
{
T max = maxVal;
if (value > max)
{
err << "'" << setting->getPath() << "' setting is out of valid bounds (max: " << max << "). Value was: " << value << std::endl;
value = max;
}
}
return value;
}
catch (const SettingTypeException& tex)
{
err << "'" << tex.getPath() << "' setting is of wrong type." << std::endl;
}
return GetDefaultValue<T>();
}
ChainedSetting operator[](const char *name)
{
CaptureSetting<Setting>(Setting::TypeGroup);
if (!setting)
{
return ChainedSetting(name, this);
}
if(setting->exists(name))
{
return ChainedSetting((*setting)[name], this);
}
else
{
return ChainedSetting(name, this);
}
}
inline ChainedSetting operator[](const std::string &name)
{
return(operator[](name.c_str()));
}
ChainedSetting operator[](int index)
{
// This could also be an TypeArray but we cannot be sure here.
// By using TypeList we ensure it will always work.
CaptureSetting<Setting>(Setting::TypeList);
if (!setting)
{
return ChainedSetting(index, this);
}
if (index >= 0 && index < setting->getLength())
{
return ChainedSetting((*setting)[index], this);
}
else
{
return ChainedSetting(index, this);
}
}
int getLength() const
{
return setting ? setting->getLength() : 0;
}
Setting::Type getType() const
{
return setting ? setting->getType() : Setting::TypeNone;
}
// Indicates whether this setting is present in the read configuration file.
bool exists() const
{
return setting != NULL;
}
bool isAnyMandatorySettingMissing() const
{
return anyMandatorySettingIsMissing;
}
bool isAnySettingMissing() const
{
return anySettingIsMissing;
}
void clearAnySettingMissingFlag()
{
anySettingIsMissing = false;
}
private:
ChainedSetting(Setting& setting, ChainedSetting* parent)
: name(setting.isRoot() ? "<root>" : (setting.getName() ? setting.getName() : ""))
, index(setting.getIndex())
, parent(parent)
, setting(&setting)
, err(parent->err)
, isSettingMandatory(false)
, anySettingIsMissing(false)
, anyMandatorySettingIsMissing(false)
, capturedSpecification(NULL)
, capturedSetting(NULL)
{
}
ChainedSetting(const std::string& name, ChainedSetting* parent)
: name(name)
, index(-1)
, parent(parent)
, setting(NULL)
, err(parent->err)
, isSettingMandatory(false)
, anySettingIsMissing(true)
, anyMandatorySettingIsMissing(false)
, capturedSpecification(NULL)
, capturedSetting(NULL)
{
}
ChainedSetting(int index, ChainedSetting* parent)
: name("")
, index(index)
, parent(parent)
, setting(NULL)
, err(parent->err)
, isSettingMandatory(false)
, anySettingIsMissing(true)
, anyMandatorySettingIsMissing(false)
, capturedSpecification(NULL)
, capturedSetting(NULL)
{
}
template<typename T>
void ConditionalSetCapturedDefaultValue()
{
*capturedSetting = GetDefaultValue<T>();
}
template<typename T>
void CaptureSetting(Setting::Type type)
{
if (!capturedSetting && parent && parent->capturedSetting)
{
if (name.length() > 0)
{
if (!parent->capturedSetting->exists(name))
{
capturedSetting = &parent->capturedSetting->add(name, type);
}
else
{
capturedSetting = &(*parent->capturedSetting)[name.c_str()];
}
}
else
{
if (index < parent->capturedSetting->getLength())
{
capturedSetting = &(*parent->capturedSetting)[0];
}
else
{
assert(index == parent->capturedSetting->getLength()); // you requested an index while omitting at least one of its previous siblings
capturedSetting = &parent->capturedSetting->add(type);
}
}
ConditionalSetCapturedDefaultValue<T>();
}
}
std::string GetPath() const
{
if (setting)
{
return setting->getPath();
}
std::string path = (name.length() > 0) ? name : "[" + std::to_string(index) + "]";
if (parent)
{
auto parentPath = parent->GetPath();
return (parentPath.length() > 0) ? (parentPath + ((name.length() == 0) ? "" : ".") + path) : path;
}
return path;
}
void PropagateAnySettingIsMissing()
{
anySettingIsMissing = true;
if (parent)
{
parent->PropagateAnySettingIsMissing();
}
}
void PropagateAnyMandatorySettingIsMissing()
{
anyMandatorySettingIsMissing = true;
if (parent)
{
parent->PropagateAnyMandatorySettingIsMissing();
}
}
template<typename T>
void AlertMandatorySettingMissing()
{
PropagateAnyMandatorySettingIsMissing();
err << "Missing '" << GetPath() << "' setting in configuration file." << std::endl;
}
template<typename T>
T GetUnsetDefaultValue() const
{
return (T)0;
}
template<typename T>
T GetDefaultValue() const
{
if (defaultVal.IsSet())
{
return (T)defaultVal;
}
return GetUnsetDefaultValue<T>();
}
template<typename T>
Setting::Type GetRequestedType() const
{
// TODO @ Hemofektik: Check whether the outcommented line is still needed. static_assert(false) is checked on compile time and, well, asserts :)
// static_assert(false, "should never happen, unless you requested an unsupported type");
return Setting::TypeNone;
}
void CheckType(const Variant& variant, Setting::Type expectedType) const
{
if (!variant.IsSet()) return;
if(expectedType != variant.GetType())
{
assert(false); // fix your code to match the whole chain of this setting to one single type!
err << "'" << GetPath() << "' setting limits or default value is of incompatible type." << std::endl;
}
}
std::string name;
int index;
ChainedSetting* parent;
Setting* setting;
std::ostream& err;
Variant defaultVal;
Variant minVal;
Variant maxVal;
bool isSettingMandatory;
bool anySettingIsMissing;
bool anyMandatorySettingIsMissing;
Config* capturedSpecification;
Setting* capturedSetting;
};
template<>
inline
void ChainedSetting::ConditionalSetCapturedDefaultValue<Setting>() { }
template<>
inline
std::string ChainedSetting::GetUnsetDefaultValue() const
{
return "";
}
template<> inline Setting::Type ChainedSetting::GetRequestedType<int8_t>() const { return Setting::TypeInt; }
template<> inline Setting::Type ChainedSetting::GetRequestedType<uint8_t>() const { return Setting::TypeInt; }
template<> inline Setting::Type ChainedSetting::GetRequestedType<int16_t>() const { return Setting::TypeInt; }
template<> inline Setting::Type ChainedSetting::GetRequestedType<uint16_t>() const { return Setting::TypeInt; }
template<> inline Setting::Type ChainedSetting::GetRequestedType<int32_t>() const { return Setting::TypeInt; }
template<> inline Setting::Type ChainedSetting::GetRequestedType<uint32_t>() const { return Setting::TypeInt; }
template<> inline Setting::Type ChainedSetting::GetRequestedType<int64_t>() const { return Setting::TypeInt64; }
template<> inline Setting::Type ChainedSetting::GetRequestedType<uint64_t>() const { return Setting::TypeInt64; }
template<> inline Setting::Type ChainedSetting::GetRequestedType<float>() const { return Setting::TypeFloat; }
template<> inline Setting::Type ChainedSetting::GetRequestedType<double>() const { return Setting::TypeFloat; }
template<> inline Setting::Type ChainedSetting::GetRequestedType<std::string>() const { return Setting::TypeString; }
template<> inline Setting::Type ChainedSetting::GetRequestedType<bool>() const { return Setting::TypeBoolean; }
}
#endif