Size.h

Go to the documentation of this file.

 
#pragma once
 
#include <iostream>
#include <ostream>
#include <string>
#include <iomanip>
#include <limits>
#include <sstream>
 
#include "../Types.h"
#include "Point.h"
#include "../String.h"
 
#include <ctype.h>
 
namespace Gorgon { namespace Geometry {
 
    template<class T_>
    class basic_Size {
    public:
        typedef T_ BaseType;
 
        basic_Size() { }
 
        explicit basic_Size(const T_ &s) : Width(s), Height(s) { }
 
        basic_Size(const T_ &w, const T_ &h) : Width(w), Height(h) { }
 
        template <class O_>
        basic_Size(const basic_Size<O_> &size) : Width((T_)size.Width), Height((T_)size.Height) { }
 
        explicit basic_Size(const basic_Point<T_> &point) : Width((T_)point.X), Height((T_)point.Y) { }
        
        explicit basic_Size(const std::string &str) {
            auto s=str.begin();
 
            if(s == str.end())
                Width = Height = 0;
            
            while(s != str.end() && (*s==' ' || *s=='\t')) s++;
 
            if(s == str.end())
                Width = Height = 0;
            
            auto pos = str.find_first_of('x', s-str.begin());
            if(pos != str.npos)
                Width=String::To<T_>(str.substr(s-str.begin(), pos-(s-str.begin())));
            else
                Width=String::To<T_>(&str[s-str.begin()]);
            
            while(s!=str.end() && *s!='x' && *s!=',') s++;
            
            if(s != str.end()) {
                if(*s=='x' || *s==',') s++;
 
                Height = String::To<T_>(&str[s-str.begin()]);
            }
        }
        
        
        explicit operator std::string() const {
            std::string ret;
            ret += String::From(Width);
            ret.push_back('x');
            ret += String::From(Height);
            
            return ret;
        }
        
            
        static basic_Size Parse(const std::string &str) {
            basic_Size sz;
            
            auto s=str.begin();
 
            if(s==str.end()) {
                throw String::IllegalTokenError(s-str.begin(), 121002, "Unexpected end of input");
            }
            
            while(*s==' ' || *s=='\t') s++;
                        
            char *endptr;
            sz.Width = T_(strtod(&*s, &endptr));
            if(endptr==&*s) {
                throw String::IllegalTokenError(0, 120001);
            }
            s+=endptr-&*s;
            
            while(s!=str.end() && isspace(*s)) s++;
            if(s==str.end()) {
                throw String::IllegalTokenError(s-str.begin(), 121002, "Unexpected end of input");
            }
            if(*s!='x') {
                throw String::IllegalTokenError(s-str.begin(), 121002, std::string("Illegal token: ")+*s);
            }
            s++;
 
            if(s==str.end()) {
                throw String::IllegalTokenError(s-str.begin(), 121002, "Unexpected end of input");
            }
 
            sz.Height=T_(strtod(&*s, &endptr));         
            if(endptr==&*s) {
                throw String::IllegalTokenError(s-str.begin(), 121003);
            }
            s+=endptr-&*s;
 
            if(s==str.end()) return sz;
            
            //eat white space + a single )
            while(s!=str.end() && isspace(*s)) s++;
            
            if(s!=str.end()) {
                throw String::IllegalTokenError(s-str.begin(), 121004, std::string("Illegal token: ")+*s);
            }
            
            return sz;
        }
 
        template <class O_>
        basic_Size &operator =(const basic_Size<O_> &size) { 
            Width=size.Width; 
            Height=size.Height; 
 
            return *this; 
        }
 
        template <class O_>
        basic_Size &operator =(const basic_Point<O_> &point) { 
            Width=point.X;
            Height=point.Y; 
 
            return *this; 
        }
 
        bool operator ==(const basic_Size  &size) const { 
            return Width==size.Width && Height==size.Height;
        }
 
        bool operator !=(const basic_Size  &size) const { 
            return Width!=size.Width || Height!=size.Height;
        }
 
        template<class O_>
        basic_Size operator +(const basic_Size<O_>  &size) const { 
            return basic_Size(size.Width+Width, size.Height+Height);
        }
 
        template<class O_>
        basic_Size operator -(const basic_Size<O_>  &size) const { 
            return basic_Size(Width-size.Width, Height-size.Height);
        }
 
        basic_Size operator -() const {
            return{-Width, -Height};
        }
 
        template<class O_>
        basic_Size &operator +=(const basic_Size<O_>  &size) { 
            Width=size.Width  +Width;
            Height=size.Height+Height;
 
            return *this;
        }
 
        template<class O_>
        basic_Size &operator -=(const basic_Size<O_>  &size) { 
            Width=Width-size.Width;
            Height=Height-size.Height;
 
            return *this;
        }
 
