TRect.h

#pragma once

 
#include <stdint.h>
#include <type_traits>
#include <typeinfo>
 
#include "FLLibTags.h"

namespace FLImaging
{
    namespace Base
    {
        #pragma pack(push, 1)
        template <typename T>
        class FL_EXPORT TRect
        {
        public:
            T left;

            T top;

            T right;

            T bottom;
 
            
            TRect()
            {
            }

            TRect(const TRect<int8_t>& tr) : left((T)tr.left), top((T)tr.top), right((T)tr.right), bottom((T)tr.bottom)
            {
            }

            TRect(const TRect<int8_t>* pTr) : left((T)pTr->left), top((T)pTr->top), right((T)pTr->right), bottom((T)pTr->bottom)
            {
            }
            
            TRect(const TRect<uint8_t>& tr) : left((T)tr.left), top((T)tr.top), right((T)tr.right), bottom((T)tr.bottom)
            {
            }
            
            TRect(const TRect<uint8_t>* pTr) : left((T)pTr->left), top((T)pTr->top), right((T)pTr->right), bottom((T)pTr->bottom)
            {
            }
            
            TRect(const TRect<int16_t>& tr) : left((T)tr.left), top((T)tr.top), right((T)tr.right), bottom((T)tr.bottom)
            {
            }
            
            TRect(const TRect<int16_t>* pTr) : left((T)pTr->left), top((T)pTr->top), right((T)pTr->right), bottom((T)pTr->bottom)
            {
            }
            
            TRect(const TRect<uint16_t>& tr) : left((T)tr.left), top((T)tr.top), right((T)tr.right), bottom((T)tr.bottom)
            {
            }
            
            TRect(const TRect<uint16_t>* pTr) : left((T)pTr->left), top((T)pTr->top), right((T)pTr->right), bottom((T)pTr->bottom)
            {
            }
            
            TRect(const TRect<int32_t>& tr) : left((T)tr.left), top((T)tr.top), right((T)tr.right), bottom((T)tr.bottom)
            {
            }
            
            TRect(const TRect<int32_t>* pTr) : left((T)pTr->left), top((T)pTr->top), right((T)pTr->right), bottom((T)pTr->bottom)
            {
            }
            
            TRect(const TRect<uint32_t>& tr) : left((T)tr.left), top((T)tr.top), right((T)tr.right), bottom((T)tr.bottom)
            {
            }
            
            TRect(const TRect<uint32_t>* pTr) : left((T)pTr->left), top((T)pTr->top), right((T)pTr->right), bottom((T)pTr->bottom)
            {
            }
            
            TRect(const TRect<int64_t>& tr) : left((T)tr.left), top((T)tr.top), right((T)tr.right), bottom((T)tr.bottom)
            {
            }
            
            TRect(const TRect<int64_t>* pTr) : left((T)pTr->left), top((T)pTr->top), right((T)pTr->right), bottom((T)pTr->bottom)
            {
            }
            
            TRect(const TRect<uint64_t>& tr) : left((T)tr.left), top((T)tr.top), right((T)tr.right), bottom((T)tr.bottom)
            {
            }

            TRect(const TRect<uint64_t>* pTr) : left((T)pTr->left), top((T)pTr->top), right((T)pTr->right), bottom((T)pTr->bottom)
            {
            }

            TRect(const TRect<float>& tr) : left((T)tr.left), top((T)tr.top), right((T)tr.right), bottom((T)tr.bottom)
            {
            }

            TRect(const TRect<float>* pTr) : left((T)pTr->left), top((T)pTr->top), right((T)pTr->right), bottom((T)pTr->bottom)
            {
            }
            
            TRect(const TRect<double>& tr) : left((T)tr.left), top((T)tr.top), right((T)tr.right), bottom((T)tr.bottom)
            {
            }
            
            TRect(const TRect<double>* pTr) : left((T)pTr->left), top((T)pTr->top), right((T)pTr->right), bottom((T)pTr->bottom)
            {
            }
            
            TRect(int8_t left, int8_t top, int8_t right, int8_t bottom) : left((T)left), top((T)top), right((T)right), bottom((T)bottom)
            {
            }

            TRect(uint8_t left, uint8_t top, uint8_t right, uint8_t bottom) : left((T)left), top((T)top), right((T)right), bottom((T)bottom)
            {
            }

            TRect(int16_t left, int16_t top, int16_t right, int16_t bottom) : left((T)left), top((T)top), right((T)right), bottom((T)bottom)
            {
            }

