Constraint.hpp

Go to the documentation of this file.

//
//  CeresEngine - A game development framework
//
//  Created by Rogiel Sulzbach.
//  Copyright (c) 2018-2023 Rogiel Sulzbach. All rights reserved.
//
 
#pragma once
 
#include "ConstraintExpression.hpp"
#include "ConstraintStrength.hpp"
#include "ConstraintVariable.hpp"
 
#include "CeresEngine/Foundation/SmartPtr.hpp"
 
#include "CeresEngine/Math/Math.hpp"
 
#include <cstdlib>
#include <map>
#include <vector>
 
namespace CeresEngine::Constraint {
 
    enum class ConstraintRelationalOperator {
        LessThanEqual,
        GreaterThanEqual,
        Equal
    };
 
    class Constraint final {
    private:
        class Data;
        RC<Data> mData;
 
    public:
        Constraint() = default;
        Constraint(const ConstraintExpression& expr, const ConstraintRelationalOperator op, const ConstraintStrength& strength = ConstraintStrength::required) : mData(new Data(expr, op, strength)) {}
        Constraint(const Constraint& other, const ConstraintStrength& strength) : mData(new Data(other, strength)) {}
 
        Constraint(const Constraint&) = default;
        Constraint& operator=(const Constraint&) = default;
 
        Constraint(Constraint&&) noexcept = default;
        Constraint& operator=(Constraint&&) noexcept = default;
 
        ~Constraint() = default;
 
    public:
        [[nodiscard]] const ConstraintExpression& getExpression() const { return mData->mExpression; }
        [[nodiscard]] ConstraintRelationalOperator getOperator() const { return mData->mOperator; }
        [[nodiscard]] const ConstraintStrength& getStrength() const { return mData->mStrength; }
 
        [[nodiscard]] bool isViolated() const;
        [[nodiscard]] bool isSatisfied() const noexcept { return !isViolated(); }
        [[nodiscard]] bool operator!() const { return !mData; }
 
    public:
        [[nodiscard]] String toString() const;
 
        friend std::ostream& operator<<(std::ostream& stream, const Constraint& constraint);
 
    private:
        static ConstraintExpression reduce(const ConstraintExpression& expr);
 
        class Data : public RefCounted<Data, RefCounter<false>> {
        public:
            Data(const ConstraintExpression& expr, const ConstraintRelationalOperator op, const ConstraintStrength& strength)
                    : mExpression(reduce(expr)), mStrength(strength), mOperator(op) {}
 
            Data(const Constraint& other, const ConstraintStrength& strength)
                    : mExpression(other.getExpression()), mStrength(strength), mOperator(other.getOperator()) {}
 
            ~Data() = default;
 
            ConstraintExpression mExpression;
            ConstraintStrength mStrength;
            ConstraintRelationalOperator mOperator;
 
        private:
            Data(const Data& other);
            Data& operator=(const Data& other);
        };
 
    public:
        friend bool operator<(const Constraint& lhs, const Constraint& rhs) { return lhs.mData.get() < rhs.mData.get(); }
        friend bool operator==(const Constraint& lhs, const Constraint& rhs) { return lhs.mData == rhs.mData; }
        friend bool operator!=(const Constraint& lhs, const Constraint& rhs) { return lhs.mData != rhs.mData; }
    };
    
    
    // Variable multiply, divide, and unary invert
    inline ConstraintExpression::Term operator*(const ConstraintVariable& variable, const double coefficient) { return ConstraintExpression::Term(variable, coefficient); }
    inline ConstraintExpression::Term operator/(const ConstraintVariable& variable, const double denominator) { return variable * (1.0 / denominator); }
    inline ConstraintExpression::Term operator-(const ConstraintVariable& variable) { return variable * -1.0; }
    
    // ConstraintExpression::Term multiply, divide, and unary invert
    inline ConstraintExpression::Term operator*(const ConstraintExpression::Term& term, const double coefficient) { return ConstraintExpression::Term(term.getVariable(), term.getCoefficient() * coefficient); }
    inline ConstraintExpression::Term operator/(const ConstraintExpression::Term& term, const double denominator) { return term * (1.0 / denominator); }
    inline ConstraintExpression::Term operator-(const ConstraintExpression::Term& term) { return term * -1.0; }
 
