ConstraintVariable.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 "CeresEngine/Foundation/SmartPtr.hpp"
#include "CeresEngine/Foundation/String.hpp"
#include "CeresEngine/Foundation/Any.hpp"
 
#include <memory>
#include <string>
 
namespace CeresEngine::Constraint {
 
    class ConstraintVariable final {
    private:
        class Data;
 
        RC<Data> mData;
 
    public:
        explicit ConstraintVariable(String name, Any&& context = Any()) : mData(new Data(std::move(name), std::move(context))) {}
 
        ConstraintVariable(const ConstraintVariable&) = default;
        ConstraintVariable& operator=(const ConstraintVariable&) = default;
 
        ConstraintVariable(ConstraintVariable&&) noexcept = default;
        ConstraintVariable& operator=(ConstraintVariable&&) noexcept = default;
 
        ~ConstraintVariable() = default;
 
    public:
        [[nodiscard]] const String& getName() const { return mData->name; }
 
        [[nodiscard]] Any& getContext() const { return mData->context; }
        void setContext(Any&& context) { mData->context = std::move(context); }
 
        [[nodiscard]] double getValue() const { return mData->value; }
        void setValue(const double value) { mData->value = value; }
 
        // operator== is used for symbolics
        [[nodiscard]] bool equals(const ConstraintVariable& other) { return mData == other.mData; }
 
    public:
        [[nodiscard]] String toString() const;
 
        friend std::ostream& operator<<(std::ostream& stream, const ConstraintVariable& variable);
 
    private:
        class Data final : public RefCounted<Data, RefCounter<false>> {
        public:
            String name;
            Any context;
            double value;
 
        public:
            explicit Data(String name, Any&& context) : name(std::move(name)), context(std::move(context)), value(0.0) {}
            explicit Data(const char* name, Any&& context) : name(name), context(std::move(context)), value(0.0) {}
 
            Data(const Data& other) = delete;
            Data& operator=(const Data& other) = delete;
 
            ~Data() = default;
        };
 
        friend bool operator<(const ConstraintVariable& lhs, const ConstraintVariable& rhs) { return lhs.mData.get() < rhs.mData.get(); }
    };
 
} // namespace CeresEngine::Constraint