            TRect(uint16_t left, uint16_t top, uint16_t right, uint16_t bottom) : left((T)left), top((T)top), right((T)right), bottom((T)bottom)
            {
            }

            TRect(int32_t left, int32_t top, int32_t right, int32_t bottom) : left((T)left), top((T)top), right((T)right), bottom((T)bottom)
            {
            }

            TRect(uint32_t left, uint32_t top, uint32_t right, uint32_t bottom) : left((T)left), top((T)top), right((T)right), bottom((T)bottom)
            {
            }

            TRect(int64_t left, int64_t top, int64_t right, int64_t bottom) : left((T)left), top((T)top), right((T)right), bottom((T)bottom)
            {
            }

            TRect(uint64_t left, uint64_t top, uint64_t right, uint64_t bottom) : left((T)left), top((T)top), right((T)right), bottom((T)bottom)
            {
            }

            TRect(float left, float top, float right, float bottom) : left((T)left), top((T)top), right((T)right), bottom((T)bottom)
            {
            }

            TRect(double left, double top, double right, double bottom) : left((T)left), top((T)top), right((T)right), bottom((T)bottom)
            {
            }
            
            void Set(const TRect<int8_t>& tr)
            {
                this->left = (T)tr.left;
                this->top = (T)tr.top;
                this->right = (T)tr.right;
                this->bottom = (T)tr.bottom;
            }

            void Set(const TRect<int8_t>* pTr)
            {
                this->left = (T)pTr->left;
                this->top = (T)pTr->top;
                this->right = (T)pTr->right;
                this->bottom = (T)pTr->bottom;
            }
            
            void Set(const TRect<uint8_t>& tr)
            {
                this->left = (T)tr.left;
                this->top = (T)tr.top;
                this->right = (T)tr.right;
                this->bottom = (T)tr.bottom;
            }
            
            void Set(const TRect<uint8_t>* pTr)
            {
                this->left = (T)pTr->left;
                this->top = (T)pTr->top;
                this->right = (T)pTr->right;
                this->bottom = (T)pTr->bottom;
            }
            
            void Set(const TRect<int16_t>& tr)
            {
                this->left = (T)tr.left;
                this->top = (T)tr.top;
                this->right = (T)tr.right;
                this->bottom = (T)tr.bottom;
            }
            
            void Set(const TRect<int16_t>* pTr)
            {
                this->left = (T)pTr->left;
                this->top = (T)pTr->top;
                this->right = (T)pTr->right;
                this->bottom = (T)pTr->bottom;
            }
            
            void Set(const TRect<uint16_t>& tr)
            {
                this->left = (T)tr.left;
                this->top = (T)tr.top;
                this->right = (T)tr.right;
                this->bottom = (T)tr.bottom;
            }
            
            void Set(const TRect<uint16_t>* pTr)
            {
                this->left = (T)pTr->left;
                this->top = (T)pTr->top;
                this->right = (T)pTr->right;
                this->bottom = (T)pTr->bottom;
            }
            
            void Set(const TRect<int32_t>& tr)
            {
                this->left = (T)tr.left;
                this->top = (T)tr.top;
                this->right = (T)tr.right;
                this->bottom = (T)tr.bottom;
            }
            
            void Set(const TRect<int32_t>* pTr)
            {
                this->left = (T)pTr->left;
                this->top = (T)pTr->top;
                this->right = (T)pTr->right;
                this->bottom = (T)pTr->bottom;
            }

            void Set(const TRect<uint32_t>& tr)
            {
                this->left = (T)tr.left;
                this->top = (T)tr.top;
                this->right = (T)tr.right;
                this->bottom = (T)tr.bottom;
            }

            void Set(const TRect<uint32_t>* pTr)
            {
                this->left = (T)pTr->left;
                this->top = (T)pTr->top;
                this->right = (T)pTr->right;
                this->bottom = (T)pTr->bottom;
            }
            
            void Set(const TRect<int64_t>& tr)
            {
                this->left = (T)tr.left;
                this->top = (T)tr.top;
                this->right = (T)tr.right;
                this->bottom = (T)tr.bottom;
            }
            
            void Set(const TRect<int64_t>* pTr)
            {
                this->left = (T)pTr->left;
                this->top = (T)pTr->top;
                this->right = (T)pTr->right;
                this->bottom = (T)pTr->bottom;
            }
            
            void Set(const TRect<uint64_t>& tr)
            {
                this->left = (T)tr.left;
                this->top = (T)tr.top;
                this->right = (T)tr.right;
                this->bottom = (T)tr.bottom;
            }
            