    // Expression multiply, divide, and unary invert
    inline ConstraintExpression operator*(const ConstraintExpression& expression, const double coefficient) {
        Vector<ConstraintExpression::Term> terms;
        terms.reserve(expression.getTerms().size());
 
        for(const ConstraintExpression::Term& term : expression.getTerms())
            terms.push_back(term * coefficient);
 
        return ConstraintExpression(std::move(terms), expression.getConstant() * coefficient);
    }
 
    inline ConstraintExpression operator/(const ConstraintExpression& expression, const double denominator) { return expression * (1.0 / denominator); }
    inline ConstraintExpression operator-(const ConstraintExpression& expression) { return expression * -1.0; }
 
    // Double multiply
    inline ConstraintExpression operator*(const double coefficient, const ConstraintExpression& expression) { return expression * coefficient; }
    inline ConstraintExpression::Term operator*(const double coefficient, const ConstraintExpression::Term& term) { return term * coefficient; }
    inline ConstraintExpression::Term operator*(const double coefficient, const ConstraintVariable& variable) { return variable * coefficient; }
 
    // Expression add and subtract
    inline ConstraintExpression operator+(const ConstraintExpression& first, const ConstraintExpression& second) {
        Vector<ConstraintExpression::Term> terms;
        terms.reserve(first.getTerms().size() + second.getTerms().size());
        terms.insert(terms.begin(), first.getTerms().begin(), first.getTerms().end());
        terms.insert(terms.end(), second.getTerms().begin(), second.getTerms().end());
        return ConstraintExpression(std::move(terms), first.getConstant() + second.getConstant());
    }
 
    inline ConstraintExpression operator+(const ConstraintExpression& first, const ConstraintExpression::Term& second) {
        Vector<ConstraintExpression::Term> terms;
        terms.reserve(first.getTerms().size() + 1);
        terms.insert(terms.begin(), first.getTerms().begin(), first.getTerms().end());
        terms.push_back(second);
        return ConstraintExpression(std::move(terms), first.getConstant());
    }
 
    inline ConstraintExpression operator+(const ConstraintExpression& expression, const ConstraintVariable& variable) { return expression + ConstraintExpression::Term(variable); }
    inline ConstraintExpression operator+(const ConstraintExpression& expression, const double constant) { return ConstraintExpression(expression.getTerms(), expression.getConstant() + constant); }
    inline ConstraintExpression operator-(const ConstraintExpression& first, const ConstraintExpression& second) { return first + -second; }
    inline ConstraintExpression operator-(const ConstraintExpression& expression, const ConstraintExpression::Term& term) { return expression + -term; }
    inline ConstraintExpression operator-(const ConstraintExpression& expression, const ConstraintVariable& variable) { return expression + -variable; }
    inline ConstraintExpression operator-(const ConstraintExpression& expression, const double constant) { return expression + -constant; }
 
    // ConstraintExpression::Term add and subtract
    inline ConstraintExpression operator+(const ConstraintExpression::Term& term, const ConstraintExpression& expression) { return expression + term; }
    inline ConstraintExpression operator+(const ConstraintExpression::Term& first, const ConstraintExpression::Term& second) { return ConstraintExpression({first, second}); }
    inline ConstraintExpression operator+(const ConstraintExpression::Term& term, const ConstraintVariable& variable) { return term + ConstraintExpression::Term(variable); }
    inline ConstraintExpression operator+(const ConstraintExpression::Term& term, const double constant) { return ConstraintExpression(term, constant); }
    inline ConstraintExpression operator-(const ConstraintExpression::Term& term, const ConstraintExpression& expression) { return -expression + term; }
    inline ConstraintExpression operator-(const ConstraintExpression::Term& first, const ConstraintExpression::Term& second) { return first + -second; }
    inline ConstraintExpression operator-(const ConstraintExpression::Term& term, const ConstraintVariable& variable) { return term + -variable; }
    inline ConstraintExpression operator-(const ConstraintExpression::Term& term, const double constant) { return term + -constant; }
 