        template<class _S>
        basic_Size operator *=(_S size) { 
            Width =T_(size  *Width);
            Height=T_(size*Height);
 
            return *this;
        }
 
        template<class _S>
        basic_Size operator /=(_S size) { 
            Width =T_(Width/size);
            Height=T_(Height/size);
 
            return *this;
        }
 
        explicit operator basic_Point<T_>() const {
            return{Width, Height};
        }
 
        T_ Cells() const { 
            return T_(std::floor(Width)*std::floor(Height)); 
        }
 
        T_ Area() const { 
            return Width*Height; 
        }
 
        bool IsValid() const {
            return Width>=0 && Height>=0;
        }
        
        static basic_Size Max() {
            static_assert(std::numeric_limits<T_>::is_specialized, "Max function can only be used with "
                "arithmetic types that have numeric_limits specialized");
            return {std::numeric_limits<T_>::max(), std::numeric_limits<T_>::max()};
        }
 
        T_ Width;
 
        T_ Height;
    };
 
    template<class T_>
    basic_Size<T_> operator *(const basic_Size<T_> &size, double factor) {
        return{T_(size.Width*factor), T_(size.Height*factor)};
    }
 
    template<class T_>
    basic_Size<T_> operator *(double factor, const basic_Size<T_> &size) {
        return operator*(size, factor);
    }
 
    template<class T_>
    basic_Size<T_> operator /(const basic_Size<T_> &size, double factor) {
        return{T_(size.Width/factor), T_(size.Height/factor)};
    }
 
    template<class T_>
    basic_Size<T_> operator /(double factor, const basic_Size<T_> &size) {
        return operator/(size, factor);
    }
 
    template<class T_>
    static std::ostream &operator <<(std::ostream &out, const basic_Size<T_> &size) {
        out<<size.Width<<"x"<<size.Height;
 
        return out;
    }
 
    template <class T_>
    std::istream &operator >> (std::istream &in, basic_Size<T_> &size) {
        while(in.peek()==' ' || in.peek()=='\t')
            in.ignore(1);
 
        std::string s;
        
        while(in.peek()!='x' && !in.eof())
            s.append(1, (char)in.get());
 
        if(in.eof()) {
            in.setstate(in.failbit);
            return in;
        }
        in.ignore(1);
 
        auto w=String::To<T_>(s);
 
        s="";
 
        while(in.peek()==' ' || in.peek()=='\t')
            in.ignore(1);
 
        while(in.peek()!=' ' && in.peek()!='\t' && in.peek()!='\n' && in.peek()!='\r' && !in.eof())
            s.append(1, in.get());
 
        size.Width=w;
        size.Height=String::To<T_>(s);
 
        return in;
    }
 
    template<class T_, class O_>
    auto operator *(const basic_Point<T_> &l, const basic_Size<O_> &r) -> basic_Point<decltype(l.X*r.Width)> {
        return{l.X*r.Width, l.Y*r.Height};
    }
 
    template<class T_, class O_>
    auto operator /(const basic_Point<T_> &l, const basic_Size<O_> &r) -> basic_Point<decltype(l.X*r.Width)> {
        return{l.X/r.Width, l.Y/r.Height};
    }
 
    template <class T_, class O_>
    void Scale(basic_Point<T_> &point, const basic_Size<O_> &size) {
        point.X = T_(point.X*size.Width);
        point.Y = T_(point.Y*size.Height);
    }
 
    template <class T_, class O_>
    void Scale(basic_Size<T_> &l, const O_ &size) {
        l.Width = T_(l.Width*size);
        l.Height = T_(l.Height*size);
    }
 
    template <class T_, class O1_, class O2_>
    void Scale(basic_Size<T_> &l, const O1_ &sizex, const O2_ &sizey) {
        l.Width = T_(l.Width*sizex);
        l.Height = T_(l.Height*sizey);
    }
 
    template <class T_, class O_>
    void Scale(basic_Size<T_> &l, const basic_Size<O_> &size) {
        l.Width = T_(l.Width*size.Width);
        l.Height = T_(l.Height*size.Height);
    }
    
    template <class T_>
    basic_Size<T_> Union(const basic_Size<T_> &l, const basic_Size<T_> &r) {
        return {std::min(l.Width, r.Width), std::min(l.Height, r.Height)};
    }
    
    template <class T_>
    basic_Size<T_> Combine(const basic_Size<T_> &l, const basic_Size<T_> &r) {
        return {std::max(l.Width, r.Width), std::max(l.Height, r.Height)};
    }
 
 
    using Size = basic_Size<int>;
 
    using Sizef = basic_Size<Float>;
 
} }