FLScalar.h

#pragma once
 
#include "FLFigure.h"

namespace FLImaging
{
    namespace Foundation
    {
        template<typename T>
        class FL_EXPORT CFLScalar : public CFLFigure
        {
        public:
            T v;
 
            virtual void Clear() override;
 
 
            virtual bool IsValid() const override;
            virtual bool IsFigureValid() const override;
            virtual const CResult MakeFigureInvalid() override;
 
            using CFLFigure::IsSpecEqual;
            virtual bool IsSpecEqual(const CFLFigure* pFlfRhs, EFigureSpecCompareType eSpecType = EFigureSpecCompareType_Coordinates) const override;
 
            virtual EFigureDeclType GetDeclType() const override;
            virtual EFigureTemplateType GetTemplateType() const override;
 
            using CFLFigure::Offset;
            virtual const CResult Offset(double x, double y) override;
 
            using CFLFigure::Multiply;
            virtual const CResult Multiply(double f64MulX, double f64MulY) override;
 
            using CFLFigure::Swap;
            virtual const CResult Swap(CFLFigure* pFlfRight) override;
 
            using CFLFigure::GetMinimumDistance;
            using CFLFigure::GetMaximumDistance;
 
            using CFLFigure::GetPointsOfMinimumDistance;
            virtual const CResult GetPointsOfMinimumDistance(const CFLFigure* pFlfTarget, CFLPointArray* pFlpaResult) const override;
 
            using CFLFigure::GetPointsOfMaximumDistance;
            virtual const CResult GetPointsOfMaximumDistance(const CFLFigure* pFlfTarget, CFLPointArray* pFlpaResult) const override;
 
            using CFLFigure::GetIndexOfMinimumDistance;
            virtual const CResult GetIndexOfMinimumDistance(const CFLFigure* pFlfDst, CFLFigureArray* pFlfaResultSrc, bool bRecursiveSrc = false, bool bRecursiveDst = false, CFLFigureArray* pFlfaResultDst = nullptr) const override;
 
            using CFLFigure::GetIndexOfMaximumDistance;
            virtual const CResult GetIndexOfMaximumDistance(const CFLFigure* pFlfDst, CFLFigureArray* pFlfaResultSrc, bool bRecursiveSrc = false, bool bRecursiveDst = false, CFLFigureArray* pFlfaResultDst = nullptr) const override;

            virtual T GetScalar() const sealed;

            virtual const CResult Set(int32_t val);

            virtual const CResult Set(int64_t val);

            virtual const CResult Set(float val);

            virtual const CResult Set(double val);
 
            virtual const CResult Set(const CFLFigure& flf) override;
            virtual const CResult Set(const CFLFigure* pFlf) override;

            virtual const CResult Set(const CFLScalar<int32_t>& flp);

            virtual const CResult Set(const CFLScalar<int32_t>* pFlp);

            virtual const CResult Set(const CFLScalar<int64_t>& flp);

            virtual const CResult Set(const CFLScalar<int64_t>* pFlp);

            virtual const CResult Set(const CFLScalar<float>& flp);

            virtual const CResult Set(const CFLScalar<float>* pFlp);

            virtual const CResult Set(const CFLScalar<double>& flp);

            virtual const CResult Set(const CFLScalar<double>* pFlp);

            virtual const CResult Set(const CFLPoint<int32_t>& flp);

            virtual const CResult Set(const CFLPoint<int32_t>* pFlp);

            virtual const CResult Set(const CFLPoint<int64_t>& flp);

            virtual const CResult Set(const CFLPoint<int64_t>* pFlp);

            virtual const CResult Set(const CFLPoint<float>& flp);

            virtual const CResult Set(const CFLPoint<float>* pFlp);

            virtual const CResult Set(const CFLPoint<double>& flp);

            virtual const CResult Set(const CFLPoint<double>* pFlp);

            virtual const CResult Set(const CFLFigureText<int32_t>& flft);

            virtual const CResult Set(const CFLFigureText<int32_t>* pFlft);

            virtual const CResult Set(const CFLFigureText<int64_t>& flft);