    // Variable add and subtract
    inline ConstraintExpression operator+(const ConstraintVariable& variable, const ConstraintExpression& expression) { return expression + variable; }
    inline ConstraintExpression operator+(const ConstraintVariable& variable, const ConstraintExpression::Term& term) { return term + variable; }
    inline ConstraintExpression operator+(const ConstraintVariable& first, const ConstraintVariable& second) { return ConstraintExpression::Term(first) + second; }
    inline ConstraintExpression operator+(const ConstraintVariable& variable, const double constant) { return ConstraintExpression::Term(variable) + constant; }
    inline ConstraintExpression operator-(const ConstraintVariable& variable, const ConstraintExpression& expression) { return variable + -expression; }
    inline ConstraintExpression operator-(const ConstraintVariable& variable, const ConstraintExpression::Term& term) { return variable + -term; }
    inline ConstraintExpression operator-(const ConstraintVariable& first, const ConstraintVariable& second) { return first + -second; }
    inline ConstraintExpression operator-(const ConstraintVariable& variable, const double constant) { return variable + -constant; }
 
    // Double add and subtract
    inline ConstraintExpression operator+(const double constant, const ConstraintExpression& expression) { return expression + constant; }
    inline ConstraintExpression operator+(const double constant, const ConstraintExpression::Term& term) { return term + constant; }
    inline ConstraintExpression operator+(const double constant, const ConstraintVariable& variable) { return variable + constant; }
    inline ConstraintExpression operator-(const double constant, const ConstraintExpression& expression) { return -expression + constant; }
    inline ConstraintExpression operator-(const double constant, const ConstraintExpression::Term& term) { return -term + constant; }
    inline ConstraintExpression operator-(const double constant, const ConstraintVariable& variable) { return -variable + constant; }
 
    // Expression relations
    inline Constraint operator==(const ConstraintExpression& first, const ConstraintExpression& second) { return Constraint(first - second, ConstraintRelationalOperator::Equal); }
    inline Constraint operator==(const ConstraintExpression& expression, const ConstraintExpression::Term& term) { return expression == ConstraintExpression(term); }
    inline Constraint operator==(const ConstraintExpression& expression, const ConstraintVariable& variable) { return expression == ConstraintExpression::Term(variable); }
    inline Constraint operator==(const ConstraintExpression& expression, const double constant) { return expression == ConstraintExpression(constant); }
    inline Constraint operator<=(const ConstraintExpression& first, const ConstraintExpression& second) { return Constraint(first - second, ConstraintRelationalOperator::LessThanEqual); }
    inline Constraint operator<=(const ConstraintExpression& expression, const ConstraintExpression::Term& term) { return expression <= ConstraintExpression(term); }
    inline Constraint operator<=(const ConstraintExpression& expression, const ConstraintVariable& variable) { return expression <= ConstraintExpression::Term(variable); }
    inline Constraint operator<=(const ConstraintExpression& expression, const double constant) { return expression <= ConstraintExpression(constant); }
    inline Constraint operator>=(const ConstraintExpression& first, const ConstraintExpression& second) { return Constraint(first - second, ConstraintRelationalOperator::GreaterThanEqual); }
    inline Constraint operator>=(const ConstraintExpression& expression, const ConstraintExpression::Term& term) { return expression >= ConstraintExpression(term); }
    inline Constraint operator>=(const ConstraintExpression& expression, const ConstraintVariable& variable) { return expression >= ConstraintExpression::Term(variable); }
    inline Constraint operator>=(const ConstraintExpression& expression, const double constant) { return expression >= ConstraintExpression(constant); }
 
