leonetienne/Hazelnupp
1
0
Fork 0
Code Issues 3 Pull Requests Packages Projects Releases Wiki Activity

Built include files

Browse Source
This commit is contained in:
Leonetienne 2021-06-06 15:31:47 +02:00
parent 1b8c156314
commit 6166e43d31
2 changed files with 70 additions and 70 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

30
INCLUDE/Hazelnupp.cpp
View File

@ -254,21 +254,21 @@ Value* Hazelnupp::ParseValue(const std::vector<std::string>& values, const Param
// Is a list forced via a constraint? If yes, return an empty list
if ((constrainType) &&
(constraint->wantedType == DATA_TYPE::LIST))
(constraint->requiredType == DATA_TYPE::LIST))
return new ListValue();
// Is a string forced via a constraint? If yes, return an empty string
else if ((constrainType) &&
(constraint->wantedType == DATA_TYPE::STRING))
(constraint->requiredType == DATA_TYPE::STRING))
return new StringValue("");
// Is an int or float forced via constraint? If yes, throw an exception
else if ((constrainType) &&
((constraint->wantedType == DATA_TYPE::INT) ||
(constraint->wantedType == DATA_TYPE::FLOAT)))
((constraint->requiredType == DATA_TYPE::INT) ||
(constraint->requiredType == DATA_TYPE::FLOAT)))
throw HazelnuppConstraintTypeMissmatch(
constraint->key,
constraint->wantedType,
constraint->requiredType,
rawInputType,
GetDescription(constraint->key)
);
@ -279,7 +279,7 @@ Value* Hazelnupp::ParseValue(const std::vector<std::string>& values, const Param
// Force void type by constraint
else if ((constrainType) &&
(constraint->wantedType == DATA_TYPE::VOID))
(constraint->requiredType == DATA_TYPE::VOID))
{
return new VoidValue;
}
@ -291,11 +291,11 @@ Value* Hazelnupp::ParseValue(const std::vector<std::string>& values, const Param
// Should the type be something other than list?
if ((constrainType) &&
(constraint->wantedType != DATA_TYPE::LIST))
(constraint->requiredType != DATA_TYPE::LIST))
{
throw HazelnuppConstraintTypeMissmatch(
constraint->key,
constraint->wantedType,
constraint->requiredType,
rawInputType,
GetDescription(constraint->key)
);
@ -322,10 +322,10 @@ Value* Hazelnupp::ParseValue(const std::vector<std::string>& values, const Param
// Is the type not supposed to be a string?
// void and list are already sorted out
if ((constrainType) &&
(constraint->wantedType != DATA_TYPE::STRING))
(constraint->requiredType != DATA_TYPE::STRING))
{
// We can only force a list-value from here
if (constraint->wantedType == DATA_TYPE::LIST)
if (constraint->requiredType == DATA_TYPE::LIST)
{
ListValue* list = new ListValue();
Value* tmp = ParseValue({ val });
@ -338,7 +338,7 @@ Value* Hazelnupp::ParseValue(const std::vector<std::string>& values, const Param
else
throw HazelnuppConstraintTypeMissmatch(
constraint->key,
constraint->wantedType,
constraint->requiredType,
rawInputType,
GetDescription(constraint->key)
);
@ -350,7 +350,7 @@ Value* Hazelnupp::ParseValue(const std::vector<std::string>& values, const Param
// In this case we have a numeric value.
// We should still produce a string if requested
if ((constrainType) &&
(constraint->wantedType == DATA_TYPE::STRING))
(constraint->requiredType == DATA_TYPE::STRING))
return new StringValue(val);
// Numeric
@ -366,10 +366,10 @@ Value* Hazelnupp::ParseValue(const std::vector<std::string>& values, const Param
if (constrainType)
{
// Must it be an integer?
if (constraint->wantedType == DATA_TYPE::INT)
if (constraint->requiredType == DATA_TYPE::INT)
return new IntValue((long long int)num);
// Must it be a floating point?
else if (constraint->wantedType == DATA_TYPE::FLOAT)
else if (constraint->requiredType == DATA_TYPE::FLOAT)
return new FloatValue(num);
// Else it must be a List
else
@ -514,7 +514,7 @@ std::string Hazelnupp::GenerateDocumentation() const
ParamDocEntry& cached = paramInfos[it.first];
cached.required = it.second.required;
cached.typeIsForced = it.second.constrainType;
cached.type = DataTypeToString(it.second.wantedType);
cached.type = DataTypeToString(it.second.requiredType);
std::stringstream defaultValueSs;
for (const std::string& s : it.second.defaultValue)

110
INCLUDE/Hazelnupp.h
View File

@ -1,18 +1,5 @@
#pragma once
/*** ../Hazelnupp/Placeholders.h ***/
#include <string>
namespace Hazelnp
{
namespace Placeholders
{
//! The only purpose of this is to provide the ability to return an empty string as an error for std::string& methods.
static const std::string g_emptyString;
}
}
/*** ../Hazelnupp/StringTools.h ***/
#include <string>
@ -55,6 +42,19 @@ namespace Hazelnp
};
}
/*** ../Hazelnupp/Placeholders.h ***/
#include <string>
namespace Hazelnp
{
namespace Placeholders
{
//! The only purpose of this is to provide the ability to return an empty string as an error for std::string& methods.
static const std::string g_emptyString;
}
}
/*** ../Hazelnupp/DataType.h ***/
#include <string>
@ -121,20 +121,20 @@ namespace Hazelnp
}
//! Constructs a type-safety constraint
static ParamConstraint TypeSafety(DATA_TYPE wantedType, bool constrainType = true)
static ParamConstraint TypeSafety(DATA_TYPE requiredType, bool constrainType = true)
{
ParamConstraint pc;
pc.constrainType = constrainType;
pc.wantedType = wantedType;
pc.requiredType = requiredType;
return pc;
}
//! Whole constructor
ParamConstraint(bool constrainType, DATA_TYPE wantedType, const std::vector<std::string>& defaultValue, bool required)
ParamConstraint(bool constrainType, DATA_TYPE requiredType, const std::vector<std::string>& defaultValue, bool required)
:
constrainType{ constrainType },
wantedType{ wantedType },
requiredType{ requiredType },
defaultValue{ defaultValue },
required{ required }
{
@ -146,7 +146,7 @@ namespace Hazelnp
bool constrainType = false;
//! Constrain the parameter to this value. Requires `constrainType` to be set to true.
DATA_TYPE wantedType = DATA_TYPE::VOID;
DATA_TYPE requiredType = DATA_TYPE::VOID;
//! The default value for this parameter.
//! Gets applied if this parameter was not given.
@ -458,43 +458,6 @@ namespace Hazelnp
};
}
/*** ../Hazelnupp/VoidValue.h ***/
namespace Hazelnp
{
/** Specializations for void values. These house no value whatsoever, but only communicate information by merely existing.
*/
class VoidValue : public Value
{
public:
VoidValue();
~VoidValue() override {};
//! Will return a deeopopy of this object
Value* Deepcopy() const override;
//! Will return a string suitable for an std::ostream;
std::string GetAsOsString() const override;
//! Throws HazelnuppValueNotConvertibleException
long long int GetInt64() const override;
//! Throws HazelnuppValueNotConvertibleException
int GetInt32() const override;
//! Throws HazelnuppValueNotConvertibleException
long double GetFloat64() const override;
//! Throws HazelnuppValueNotConvertibleException
double GetFloat32() const override;
//! Returns an empty string
std::string GetString() const override;
//! Returns an empty list
const std::vector<Value*>& GetList() const;
};
}
/*** ../Hazelnupp/Parameter.h ***/
#include <string>
@ -671,6 +634,43 @@ namespace Hazelnp
};
}
/*** ../Hazelnupp/VoidValue.h ***/
namespace Hazelnp
{
/** Specializations for void values. These house no value whatsoever, but only communicate information by merely existing.
*/
class VoidValue : public Value
{
public:
VoidValue();
~VoidValue() override {};
//! Will return a deeopopy of this object
Value* Deepcopy() const override;
//! Will return a string suitable for an std::ostream;
std::string GetAsOsString() const override;
//! Throws HazelnuppValueNotConvertibleException
long long int GetInt64() const override;
//! Throws HazelnuppValueNotConvertibleException
int GetInt32() const override;
//! Throws HazelnuppValueNotConvertibleException
long double GetFloat64() const override;
//! Throws HazelnuppValueNotConvertibleException
double GetFloat32() const override;
//! Returns an empty string
std::string GetString() const override;
//! Returns an empty list
const std::vector<Value*>& GetList() const;
};
}
/*** ../Hazelnupp/FloatValue.h ***/
#include <ostream>