generic-library/valijson
1
0
Fork 0
mirror of https://github.com/tristanpenman/valijson.git synced 2025-03-03 12:58:03 +01:00
Code Issues Projects Releases Wiki Activity

Improve encapsulation in MinimumConstraint class

Browse Source
This commit is contained in:
Tristan Penman 2016-01-10 10:11:38 +11:00
parent 65e2c662cc
commit 4d0d38566c
5 changed files with 66 additions and 35 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
examples/custom_schema.cpp
View File

@ -125,7 +125,10 @@ void addPropertiesConstraint(Schema &schema)
// Create a child schema for the 'price' property, that requires a
// number with a value greater than zero.
const Subschema *subschema = schema.createSubschema();
schema.addConstraintToSubschema(MinimumConstraint(0.0, true), subschema);
MinimumConstraint minimumConstraint;
minimumConstraint.setMinimum(0.0);
minimumConstraint.setExclusiveMinimum(true);
schema.addConstraintToSubschema(minimumConstraint, subschema);
TypeConstraint typeConstraint;
typeConstraint.addNamedType(TypeConstraint::kNumber);
schema.addConstraintToSubschema(typeConstraint, subschema);

41
include/valijson/constraints/concrete_constraints.hpp
View File

@ -451,16 +451,43 @@ struct MaxPropertiesConstraint: BasicConstraint<MaxPropertiesConstraint>
};
/**
* @brief Represents a pair of 'minimum' and 'exclusiveMinimum' constraints.
* @brief Represents 'minimum' and 'exclusiveMinimum' constraints
*/
struct MinimumConstraint: BasicConstraint<MinimumConstraint>
class MinimumConstraint: public BasicConstraint<MinimumConstraint>
{
MinimumConstraint(double minimum, bool exclusiveMinimum)
: minimum(minimum),
exclusiveMinimum(exclusiveMinimum) { }
public:
MinimumConstraint()
: minimum(-std::numeric_limits<double>::infinity()),
exclusiveMinimum(false) { }
const double minimum;
const bool exclusiveMinimum;
MinimumConstraint(CustomAlloc allocFn, CustomFree freeFn)
: BasicConstraint(allocFn, freeFn),
minimum(-std::numeric_limits<double>::infinity()),
exclusiveMinimum(false) { }
bool getExclusiveMinimum() const
{
return exclusiveMinimum;
}
void setExclusiveMinimum(bool newExclusiveMinimum)
{
exclusiveMinimum = newExclusiveMinimum;
}
double getMinimum() const
{
return minimum;
}
void setMinimum(double newMinimum)
{
minimum = newMinimum;
}
private:
double minimum;
bool exclusiveMinimum;
};
/**

2
include/valijson/constraints/constraint_visitor.hpp
View File

@ -9,7 +9,6 @@ struct FormatConstraint;
struct MaxItemsConstraint;
struct MaxLengthConstraint;
struct MaxPropertiesConstraint;
struct MinimumConstraint;
struct MinItemsConstraint;
struct MinLengthConstraint;
struct MinPropertiesConstraint;
@ -21,6 +20,7 @@ class DependenciesConstraint;
class EnumConstraint;
class LinearItemsConstraint;
class MaximumConstraint;
class MinimumConstraint;
class NotConstraint;
class OneOfConstraint;
class PatternConstraint;

24
include/valijson/schema_parser.hpp
View File

@ -1009,25 +1009,25 @@ private:
const AdapterType &node,
const AdapterType *exclusiveMinimum)
{
bool exclusiveMinimumValue = false;
if (!node.maybeDouble()) {
throw std::runtime_error(
"Expected numeric value for minimum constraint.");
}
constraints::MinimumConstraint constraint;
constraint.setMinimum(node.asDouble());
if (exclusiveMinimum) {
if (exclusiveMinimum->maybeBool()) {
exclusiveMinimumValue = exclusiveMinimum->asBool();
} else {
if (!exclusiveMinimum->maybeBool()) {
throw std::runtime_error(
"Expected boolean value for 'exclusiveMinimum' "
"constraint.");
}
constraint.setExclusiveMinimum(exclusiveMinimum->asBool());
}
if (node.maybeDouble()) {
double minimumValue = node.asDouble();
return constraints::MinimumConstraint(minimumValue,
exclusiveMinimumValue);
}
throw std::runtime_error(
"Expected numeric value for 'minimum' constraint.");
return constraint;
}
/**

29
include/valijson/validation_visitor.hpp
View File

@ -467,12 +467,11 @@ public:
}
/**
* @brief Validate against the minimum constraint represented by a
* MinimumConstraint object.
* @brief Validate a value against a MinimumConstraint
*
* @param constraint Constraint that the target must validate against.
* @param constraint Constraint that the target must validate against
*
* @return true if the constraint is satisfied, false otherwise.
* @return \c true if the constraint is satisfied; \c false otherwise
*/
virtual bool visit(const MinimumConstraint &constraint)
{
@ -481,24 +480,26 @@ public:
return true;
}
if (constraint.exclusiveMinimum) {
if (target.asDouble() <= constraint.minimum) {
const double minimum = constraint.getMinimum();
if (constraint.getExclusiveMinimum()) {
if (target.asDouble() <= minimum) {
if (results) {
results->pushError(context,
"Expected number greater than " +
boost::lexical_cast<std::string>(constraint.minimum));
boost::lexical_cast<std::string>(minimum));
}
return false;
}
} else {
if (target.asDouble() < constraint.minimum) {
if (results) {
results->pushError(context,
} else if (target.asDouble() < minimum) {
if (results) {
results->pushError(context,
"Expected number greater than or equal to" +
boost::lexical_cast<std::string>(constraint.minimum));
}
return false;
boost::lexical_cast<std::string>(minimum));
}
return false;
}
return true;