    // ConstraintExpression::Term relations
    inline Constraint operator==(const ConstraintExpression::Term& term, const ConstraintExpression& expression) { return expression == term; }
    inline Constraint operator==(const ConstraintExpression::Term& first, const ConstraintExpression::Term& second) { return ConstraintExpression(first) == second; }
    inline Constraint operator==(const ConstraintExpression::Term& term, const ConstraintVariable& variable) { return ConstraintExpression(term) == variable; }
    inline Constraint operator==(const ConstraintExpression::Term& term, const double constant) { return ConstraintExpression(term) == constant; }
    inline Constraint operator<=(const ConstraintExpression::Term& term, const ConstraintExpression& expression) { return expression >= term; }
    inline Constraint operator<=(const ConstraintExpression::Term& first, const ConstraintExpression::Term& second) { return ConstraintExpression(first) <= second; }
    inline Constraint operator<=(const ConstraintExpression::Term& term, const ConstraintVariable& variable) { return ConstraintExpression(term) <= variable; }
    inline Constraint operator<=(const ConstraintExpression::Term& term, const double constant) { return ConstraintExpression(term) <= constant; }
    inline Constraint operator>=(const ConstraintExpression::Term& term, const ConstraintExpression& expression) { return expression <= term; }
    inline Constraint operator>=(const ConstraintExpression::Term& first, const ConstraintExpression::Term& second) { return ConstraintExpression(first) >= second; }
    inline Constraint operator>=(const ConstraintExpression::Term& term, const ConstraintVariable& variable) { return ConstraintExpression(term) >= variable; }
    inline Constraint operator>=(const ConstraintExpression::Term& term, const double constant) { return ConstraintExpression(term) >= constant; }
 
    // Variable relations
    inline Constraint operator==(const ConstraintVariable& variable, const ConstraintExpression& expression) { return expression == variable; }
    inline Constraint operator==(const ConstraintVariable& variable, const ConstraintExpression::Term& term) { return term == variable; }
    inline Constraint operator==(const ConstraintVariable& first, const ConstraintVariable& second) { return ConstraintExpression::Term(first) == second; }
    inline Constraint operator==(const ConstraintVariable& variable, const double constant) { return ConstraintExpression::Term(variable) == constant; }
    inline Constraint operator<=(const ConstraintVariable& variable, const ConstraintExpression& expression) { return expression >= variable; }
    inline Constraint operator<=(const ConstraintVariable& variable, const ConstraintExpression::Term& term) { return term >= variable; }
    inline Constraint operator<=(const ConstraintVariable& first, const ConstraintVariable& second) { return ConstraintExpression::Term(first) <= second; }
    inline Constraint operator<=(const ConstraintVariable& variable, const double constant) { return ConstraintExpression::Term(variable) <= constant; }
    inline Constraint operator>=(const ConstraintVariable& variable, const ConstraintExpression& expression) { return expression <= variable; }
    inline Constraint operator>=(const ConstraintVariable& variable, const ConstraintExpression::Term& term) { return term <= variable; }
    inline Constraint operator>=(const ConstraintVariable& first, const ConstraintVariable& second) { return ConstraintExpression::Term(first) >= second; }
    inline Constraint operator>=(const ConstraintVariable& variable, const double constant) { return ConstraintExpression::Term(variable) >= constant; }
 
    // Double relations
    inline Constraint operator==(const double constant, const ConstraintExpression& expression) { return expression == constant; }
    inline Constraint operator==(const double constant, const ConstraintExpression::Term& term) { return term == constant; }
    inline Constraint operator==(const double constant, const ConstraintVariable& variable) { return variable == constant; }
    inline Constraint operator<=(const double constant, const ConstraintExpression& expression) { return expression >= constant; }
    inline Constraint operator<=(const double constant, const ConstraintExpression::Term& term) { return term >= constant; }
    inline Constraint operator<=(const double constant, const ConstraintVariable& variable) { return variable >= constant; }
    inline Constraint operator>=(const double constant, const ConstraintExpression& expression) { return expression <= constant; }
    inline Constraint operator>=(const double constant, const ConstraintExpression::Term& term) { return term <= constant; }
    inline Constraint operator>=(const double constant, const ConstraintVariable& variable) { return variable <= constant; }
 
    // Constraint strength modifier
    inline Constraint operator|(const Constraint& constraint, const ConstraintStrength& strength) { return Constraint(constraint, strength); }
    inline Constraint operator|(const ConstraintStrength& strength, const Constraint& constraint) { return constraint | strength; }
 
} // namespace CeresEngine::Constraint