            void Set(const TRect<uint64_t>* pTr)
            {
                this->left = (T)pTr->left;
                this->top = (T)pTr->top;
                this->right = (T)pTr->right;
                this->bottom = (T)pTr->bottom;
            }
            
            void Set(const TRect<float>& tr)
            {
                this->left = (T)tr.left;
                this->top = (T)tr.top;
                this->right = (T)tr.right;
                this->bottom = (T)tr.bottom;
            }
            
            void Set(const TRect<float>* pTr)
            {
                this->left = (T)pTr->left;
                this->top = (T)pTr->top;
                this->right = (T)pTr->right;
                this->bottom = (T)pTr->bottom;
            }
            
            void Set(const TRect<double>& tr)
            {
                this->left = (T)tr.left;
                this->top = (T)tr.top;
                this->right = (T)tr.right;
                this->bottom = (T)tr.bottom;
            }
            
            void Set(const TRect<double>* pTr)
            {
                this->left = (T)pTr->left;
                this->top = (T)pTr->top;
                this->right = (T)pTr->right;
                this->bottom = (T)pTr->bottom;
            }
            
            void Set(int8_t left, int8_t top, int8_t right, int8_t bottom)
            {
                this->left = (T)left;
                this->top = (T)top;
                this->right = (T)right;
                this->bottom = (T)bottom;
            }

            void Set(uint8_t left, uint8_t top, uint8_t right, uint8_t bottom)
            {
                this->left = (T)left;
                this->top = (T)top;
                this->right = (T)right;
                this->bottom = (T)bottom;
            }

            void Set(int16_t left, int16_t top, int16_t right, int16_t bottom)
            {
                this->left = (T)left;
                this->top = (T)top;
                this->right = (T)right;
                this->bottom = (T)bottom;
            }

            void Set(uint16_t left, uint16_t top, uint16_t right, uint16_t bottom)
            {
                this->left = (T)left;
                this->top = (T)top;
                this->right = (T)right;
                this->bottom = (T)bottom;
            }

            void Set(int32_t left, int32_t top, int32_t right, int32_t bottom)
            {
                this->left = (T)left;
                this->top = (T)top;
                this->right = (T)right;
                this->bottom = (T)bottom;
            }

            void Set(uint32_t left, uint32_t top, uint32_t right, uint32_t bottom)
            {
                this->left = (T)left;
                this->top = (T)top;
                this->right = (T)right;
                this->bottom = (T)bottom;
            }

            void Set(int64_t left, int64_t top, int64_t right, int64_t bottom)
            {
                this->left = (T)left;
                this->top = (T)top;
                this->right = (T)right;
                this->bottom = (T)bottom;
            }

            void Set(uint64_t left, uint64_t top, uint64_t right, uint64_t bottom)
            {
                this->left = (T)left;
                this->top = (T)top;
                this->right = (T)right;
                this->bottom = (T)bottom;
            }

            void Set(float left, float top, float right, float bottom)
            {
                this->left = (T)left;
                this->top = (T)top;
                this->right = (T)right;
                this->bottom = (T)bottom;
            }

            void Set(double left, double top, double right, double bottom)
            {
                this->left = (T)left;
                this->top = (T)top;
                this->right = (T)right;
                this->bottom = (T)bottom;
            }

            const TRect<T>& operator=(int32_t value)
            {
                left = top = right = bottom = (T)value;
 
                return *this;
            }

            const TRect<T>& operator=(int64_t value)
            {
                left = top = right = bottom = (T)value;
 
                return *this;
            }

            const TRect<T>& operator=(float value)
            {
                left = top = right = bottom = (T)value;
 
                return *this;
            }

            const TRect<T>& operator=(double value)
            {
                left = top = right = bottom = (T)value;
 
                return *this;
            }
            
            const TRect<T>& operator=(const TRect<int32_t>& tr)
            {
                left = (T)tr.left;
                top = (T)tr.top;
                right = (T)tr.right;
                bottom = (T)tr.bottom;
 
                return *this;
            }

            const TRect<T>& operator=(const TRect<int64_t>& tr)
            {
                left = (T)tr.left;
                top = (T)tr.top;
                right = (T)tr.right;
                bottom = (T)tr.bottom;
 
                return *this;
            }

            const TRect<T>& operator=(const TRect<float>& tr)
            {
                left = (T)tr.left;
                top = (T)tr.top;
                right = (T)tr.right;
                bottom = (T)tr.bottom;
 
                return *this;
            }

