Built include files

INCLUDE/Hazelnupp.cpp

@@ -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->requiredType == DATA_TYPE::INT) ||
-			 (constraint->wantedType == DATA_TYPE::FLOAT)))
+			 (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)

INCLUDE/Hazelnupp.h

@@ -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>