            virtual const CResult Set(const CFLFigureText<int64_t>* pFlft);

            virtual const CResult Set(const CFLFigureText<float>& flft);

            virtual const CResult Set(const CFLFigureText<float>* pFlft);

            virtual const CResult Set(const CFLFigureText<double>& flft);

            virtual const CResult Set(const CFLFigureText<double>* pFlft);

            virtual const CResult Set(const CFLLine<int32_t>& fll);

            virtual const CResult Set(const CFLLine<int32_t>* pFll);

            virtual const CResult Set(const CFLLine<int64_t>& fll);

            virtual const CResult Set(const CFLLine<int64_t>* pFll);

            virtual const CResult Set(const CFLLine<float>& fll);

            virtual const CResult Set(const CFLLine<float>* pFll);

            virtual const CResult Set(const CFLLine<double>& fll);

            virtual const CResult Set(const CFLLine<double>* pFll);

            virtual const CResult Set(const CFLRect<int32_t>& flr);

            virtual const CResult Set(const CFLRect<int32_t>* pFlr);

            virtual const CResult Set(const CFLRect<int64_t>& flr);

            virtual const CResult Set(const CFLRect<int64_t>* pFlr);

            virtual const CResult Set(const CFLRect<float>& flr);

            virtual const CResult Set(const CFLRect<float>* pFlr);

            virtual const CResult Set(const CFLRect<double>& flr);

            virtual const CResult Set(const CFLRect<double>* pFlr);

            virtual const CResult Set(const CFLRoundRect<int32_t>& flrr);

            virtual const CResult Set(const CFLRoundRect<int32_t>* pFlrr);

            virtual const CResult Set(const CFLRoundRect<int64_t>& flrr);

            virtual const CResult Set(const CFLRoundRect<int64_t>* pFlrr);

            virtual const CResult Set(const CFLRoundRect<float>& flrr);

            virtual const CResult Set(const CFLRoundRect<float>* pFlrr);

            virtual const CResult Set(const CFLRoundRect<double>& flrr);

            virtual const CResult Set(const CFLRoundRect<double>* pFlrr);

            virtual const CResult Set(const CFLQuad<int32_t>& flq);

            virtual const CResult Set(const CFLQuad<int32_t>* pFlq);

            virtual const CResult Set(const CFLQuad<int64_t>& flq);

            virtual const CResult Set(const CFLQuad<int64_t>* pFlq);

            virtual const CResult Set(const CFLQuad<float>& flq);

            virtual const CResult Set(const CFLQuad<float>* pFlq);

            virtual const CResult Set(const CFLQuad<double>& flq);

            virtual const CResult Set(const CFLQuad<double>* pFlq);

            virtual const CResult Set(const CFLCircle<int32_t>& flc);

            virtual const CResult Set(const CFLCircle<int32_t>* pFlc);

            virtual const CResult Set(const CFLCircle<int64_t>& flc);

            virtual const CResult Set(const CFLCircle<int64_t>* pFlc);

            virtual const CResult Set(const CFLCircle<float>& flc);

            virtual const CResult Set(const CFLCircle<float>* pFlc);

            virtual const CResult Set(const CFLCircle<double>& flc);

            virtual const CResult Set(const CFLCircle<double>* pFlc);

            virtual const CResult Set(const CFLEllipse<int32_t>& fle);

            virtual const CResult Set(const CFLEllipse<int32_t>* pFle);

            virtual const CResult Set(const CFLEllipse<int64_t>& fle);

            virtual const CResult Set(const CFLEllipse<int64_t>* pFle);

            virtual const CResult Set(const CFLEllipse<float>& fle);

            virtual const CResult Set(const CFLEllipse<float>* pFle);

            virtual const CResult Set(const CFLEllipse<double>& fle);

            virtual const CResult Set(const CFLEllipse<double>* pFle);

            virtual const CResult Set(const CFLDoughnut<int32_t>& fld);

            virtual const CResult Set(const CFLDoughnut<int32_t>* pFld);

            virtual const CResult Set(const CFLDoughnut<int64_t>& fld);

