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;
 
            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;
    }
}