            const TRect<T>& operator=(const TRect<double>& tr)
            {
                left = (T)tr.left;
                top = (T)tr.top;
                right = (T)tr.right;
                bottom = (T)tr.bottom;
 
                return *this;
            }
            
            bool operator==(const TRect<int32_t>& tr)
            {
                return left == (T)tr.left && top == (T)tr.top && right == (T)tr.right && bottom == (T)tr.bottom;
            }

            bool operator==(const TRect<int64_t>& tr)
            {
                return left == (T)tr.left && top == (T)tr.top && right == (T)tr.right && bottom == (T)tr.bottom;
            }

            bool operator==(const TRect<float>& tr)
            {
                return left == (T)tr.left && top == (T)tr.top && right == (T)tr.right && bottom == (T)tr.bottom;
            }

            bool operator==(const TRect<double>& tr)
            {
                return left == (T)tr.left && top == (T)tr.top && right == (T)tr.right && bottom == (T)tr.bottom;
            }
            
            bool operator!=(const TRect<int32_t>& tr)
            {
                return left != (T)tr.left || top != (T)tr.top || right != (T)tr.right || bottom != (T)tr.bottom;
            }

            bool operator!=(const TRect<int64_t>& tr)
            {
                return left != (T)tr.left || top != (T)tr.top || right != (T)tr.right || bottom != (T)tr.bottom;
            }

            bool operator!=(const TRect<float>& tr)
            {
                return left != (T)tr.left || top != (T)tr.top || right != (T)tr.right || bottom != (T)tr.bottom;
            }

            bool operator!=(const TRect<double>& tr)
            {
                return left != (T)tr.left || top != (T)tr.top || right != (T)tr.right || bottom != (T)tr.bottom;
            }

            const TRect<T>& operator+=(int32_t value)
            {
                left += (T)value;
                top += (T)value;
                right += (T)value;
                bottom += (T)value;
 
                return *this;
            }

            const TRect<T>& operator+=(int64_t value)
            {
                left += (T)value;
                top += (T)value;
                right += (T)value;
                bottom += (T)value;
 
                return *this;
            }

            const TRect<T>& operator+=(float value)
            {
                left += (T)value;
                top += (T)value;
                right += (T)value;
                bottom += (T)value;
 
                return *this;
            }

            const TRect<T>& operator+=(double value)
            {
                left += (T)value;
                top += (T)value;
                right += (T)value;
                bottom += (T)value;
 
                return *this;
            }
            
            const TRect<T>& operator+=(const TRect<int32_t>& tr)
            {
                left += (T)tr.left;
                top += (T)tr.top;
                right += (T)tr.right;
                bottom += (T)tr.bottom;
 
                return *this;
            }

            const TRect<T>& operator+=(const TRect<int64_t>& tr)
            {
                left += (T)tr.left;
                top += (T)tr.top;
                right += (T)tr.right;
                bottom += (T)tr.bottom;
 
                return *this;
            }

            const TRect<T>& operator+=(const TRect<float>& tr)
            {
                left += (T)tr.left;
                top += (T)tr.top;
                right += (T)tr.right;
                bottom += (T)tr.bottom;
 
                return *this;
            }

            const TRect<T>& operator+=(const TRect<double>& tr)
            {
                left += (T)tr.left;
                top += (T)tr.top;
                right += (T)tr.right;
                bottom += (T)tr.bottom;
 
                return *this;
            }

            const TRect<T>& operator-=(int32_t value)
            {
                left -= (T)value;
                top -= (T)value;
                right -= (T)value;
                bottom -= (T)value;
 
                return *this;
            }

            const TRect<T>& operator-=(int64_t value)
            {
                left -= (T)value;
                top -= (T)value;
                right -= (T)value;
                bottom -= (T)value;
 
                return *this;
            }

            const TRect<T>& operator-=(float value)
            {
                left -= (T)value;
                top -= (T)value;
                right -= (T)value;
                bottom -= (T)value;
 
                return *this;
            }

            const TRect<T>& operator-=(double value)
            {
                left -= (T)value;
                top -= (T)value;
                right -= (T)value;
                bottom -= (T)value;
 
                return *this;
            }
            
            const TRect<T>& operator-=(const TRect<int32_t>& tr)
            {
                left -= (T)tr.left;
                top -= (T)tr.top;
                right -= (T)tr.right;
                bottom -= (T)tr.bottom;
 
                return *this;
            }