            virtual const CResult Set(const CFLDoughnut<int64_t>* pFld);

            virtual const CResult Set(const CFLDoughnut<float>& fld);

            virtual const CResult Set(const CFLDoughnut<float>* pFld);

            virtual const CResult Set(const CFLDoughnut<double>& fld);

            virtual const CResult Set(const CFLDoughnut<double>* pFld);

            virtual const CResult Set(const CFLFigureArray& flfa);

            virtual const CResult Set(const CFLFigureArray* pFlfa);

            virtual const CResult Set(const CFLComplexRegion& flcr);

            virtual const CResult Set(const CFLComplexRegion* pFlcr);

            virtual const CResult Set(const CFLCubicSpline& flcs);

            virtual const CResult Set(const CFLCubicSpline* pFlcs);

            virtual const CResult Set(const CFLBezierQuadraticCurve& flbc2);

            virtual const CResult Set(const CFLBezierQuadraticCurve* pFlbc2);

            virtual const CResult Set(const CFLBezierCubicCurve& flbc3);

            virtual const CResult Set(const CFLBezierCubicCurve* pFlbc3);

            virtual const CResult Set(const CFLBezierQuarticCurve& flbc4);

            virtual const CResult Set(const CFLBezierQuarticCurve* pFlbc4);

            virtual const CResult Set(const CFLRegion& flrg);

            virtual const CResult Set(const CFLRegion* pFlrg);

            virtual const CResult Set(const CFLPointArray& flpa);

            virtual const CResult Set(const CFLPointArray* pFlpa);
 

            CFLScalar();

            virtual ~CFLScalar();

            CFLScalar(int32_t val);

            CFLScalar(int64_t val);

            CFLScalar(float val);

            CFLScalar(double val);

            CFLScalar(const CFLFigure& flf);

            CFLScalar(const CFLFigure* pFlf);

            CFLScalar(const CFLScalar<int32_t>& flp);

            CFLScalar(const CFLScalar<int32_t>* pFlp);

            CFLScalar(const CFLScalar<int64_t>& flp);

            CFLScalar(const CFLScalar<int64_t>* pFlp);

            CFLScalar(const CFLScalar<float>& flp);

            CFLScalar(const CFLScalar<float>* pFlp);

            CFLScalar(const CFLScalar<double>& flp);

            CFLScalar(const CFLScalar<double>* pFlp);
 
 
 
 
            operator int32_t() const;
            operator int64_t() const;
            operator float() const;
            operator double() const;

            // Assignment operator
 

            const CFLScalar<T>& operator=(int32_t val);

            const CFLScalar<T>& operator=(int64_t val);

            const CFLScalar<T>& operator=(float val);

            const CFLScalar<T>& operator=(double val);

            const CFLScalar<T>& operator=(const CFLScalar<int32_t>& val);

            const CFLScalar<T>& operator=(const CFLScalar<int64_t>& val);

            const CFLScalar<T>& operator=(const CFLScalar<float>& val);

            const CFLScalar<T>& operator=(const CFLScalar<double>& val);

            // Comparison operator

            bool operator==(int32_t val) const;

            bool operator==(int64_t val) const;

            bool operator==(float val) const;

            bool operator==(double val) const;

            bool operator==(const CFLScalar<int32_t>& val) const;

            bool operator==(const CFLScalar<int64_t>& val) const;

            bool operator==(const CFLScalar<float>& val) const;

            bool operator==(const CFLScalar<double>& val) const;

            bool operator!=(int32_t val) const;

            bool operator!=(int64_t val) const;

            bool operator!=(float val) const;

            bool operator!=(double val) const;

            bool operator!=(const CFLScalar<int32_t>& val) const;

            bool operator!=(const CFLScalar<int64_t>& val) const;

            bool operator!=(const CFLScalar<float>& val) const;

            bool operator!=(const CFLScalar<double>& val) const;

            bool operator>(int32_t val) const;

            bool operator>(int64_t val) const;

            bool operator>(float val) const;

            bool operator>(double val) const;

