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

Renamed 'ParamConstraint::wantedType' to 'ParamConstraint::requiredType'

Browse Source
This commit is contained in:
Leonetienne 2021-06-06 15:24:29 +02:00
parent 09a2ce4e74
commit 1b8c156314
5 changed files with 47 additions and 47 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

BIN
Hazelnupp.vpp
View File

Binary file not shown.

30
Hazelnupp/Hazelnupp.cpp
View File

@ -182,21 +182,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)
);
@ -207,7 +207,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;
}
@ -219,11 +219,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)
);
@ -250,10 +250,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 });
@ -266,7 +266,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)
);
@ -278,7 +278,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
@ -294,10 +294,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
@ -442,7 +442,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)

10
Hazelnupp/ParamConstraint.h
View File

@ -23,20 +23,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 }
{
@ -48,7 +48,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.

52
Test_Hazelnupp/Constraints.cpp
View File

@ -20,15 +20,15 @@ namespace TestHazelnupp
"/my/fake/path/wahoo.out",
"--dummy",
"123"
});
});
// Exercise
Hazelnupp nupp;
nupp.SetCrashOnFail(false);
nupp.RegisterConstraint("--elenor-int", ParamConstraint::Require({"5994"}));
nupp.RegisterConstraint("--elenor-int", ParamConstraint::Require({ "5994" }));
nupp.RegisterConstraint("--federich-float", ParamConstraint::Require({ "420.69" }));
nupp.RegisterConstraint("--siegbert-string", ParamConstraint::Require({"banana"}));
nupp.RegisterConstraint("--siegbert-string", ParamConstraint::Require({ "banana" }));
nupp.RegisterConstraint("--lieber-liste", ParamConstraint::Require({ "banana", "apple", "59" }));
nupp.Parse(C_Ify(args));
@ -72,16 +72,16 @@ namespace TestHazelnupp
"banana",
"apple",
"59"
});
});
// Exercise
Hazelnupp nupp;
nupp.SetCrashOnFail(false);
nupp.RegisterConstraint("--elenor-int", ParamConstraint::Require({ "6871" }));
nupp.RegisterConstraint("--federich-float", ParamConstraint::Require({"-199.44"}));
nupp.RegisterConstraint("--siegbert-string", ParamConstraint::Require({"bornana"}));
nupp.RegisterConstraint("--lieber-liste", ParamConstraint::Require({"bornana", "ollpe", "5"}));
nupp.RegisterConstraint("--federich-float", ParamConstraint::Require({ "-199.44" }));
nupp.RegisterConstraint("--siegbert-string", ParamConstraint::Require({ "bornana" }));
nupp.RegisterConstraint("--lieber-liste", ParamConstraint::Require({ "bornana", "ollpe", "5" }));
nupp.Parse(C_Ify(args));
@ -126,7 +126,7 @@ namespace TestHazelnupp
"9",
"--force",
"plsdontuseme"
});
});
// Exercise
Hazelnupp nupp;
@ -184,7 +184,7 @@ namespace TestHazelnupp
"banana",
"apple",
"59"
});
});
Assert::ExpectException<HazelnuppConstraintMissingValue>(
[args]
@ -199,7 +199,7 @@ namespace TestHazelnupp
nupp.Parse(C_Ify(args));
}
);
);
return;
}
@ -222,7 +222,7 @@ namespace TestHazelnupp
"banana",
"apple",
"59"
});
});
Assert::ExpectException<HazelnuppConstraintTypeMissmatch>(
[args]
@ -232,12 +232,12 @@ namespace TestHazelnupp
nupp.RegisterConstraint(
"--elenor-int",
ParamConstraint::TypeSafety( DATA_TYPE::INT)
ParamConstraint::TypeSafety(DATA_TYPE::INT)
);
nupp.Parse(C_Ify(args));
}
);
);
return;
}
@ -259,7 +259,7 @@ namespace TestHazelnupp
"--void5",
"foo",
"baz"
});
});
Hazelnupp nupp;
nupp.SetCrashOnFail(false);
@ -292,7 +292,7 @@ namespace TestHazelnupp
"/my/fake/path/wahoo.out",
"--dummy",
"--empty-list",
});
});
Hazelnupp nupp;
nupp.SetCrashOnFail(false);
@ -321,7 +321,7 @@ namespace TestHazelnupp
"/my/fake/path/wahoo.out",
"--dummy",
"--empty-string",
});
});
Hazelnupp nupp;
nupp.SetCrashOnFail(false);
@ -349,7 +349,7 @@ namespace TestHazelnupp
ArgList args({
"/my/fake/path/wahoo.out",
"--thisisvoid",
});
});
// Test section: INT
Assert::ExpectException<HazelnuppConstraintTypeMissmatch>([args]
@ -406,14 +406,14 @@ namespace TestHazelnupp
"/my/fake/path/wahoo.out",
"--dummy",
"--empty-list",
});
});
Hazelnupp nupp;
nupp.SetCrashOnFail(false);
nupp.RegisterConstraint(
"--default-val",
ParamConstraint::Require({"32"}, true)
ParamConstraint::Require({ "32" }, true)
);
nupp.RegisterConstraint(
@ -444,7 +444,7 @@ namespace TestHazelnupp
"/my/fake/path/wahoo.out",
"--dummy",
"--empty-list",
});
});
Hazelnupp nupp;
nupp.SetCrashOnFail(false);
@ -471,7 +471,7 @@ namespace TestHazelnupp
"/my/fake/path/wahoo.out",
"--dummy",
"--empty-list",
});
});
Hazelnupp nupp;
nupp.SetCrashOnFail(false);
@ -501,14 +501,14 @@ namespace TestHazelnupp
"/my/fake/path/wahoo.out",
"--dummy",
"--empty-list",
});
});
Hazelnupp nupp;
nupp.SetCrashOnFail(false);
ParamConstraint dftvalConst_expected =
ParamConstraint::Require({"32"}, true);
ParamConstraint dftvalConst_expected =
ParamConstraint::Require({ "32" }, true);
nupp.RegisterConstraint("--default-val", dftvalConst_expected);
nupp.RegisterConstraint("--not-there", ParamConstraint::Require({}, true));
nupp.RegisterConstraint("--another-one", ParamConstraint::Require({ "bites" }, true));
@ -519,7 +519,7 @@ namespace TestHazelnupp
// Verify
Assert::IsTrue(dftvalConst_expected.required == dftvalConst.required, L"required");
Assert::IsTrue(dftvalConst_expected.defaultValue == dftvalConst.defaultValue, L"defaultValue");
Assert::IsTrue(dftvalConst_expected.wantedType == dftvalConst.wantedType, L"wantedType");
Assert::IsTrue(dftvalConst_expected.requiredType == dftvalConst.requiredType, L"requiredType");
Assert::IsTrue(dftvalConst_expected.constrainType == dftvalConst.constrainType, L"constrainType");
return;

2
readme.md
View File

@ -244,7 +244,7 @@ Note that you can also combine these two constraint-types by populating the stru
```cpp
ParamConstraint pc;
pc.constrainType = true;
pc.wantedType = DATA_TYPE::STRING;
pc.requiredType = DATA_TYPE::STRING;
pc.defaultValue = {}; // no default value
pc.required = true;