            const TRect<T>& operator-=(const TRect<int64_t>& tr)
            {
                left -= (T)tr.left;
                top -= (T)tr.top;
                right -= (T)tr.right;
                bottom -= (T)tr.bottom;
 
                return *this;
            }

            const TRect<T>& operator-=(const TRect<float>& tr)
            {
                left -= (T)tr.left;
                top -= (T)tr.top;
                right -= (T)tr.right;
                bottom -= (T)tr.bottom;
 
                return *this;
            }

            const TRect<T>& operator-=(const TRect<double>& tr)
            {
                left -= (T)tr.left;
                top -= (T)tr.top;
                right -= (T)tr.right;
                bottom -= (T)tr.bottom;
 
                return *this;
            }
            
            const TRect<T>& operator*=(int32_t value)
            {
                left *= (T)value;
                top *= (T)value;
                right *= (T)value;
                bottom *= (T)value;
 
                return *this;
            }

            const TRect<T>& operator*=(int64_t value)
            {
                left *= (T)value;
                top *= (T)value;
                right *= (T)value;
                bottom *= (T)value;
 
                return *this;
            }

            const TRect<T>& operator*=(float value)
            {
                left *= (T)value;
                top *= (T)value;
                right *= (T)value;
                bottom *= (T)value;
 
                return *this;
            }

            const TRect<T>& operator*=(double value)
            {
                left *= (T)value;
                top *= (T)value;
                right *= (T)value;
                bottom *= (T)value;
 
                return *this;
            }
            
            const TRect<T>& operator*=(const TRect<int32_t>& tr)
            {
                left *= (T)tr.left;
                top *= (T)tr.top;
                right *= (T)tr.right;
                bottom *= (T)tr.bottom;
 
                return *this;
            }

            const TRect<T>& operator*=(const TRect<int64_t>& tr)
            {
                left *= (T)tr.left;
                top *= (T)tr.top;
                right *= (T)tr.right;
                bottom *= (T)tr.bottom;
 
                return *this;
            }

            const TRect<T>& operator*=(const TRect<float>& tr)
            {
                left *= (T)tr.left;
                top *= (T)tr.top;
                right *= (T)tr.right;
                bottom *= (T)tr.bottom;
 
                return *this;
            }

            const TRect<T>& operator*=(const TRect<double>& tr)
            {
                left *= (T)tr.left;
                top *= (T)tr.top;
                right *= (T)tr.right;
                bottom *= (T)tr.bottom;
 
                return *this;
            }
            
            const TRect<T>& operator/=(int32_t value)
            {
                left /= (T)value;
                top /= (T)value;
                right /= (T)value;
                bottom /= (T)value;
 
                return *this;
            }

            const TRect<T>& operator/=(int64_t value)
            {
                left /= (T)value;
                top /= (T)value;
                right /= (T)value;
                bottom /= (T)value;
 
                return *this;
            }

            const TRect<T>& operator/=(float value)
            {
                left /= (T)value;
                top /= (T)value;
                right /= (T)value;
                bottom /= (T)value;
 
                return *this;
            }

            const TRect<T>& operator/=(double value)
            {
                left /= (T)value;
                top /= (T)value;
                right /= (T)value;
                bottom /= (T)value;
 
                return *this;
            }

            const TRect<T>& operator/=(const TRect<int32_t>& tr)
            {
                left /= (T)tr.left;
                top /= (T)tr.top;
                right /= (T)tr.right;
                bottom /= (T)tr.bottom;
 
                return *this;
            }

            const TRect<T>& operator/=(const TRect<int64_t>& tr)
            {
                left /= (T)tr.left;
                top /= (T)tr.top;
                right /= (T)tr.right;
                bottom /= (T)tr.bottom;
 
                return *this;
            }

            const TRect<T>& operator/=(const TRect<float>& tr)
            {
                left /= (T)tr.left;
                top /= (T)tr.top;
                right /= (T)tr.right;
                bottom /= (T)tr.bottom;
 
                return *this;
            }

            const TRect<T>& operator/=(const TRect<double>& tr)
            {
                left /= (T)tr.left;
                top /= (T)tr.top;
                right /= (T)tr.right;
                bottom /= (T)tr.bottom;
 
                return *this;
            }
            
            TRect<T> operator+(int32_t value)
            {
                TRect<T> trReturn;
                trReturn.left = left + (T)value;
                trReturn.top = top + (T)value;
                trReturn.right = right + (T)value;
                trReturn.bottom = bottom + (T)value;
                return trReturn;
            }