            bool operator>(const CFLScalar<int32_t>& val) const;

            bool operator>(const CFLScalar<int64_t>& val) const;

            bool operator>(const CFLScalar<float>& val) const;

            bool operator>(const CFLScalar<double>& val) const;

            bool operator>=(int32_t val) const;

            bool operator>=(int64_t val) const;

            bool operator>=(float val) const;

            bool operator>=(double val) const;

            bool operator>=(const CFLScalar<int32_t>& val) const;

            bool operator>=(const CFLScalar<int64_t>& val) const;

            bool operator>=(const CFLScalar<float>& val) const;

            bool operator>=(const CFLScalar<double>& val) const;

            bool operator<(int32_t val) const;

            bool operator<(int64_t val) const;

            bool operator<(float val) const;

            bool operator<(double val) const;

            bool operator<(const CFLScalar<int32_t>& val) const;

            bool operator<(const CFLScalar<int64_t>& val) const;

            bool operator<(const CFLScalar<float>& val) const;

            bool operator<(const CFLScalar<double>& val) const;

            bool operator<=(int32_t val) const;

            bool operator<=(int64_t val) const;

            bool operator<=(float val) const;

            bool operator<=(double val) const;

            bool operator<=(const CFLScalar<int32_t>& val) const;

            bool operator<=(const CFLScalar<int64_t>& val) const;

            bool operator<=(const CFLScalar<float>& val) const;

            bool operator<=(const CFLScalar<double>& val) const;

            // Arithmetic and assignment operator

            const CFLScalar<T>& operator+=(int32_t value);

            const CFLScalar<T>& operator+=(int64_t value);

            const CFLScalar<T>& operator+=(float value);

            const CFLScalar<T>& operator+=(double value);

            const CFLScalar<T>& operator+=(const CFLScalar<int32_t>& value);

            const CFLScalar<T>& operator+=(const CFLScalar<int64_t>& value);

            const CFLScalar<T>& operator+=(const CFLScalar<float>& value);

            const CFLScalar<T>& operator+=(const CFLScalar<double>& value);

            const CFLScalar<T>& operator-=(int32_t value);

            const CFLScalar<T>& operator-=(int64_t value);

            const CFLScalar<T>& operator-=(float value);

            const CFLScalar<T>& operator-=(double value);

            const CFLScalar<T>& operator-=(const CFLScalar<int32_t>& value);

            const CFLScalar<T>& operator-=(const CFLScalar<int64_t>& value);

            const CFLScalar<T>& operator-=(const CFLScalar<float>& value);

            const CFLScalar<T>& operator-=(const CFLScalar<double>& value);

            const CFLScalar<T>& operator*=(int32_t value);

            const CFLScalar<T>& operator*=(int64_t value);

            const CFLScalar<T>& operator*=(float value);

            const CFLScalar<T>& operator*=(double value);

            const CFLScalar<T>& operator*=(const CFLScalar<int32_t>& value);

            const CFLScalar<T>& operator*=(const CFLScalar<int64_t>& value);

            const CFLScalar<T>& operator*=(const CFLScalar<float>& value);

            const CFLScalar<T>& operator*=(const CFLScalar<double>& value);

            const CFLScalar<T>& operator/=(int32_t value);

            const CFLScalar<T>& operator/=(int64_t value);

            const CFLScalar<T>& operator/=(float value);

            const CFLScalar<T>& operator/=(double value);

            const CFLScalar<T>& operator/=(const CFLScalar<int32_t>& value);

            const CFLScalar<T>& operator/=(const CFLScalar<int64_t>& value);

            const CFLScalar<T>& operator/=(const CFLScalar<float>& value);

            const CFLScalar<T>& operator/=(const CFLScalar<double>& value);


            // Arithmetic operator

            CFLScalar<T> operator+(int32_t value) const;

            CFLScalar<T> operator+(int64_t value) const;

            CFLScalar<T> operator+(float value) const;

            CFLScalar<T> operator+(double value) const;

            CFLScalar<T> operator+(const CFLScalar<int32_t>& value) const;

