json-validator/include/jvalidate/constraint/general_constraint.h

#pragma once

#include <memory>
#include <set>
#include <utility>
#include <vector>

#include <jvalidate/constraint/constraint.h>
#include <jvalidate/forward.h>
#include <jvalidate/status.h>

namespace jvalidate::constraint {
class AllOfConstraint : public SimpleConstraint<AllOfConstraint> {
public:
  std::vector<SubConstraint> children;

public:
  AllOfConstraint(std::vector<schema::Node const *> const & children)
      : children(children.begin(), children.end()) {}

  AllOfConstraint(std::vector<std::unique_ptr<Constraint>> && children) {
    for (auto && child : children) {
      this->children.push_back(std::move(child));
    }
  }
};

class AnyOfConstraint : public SimpleConstraint<AnyOfConstraint> {
public:
  std::vector<SubConstraint> children;

public:
  AnyOfConstraint(std::vector<schema::Node const *> const & children)
      : children(children.begin(), children.end()) {}

  AnyOfConstraint(std::vector<std::unique_ptr<Constraint>> && children) {
    for (auto && child : children) {
      this->children.push_back(std::move(child));
    }
  }
};

class EnumConstraint : public SimpleConstraint<EnumConstraint> {
public:
  std::vector<std::unique_ptr<adapter::Const const>> enumeration;

public:
  EnumConstraint(std::unique_ptr<adapter::Const const> && constant) {
    enumeration.push_back(std::move(constant));
  }

  EnumConstraint(std::vector<std::unique_ptr<adapter::Const const>> && enums)
      : enumeration(std::move(enums)) {}
};

class OneOfConstraint : public SimpleConstraint<OneOfConstraint> {
public:
  std::vector<schema::Node const *> children;

public:
  OneOfConstraint(std::vector<schema::Node const *> const & children) : children(children) {}
};

class ConditionalConstraint : public SimpleConstraint<ConditionalConstraint> {
public:
  schema::Node const * if_constraint;
  schema::Node const * then_constraint;
  schema::Node const * else_constraint;

public:
  ConditionalConstraint(schema::Node const * if_constraint, schema::Node const * then_constraint,
                        schema::Node const * else_constraint)
      : if_constraint(if_constraint), then_constraint(then_constraint),
        else_constraint(else_constraint) {}
};

class NotConstraint : public SimpleConstraint<NotConstraint> {
public:
  SubConstraint child;

public:
  NotConstraint(schema::Node const * child) : child(child) {}
  NotConstraint(std::unique_ptr<Constraint> && child) : child(std::move(child)) {}
};

class TypeConstraint : public SimpleConstraint<TypeConstraint> {
public:
  std::set<adapter::Type> types;

public:
  TypeConstraint(adapter::Type type) : types{type} {}
  TypeConstraint(std::set<adapter::Type> const & types) : types(types) {}
};
}