            TRect<T> operator+(int64_t value)
            {
                TRect<T> trReturn;
                trReturn.left = left + (T)value;
                trReturn.top = top + (T)value;
                trReturn.right = right + (T)value;
                trReturn.bottom = bottom + (T)value;
                return trReturn;
            }

            TRect<T> operator+(float value)
            {
                TRect<T> trReturn;
                trReturn.left = left + (T)value;
                trReturn.top = top + (T)value;
                trReturn.right = right + (T)value;
                trReturn.bottom = bottom + (T)value;
                return trReturn;
            }

            TRect<T> operator+(double value)
            {
                TRect<T> trReturn;
                trReturn.left = left + (T)value;
                trReturn.top = top + (T)value;
                trReturn.right = right + (T)value;
                trReturn.bottom = bottom + (T)value;
                return trReturn;
            }
            
            TRect<T> operator+(const TRect<int32_t>& tr)
            {
                TRect<T> trReturn;
                trReturn.left = left + (T)tr.left;
                trReturn.top = top + (T)tr.top;
                trReturn.right = right + (T)tr.right;
                trReturn.bottom = bottom + (T)tr.bottom;
                return trReturn;
            }

            TRect<T> operator+(const TRect<int64_t>& tr)
            {
                TRect<T> trReturn;
                trReturn.left = left + (T)tr.left;
                trReturn.top = top + (T)tr.top;
                trReturn.right = right + (T)tr.right;
                trReturn.bottom = bottom + (T)tr.bottom;
                return trReturn;
            }

            TRect<T> operator+(const TRect<float>& tr)
            {
                TRect<T> trReturn;
                trReturn.left = left + (T)tr.left;
                trReturn.top = top + (T)tr.top;
                trReturn.right = right + (T)tr.right;
                trReturn.bottom = bottom + (T)tr.bottom;
                return trReturn;
            }

            TRect<T> operator+(const TRect<double>& tr)
            {
                TRect<T> trReturn;
                trReturn.left = left + (T)tr.left;
                trReturn.top = top + (T)tr.top;
                trReturn.right = right + (T)tr.right;
                trReturn.bottom = bottom + (T)tr.bottom;
                return trReturn;
            }
            
            TRect<T> operator-(int32_t value)
            {
                TRect<T> trReturn;
                trReturn.left = left - (T)value;
                trReturn.top = top - (T)value;
                trReturn.right = right - (T)value;
                trReturn.bottom = bottom - (T)value;
                return trReturn;
            }

            TRect<T> operator-(int64_t value)
            {
                TRect<T> trReturn;
                trReturn.left = left - (T)value;
                trReturn.top = top - (T)value;
                trReturn.right = right - (T)value;
                trReturn.bottom = bottom - (T)value;
                return trReturn;
            }

            TRect<T> operator-(float value)
            {
                TRect<T> trReturn;
                trReturn.left = left - (T)value;
                trReturn.top = top - (T)value;
                trReturn.right = right - (T)value;
                trReturn.bottom = bottom - (T)value;
                return trReturn;
            }

            TRect<T> operator-(double value)
            {
                TRect<T> trReturn;
                trReturn.left = left - (T)value;
                trReturn.top = top - (T)value;
                trReturn.right = right - (T)value;
                trReturn.bottom = bottom - (T)value;
                return trReturn;
            }
            
            TRect<T> operator-(const TRect<int32_t>& tr)
            {
                TRect<T> trReturn;
                trReturn.left = left - (T)tr.left;
                trReturn.top = top - (T)tr.top;
                trReturn.right = right - (T)tr.right;
                trReturn.bottom = bottom - (T)tr.bottom;
                return trReturn;
            }

            TRect<T> operator-(const TRect<int64_t>& tr)
            {
                TRect<T> trReturn;
                trReturn.left = left - (T)tr.left;
                trReturn.top = top - (T)tr.top;
                trReturn.right = right - (T)tr.right;
                trReturn.bottom = bottom - (T)tr.bottom;
                return trReturn;
            }

            TRect<T> operator-(const TRect<float>& tr)
            {
                TRect<T> trReturn;
                trReturn.left = left - (T)tr.left;
                trReturn.top = top - (T)tr.top;
                trReturn.right = right - (T)tr.right;
                trReturn.bottom = bottom - (T)tr.bottom;
                return trReturn;
            }

            TRect<T> operator-(const TRect<double>& tr)
            {
                TRect<T> trReturn;
                trReturn.left = left - (T)tr.left;
                trReturn.top = top - (T)tr.top;
                trReturn.right = right - (T)tr.right;
                trReturn.bottom = bottom - (T)tr.bottom;
                return trReturn;
            }