            CFLScalar<T> operator+(const CFLScalar<int64_t>& value) const;

            CFLScalar<T> operator+(const CFLScalar<float>& value) const;

            CFLScalar<T> operator+(const CFLScalar<double>& value) const;

            CFLScalar<T> operator-(int32_t value) const;

            CFLScalar<T> operator-(int64_t value) const;

            CFLScalar<T> operator-(float value) const;

            CFLScalar<T> operator-(double value) const;

            CFLScalar<T> operator-(const CFLScalar<int32_t>& value) const;

            CFLScalar<T> operator-(const CFLScalar<int64_t>& value) const;

            CFLScalar<T> operator-(const CFLScalar<float>& value) const;

            CFLScalar<T> operator-(const CFLScalar<double>& value) const;

            CFLScalar<T> operator*(int32_t value) const;

            CFLScalar<T> operator*(int64_t value) const;

            CFLScalar<T> operator*(float value) const;

            CFLScalar<T> operator*(double value) const;

            CFLScalar<T> operator*(const CFLScalar<int32_t>& value) const;

            CFLScalar<T> operator*(const CFLScalar<int64_t>& value) const;

            CFLScalar<T> operator*(const CFLScalar<float>& value) const;

            CFLScalar<T> operator*(const CFLScalar<double>& value) const;

            CFLScalar<T> operator/(int32_t value) const;

            CFLScalar<T> operator/(int64_t value) const;

            CFLScalar<T> operator/(float value) const;

            CFLScalar<T> operator/(double value) const;

            CFLScalar<T> operator/(const CFLScalar<int32_t>& value) const;

            CFLScalar<T> operator/(const CFLScalar<int64_t>& value) const;

            CFLScalar<T> operator/(const CFLScalar<float>& value) const;

            CFLScalar<T> operator/(const CFLScalar<double>& value) const;

 
            //friend 연산자
            // Comparison operator

            friend bool operator==(int32_t val, const CFLScalar<T>& scalar)
            {
                return val == scalar.v;
            }

            friend bool operator==(int64_t val, const CFLScalar<T>& scalar)
            {
                return val == scalar.v;
            }

            friend bool operator==(float val, const CFLScalar<T>& scalar)
            {
                return val == scalar.v;
            }

            friend bool operator==(double val, const CFLScalar<T>& scalar)
            {
                return val == scalar.v;
            }

            friend bool operator!=(int32_t val, const CFLScalar<T>& scalar)
            {
                return val != scalar.v;
            }

            friend bool operator!=(int64_t val, const CFLScalar<T>& scalar)
            {
                return val != scalar.v;
            }

            friend bool operator!=(float val, const CFLScalar<T>& scalar)
            {
                return val != scalar.v;
            }

            friend bool operator!=(double val, const CFLScalar<T>& scalar)
            {
                return val != scalar.v;
            }

            friend bool operator>(int32_t val, const CFLScalar<T>& scalar)
            {
                return val > scalar.v;
            }

            friend bool operator>(int64_t val, const CFLScalar<T>& scalar)
            {
                return val > scalar.v;
            }

            friend bool operator>(float val, const CFLScalar<T>& scalar)
            {
                return val > scalar.v;
            }

            friend bool operator>(double val, const CFLScalar<T>& scalar)
            {
                return val > scalar.v;
            }

            friend bool operator>=(int32_t val, const CFLScalar<T>& scalar)
            {
                return val >= scalar.v;
            }

            friend bool operator>=(int64_t val, const CFLScalar<T>& scalar)
            {
                return val >= scalar.v;
            }

            friend bool operator>=(float val, const CFLScalar<T>& scalar)
            {
                return val >= scalar.v;
            }

            friend bool operator>=(double val, const CFLScalar<T>& scalar)
            {
                return val >= scalar.v;
            }

            friend bool operator<(int32_t val, const CFLScalar<T>& scalar)
            {
                return val < scalar.v;
            }

            friend bool operator<(int64_t val, const CFLScalar<T>& scalar)
            {
                return val < scalar.v;
            }

