diff --git a/Hazelnupp.vpp b/Hazelnupp.vpp index 60a5f6d..3b8d026 100644 Binary files a/Hazelnupp.vpp and b/Hazelnupp.vpp differ diff --git a/Hazelnupp/Hazelnupp.cpp b/Hazelnupp/Hazelnupp.cpp index 7d5d646..8d5d829 100644 --- a/Hazelnupp/Hazelnupp.cpp +++ b/Hazelnupp/Hazelnupp.cpp @@ -182,21 +182,21 @@ Value* Hazelnupp::ParseValue(const std::vector& 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& 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& 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& 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& 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& 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& 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) diff --git a/Hazelnupp/ParamConstraint.h b/Hazelnupp/ParamConstraint.h index 32a3981..3d4ce7e 100644 --- a/Hazelnupp/ParamConstraint.h +++ b/Hazelnupp/ParamConstraint.h @@ -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& defaultValue, bool required) + ParamConstraint(bool constrainType, DATA_TYPE requiredType, const std::vector& 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. diff --git a/Test_Hazelnupp/Constraints.cpp b/Test_Hazelnupp/Constraints.cpp index 04055ac..31eca99 100644 --- a/Test_Hazelnupp/Constraints.cpp +++ b/Test_Hazelnupp/Constraints.cpp @@ -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( [args] @@ -199,7 +199,7 @@ namespace TestHazelnupp nupp.Parse(C_Ify(args)); } - ); + ); return; } @@ -222,7 +222,7 @@ namespace TestHazelnupp "banana", "apple", "59" - }); + }); Assert::ExpectException( [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([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; diff --git a/readme.md b/readme.md index d139063..252abf5 100644 --- a/readme.md +++ b/readme.md @@ -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;