            TRect<T> operator*(int32_t value)
            {
                TRect<T> trReturn;
                trReturn.left = left * (T)value;
                trReturn.top = top * (T)value;
                trReturn.right = right * (T)value;
                trReturn.bottom = bottom * (T)value;
                return trReturn;
            }

            TRect<T> operator*(int64_t value)
            {
                TRect<T> trReturn;
                trReturn.left = left * (T)value;
                trReturn.top = top * (T)value;
                trReturn.right = right * (T)value;
                trReturn.bottom = bottom * (T)value;
                return trReturn;
            }

            TRect<T> operator*(float value)
            {
                TRect<T> trReturn;
                trReturn.left = left * (T)value;
                trReturn.top = top * (T)value;
                trReturn.right = right * (T)value;
                trReturn.bottom = bottom * (T)value;
                return trReturn;
            }

            TRect<T> operator*(double value)
            {
                TRect<T> trReturn;
                trReturn.left = left * (T)value;
                trReturn.top = top * (T)value;
                trReturn.right = right * (T)value;
                trReturn.bottom = bottom * (T)value;
                return trReturn;
            }
            
            TRect<T> operator*(const TRect<int32_t>& tr)
            {
                TRect<T> trReturn;
                trReturn.left = left * (T)tr.left;
                trReturn.top = top * (T)tr.top;
                trReturn.right = right * (T)tr.right;
                trReturn.bottom = bottom * (T)tr.bottom;
                return trReturn;
            }

            TRect<T> operator*(const TRect<int64_t>& tr)
            {
                TRect<T> trReturn;
                trReturn.left = left * (T)tr.left;
                trReturn.top = top * (T)tr.top;
                trReturn.right = right * (T)tr.right;
                trReturn.bottom = bottom * (T)tr.bottom;
                return trReturn;
            }

            TRect<T> operator*(const TRect<float>& tr)
            {
                TRect<T> trReturn;
                trReturn.left = left * (T)tr.left;
                trReturn.top = top * (T)tr.top;
                trReturn.right = right * (T)tr.right;
                trReturn.bottom = bottom * (T)tr.bottom;
                return trReturn;
            }

            TRect<T> operator*(const TRect<double>& tr)
            {
                TRect<T> trReturn;
                trReturn.left = left * (T)tr.left;
                trReturn.top = top * (T)tr.top;
                trReturn.right = right * (T)tr.right;
                trReturn.bottom = bottom * (T)tr.bottom;
                return trReturn;
            }
            
            TRect<T> operator/(int32_t value)
            {
                TRect<T> trReturn;
                trReturn.left = left / (T)value;
                trReturn.top = top / (T)value;
                trReturn.right = right / (T)value;
                trReturn.bottom = bottom / (T)value;
                return trReturn;
            }

            TRect<T> operator/(int64_t value)
            {
                TRect<T> trReturn;
                trReturn.left = left / (T)value;
                trReturn.top = top / (T)value;
                trReturn.right = right / (T)value;
                trReturn.bottom = bottom / (T)value;
                return trReturn;
            }

            TRect<T> operator/(float value)
            {
                TRect<T> trReturn;
                trReturn.left = left / (T)value;
                trReturn.top = top / (T)value;
                trReturn.right = right / (T)value;
                trReturn.bottom = bottom / (T)value;
                return trReturn;
            }

            TRect<T> operator/(double value)
            {
                TRect<T> trReturn;
                trReturn.left = left / (T)value;
                trReturn.top = top / (T)value;
                trReturn.right = right / (T)value;
                trReturn.bottom = bottom / (T)value;
                return trReturn;
            }

            TRect<T> operator/(const TRect<int32_t>& tr)
            {
                TRect<T> trReturn;
                trReturn.left = left / (T)tr.left;
                trReturn.top = top / (T)tr.top;
                trReturn.right = right / (T)tr.right;
                trReturn.bottom = bottom / (T)tr.bottom;
                return trReturn;
            }

            TRect<T> operator/(const TRect<int64_t>& tr)
            {
                TRect<T> trReturn;
                trReturn.left = left / (T)tr.left;
                trReturn.top = top / (T)tr.top;
                trReturn.right = right / (T)tr.right;
                trReturn.bottom = bottom / (T)tr.bottom;
                return trReturn;
            }

            TRect<T> operator/(const TRect<float>& tr)
            {
                TRect<T> trReturn;
                trReturn.left = left / (T)tr.left;
                trReturn.top = top / (T)tr.top;
                trReturn.right = right / (T)tr.right;
                trReturn.bottom = bottom / (T)tr.bottom;
                return trReturn;
            }