            friend bool operator<(float val, const CFLScalar<T>& scalar)
            {
                return val < scalar.v;
            }

            friend bool operator<(double val, const CFLScalar<T>& scalar)
            {
                return val < scalar.v;
            }

            friend bool operator<=(int32_t val, const CFLScalar<T>& scalar)
            {
                return val <= scalar.v;
            }

            friend bool operator<=(int64_t val, const CFLScalar<T>& scalar)
            {
                return val <= scalar.v;
            }

            friend bool operator<=(float val, const CFLScalar<T>& scalar)
            {
                return val <= scalar.v;
            }

            friend bool operator<=(double val, const CFLScalar<T>& scalar)
            {
                return val <= scalar.v;
            }

            // Arithmetic operator
            friend CFLScalar<T> operator+(int32_t value, const CFLScalar<T>& scalar)
            {
                CFLScalar<T> t(value);
                t += (T)scalar;
                return t;
            }

            friend CFLScalar<T> operator+(int64_t value, const CFLScalar<T>& scalar)
            {
                CFLScalar<T> t(value);
                t += (T)scalar;
                return t;
            }

            friend CFLScalar<T> operator+(float value, const CFLScalar<T>& scalar)
            {
                CFLScalar<T> t(value);
                t += (T)scalar;
                return t;
            }

            friend CFLScalar<T> operator+(double value, const CFLScalar<T>& scalar)
            {
                CFLScalar<T> t(value);
                t += (T)scalar;
                return t;
            }

            friend CFLScalar<T> operator-(int32_t value, const CFLScalar<T>& scalar)
            {
                CFLScalar<T> t(value);
                t -= (T)scalar;
                return t;
            }

            friend CFLScalar<T> operator-(int64_t value, const CFLScalar<T>& scalar)
            {
                CFLScalar<T> t(value);
                t -= (T)scalar;
                return t;
            }

            friend CFLScalar<T> operator-(float value, const CFLScalar<T>& scalar)
            {
                CFLScalar<T> t(value);
                t -= (T)scalar;
                return t;
            }

            friend CFLScalar<T> operator-(double value, const CFLScalar<T>& scalar)
            {
                CFLScalar<T> t(value);
                t -= (T)scalar;
                return t;
            }

            friend CFLScalar<T> operator*(int32_t value, const CFLScalar<T>& scalar)
            {
                CFLScalar<T> t(value);
                t *= (T)scalar;
                return t;
            }

            friend CFLScalar<T> operator*(int64_t value, const CFLScalar<T>& scalar)
            {
                CFLScalar<T> t(value);
                t *= (T)scalar;
                return t;
            }

            friend CFLScalar<T> operator*(float value, const CFLScalar<T>& scalar)
            {
                CFLScalar<T> t(value);
                t *= (T)scalar;
                return t;
            }

            friend CFLScalar<T> operator*(double value, const CFLScalar<T>& scalar)
            {
                CFLScalar<T> t(value);
                t *= (T)scalar;
                return t;
            }

            friend CFLScalar<T> operator/(int32_t value, const CFLScalar<T>& scalar)
            {
                CFLScalar<T> t(value);
                t /= (T)scalar;
                return t;
            }

            friend CFLScalar<T> operator/(int64_t value, const CFLScalar<T>& scalar)
            {
                CFLScalar<T> t(value);
                t /= (T)scalar;
                return t;
            }

            friend CFLScalar<T> operator/(float value, const CFLScalar<T>& scalar)
            {
                CFLScalar<T> t(value);
                t /= (T)scalar;
                return t;
            }

            friend CFLScalar<T> operator/(double value, const CFLScalar<T>& scalar)
            {
                CFLScalar<T> t(value);
                t /= (T)scalar;
                return t;
            }
 
 
            SupportToDuplicateObject(CFLScalar<T>, *this);
            DeclareGetClassType();
        };
 
        typedef CFLScalar<int32_t> CFLScalarL;
        typedef CFLScalar<int64_t> CFLScalarLL;
        typedef CFLScalar<float> CFLScalarF;
        typedef CFLScalar<double> CFLScalarD;
    }
}