            TRect<T> operator/(const TRect<double>& tr)
            {
                TRect<T> trReturn;
                trReturn.left = left / (T)tr.left;
                trReturn.top = top / (T)tr.top;
                trReturn.right = right / (T)tr.right;
                trReturn.bottom = bottom / (T)tr.bottom;
                return trReturn;
            }

            friend TRect<T> operator+(int32_t value, const TRect<T>& tr)
            {
                return TRect<T>((T)value + tr.left, (T)value + tr.top, (T)value + tr.right, (T)value + tr.bottom);
            }

            friend TRect<T> operator+(int64_t value, const TRect<T>& tr)
            {
                return TRect<T>((T)value + tr.left, (T)value + tr.top, (T)value + tr.right, (T)value + tr.bottom);
            }

            friend TRect<T> operator+(float value, const TRect<T>& tr)
            {
                return TRect<T>((T)value + tr.left, (T)value + tr.top, (T)value + tr.right, (T)value + tr.bottom);
            }

            friend TRect<T> operator+(double value, const TRect<T>& tr)
            {
                return TRect<T>((T)value + tr.left, (T)value + tr.top, (T)value + tr.right, (T)value + tr.bottom);
            }

            friend TRect<T> operator-(int32_t value, const TRect<T>& tr)
            {
                return TRect<T>((T)value - tr.left, (T)value - tr.top, (T)value - tr.right, (T)value - tr.bottom);
            }

            friend TRect<T> operator-(int64_t value, const TRect<T>& tr)
            {
                return TRect<T>((T)value - tr.left, (T)value - tr.top, (T)value - tr.right, (T)value - tr.bottom);
            }

            friend TRect<T> operator-(float value, const TRect<T>& tr)
            {
                return TRect<T>((T)value - tr.left, (T)value - tr.top, (T)value - tr.right, (T)value - tr.bottom);
            }

            friend TRect<T> operator-(double value, const TRect<T>& tr)
            {
                return TRect<T>((T)value - tr.left, (T)value - tr.top, (T)value - tr.right, (T)value - tr.bottom);
            }

            friend TRect<T> operator*(int32_t value, const TRect<T>& tr)
            {
                return TRect<T>((T)value * tr.left, (T)value * tr.top, (T)value * tr.right, (T)value * tr.bottom);
            }

            friend TRect<T> operator*(int64_t value, const TRect<T>& tr)
            {
                return TRect<T>((T)value * tr.left, (T)value * tr.top, (T)value * tr.right, (T)value * tr.bottom);
            }

            friend TRect<T> operator*(float value, const TRect<T>& tr)
            {
                return TRect<T>((T)value * tr.left, (T)value * tr.top, (T)value * tr.right, (T)value * tr.bottom);
            }

            friend TRect<T> operator*(double value, const TRect<T>& tr)
            {
                return TRect<T>((T)value * tr.left, (T)value * tr.top, (T)value * tr.right, (T)value * tr.bottom);
            }

            friend TRect<T> operator/(int32_t value, const TRect<T>& tr)
            {
                return TRect<T>((T)value / tr.left, (T)value / tr.top, (T)value / tr.right, (T)value / tr.bottom);
            }

            friend TRect<T> operator/(int64_t value, const TRect<T>& tr)
            {
                return TRect<T>((T)value / tr.left, (T)value / tr.top, (T)value / tr.right, (T)value / tr.bottom);
            }

            friend TRect<T> operator/(float value, const TRect<T>& tr)
            {
                return TRect<T>((T)value / tr.left, (T)value / tr.top, (T)value / tr.right, (T)value / tr.bottom);
            }

            friend TRect<T> operator/(double value, const TRect<T>& tr)
            {
                return TRect<T>((T)value / tr.left, (T)value / tr.top, (T)value / tr.right, (T)value / tr.bottom);
            }
        };
        #pragma pack(pop)
 
        typedef TRect<int8_t> TRectC;
        typedef TRect<uint8_t> TRectUC;
        typedef TRect<int16_t> TRectS;
        typedef TRect<uint16_t> TRectUS;
        typedef TRect<int32_t> TRectL;
        typedef TRect<uint32_t> TRectUL;
        typedef TRect<int64_t> TRectLL;
        typedef TRect<uint64_t> TRectULL;
        typedef TRect<float> TRectF;
        typedef TRect<double> TRectD;
    }
}