size2d.h

Go to the documentation of this file.

 
#pragma once
 
 
#include <promeki/config.h>
#if PROMEKI_ENABLE_CORE
#include <cstdlib>
#include <cerrno>
#include <type_traits>
#include <promeki/namespace.h>
#include <promeki/string.h>
#include <promeki/point.h>
#include <promeki/error.h>
#include <promeki/result.h>
 
PROMEKI_NAMESPACE_BEGIN
 
template <typename T> class Size2DTemplate {
        public:
                Size2DTemplate(const T &width = 0, const T &height = 0) : _width(width), _height(height) {}
 
                ~Size2DTemplate() {}
 
                bool isValid() const { return (_width > 0) && (_height > 0); }
 
                void set(const T &w, const T &h) {
                        _width = w;
                        _height = h;
                        return;
                }
 
                void setWidth(const T &val) {
                        _width = val;
                        return;
                }
 
                const T &width() const { return _width; }
 
                void setHeight(const T &val) {
                        _height = val;
                        return;
                }
 
                const T &height() const { return _height; }
 
                T area() const { return _width * _height; }
 
                String toString() const { return String::number(_width) + "x" + String::number(_height); }
 
                operator String() const { return toString(); }
 
                static Result<Size2DTemplate<T>> fromString(const String &str) {
                        const char *s = str.cstr();
                        if (s == nullptr || *s == '\0') {
                                return makeError<Size2DTemplate<T>>(Error::Invalid);
                        }
                        T           w{};
                        const char *end = nullptr;
                        if (!parseDim(s, w, end)) {
                                return makeError<Size2DTemplate<T>>(Error::Invalid);
                        }
                        if (*end != 'x' && *end != 'X') {
                                return makeError<Size2DTemplate<T>>(Error::Invalid);
                        }
                        const char *rest = end + 1;
                        if (*rest == '\0') {
                                return makeError<Size2DTemplate<T>>(Error::Invalid);
                        }
                        T h{};
                        if (!parseDim(rest, h, end) || *end != '\0') {
                                return makeError<Size2DTemplate<T>>(Error::Invalid);
                        }
                        return makeResult(Size2DTemplate<T>(w, h));
                }
 
                bool operator==(const Size2DTemplate &other) const {
                        return _width == other._width && _height == other._height;
                }
 
                bool operator!=(const Size2DTemplate &other) const { return !(*this == other); }
 
                template <typename N> bool pointIsInside(const Point<N, 2> &p) const {
                        // First gate the >=0 check so a signed point coordinate paired with
                        // an unsigned size dimension doesn't trip -Wsign-compare on the
                        // upper bound: after p.x() >= 0 the cast to T is always safe.
                        if (p.x() < N{0} || p.y() < N{0}) return false;
                        return static_cast<T>(p.x()) < _width && static_cast<T>(p.y()) < _height;
                }
 
        private:
                T _width = 0;
                T _height = 0;
 
                // Parses one width or height token from @p s, dispatching to
                // strtoll for signed T and strtoull for unsigned T so that
                // negative inputs are accepted by signed templates and
                // rejected by unsigned templates.  On success returns true,
                // sets @p out, and points @p end at the first unparsed
                // character.  On parse failure returns false.
                static bool parseDim(const char *s, T &out, const char *&end) {
                        char *parseEnd = nullptr;
                        errno = 0;
                        if constexpr (std::is_integral_v<T> && std::is_signed_v<T>) {
                                long long v = std::strtoll(s, &parseEnd, 10);
                                end = parseEnd;
                                if (parseEnd == s || errno != 0) return false;
                                out = static_cast<T>(v);
                                return true;
                        } else if constexpr (std::is_integral_v<T>) {
                                // strtoull silently accepts a leading '-' and
                                // returns the negation as unsigned.  Reject up
                                // front so an unsigned size cannot be parsed
                                // from a negative-looking input.
                                const char *p = s;
                                while (*p == ' ' || *p == '\t') ++p;
                                if (*p == '-') return false;
                                unsigned long long v = std::strtoull(s, &parseEnd, 10);
                                end = parseEnd;
                                if (parseEnd == s || errno != 0) return false;
                                out = static_cast<T>(v);
                                return true;
                        } else {
                                double v = std::strtod(s, &parseEnd);
                                end = parseEnd;
                                if (parseEnd == s || errno != 0) return false;
                                out = static_cast<T>(v);
                                return true;
                        }
                }
};
 
using Size2Di32 = Size2DTemplate<int32_t>;
using Size2Du32 = Size2DTemplate<uint32_t>;
using Size2Df = Size2DTemplate<float>;
using Size2Dd = Size2DTemplate<double>;
 
PROMEKI_NAMESPACE_END
 
template <typename T>
struct std::formatter<promeki::Size2DTemplate<T>> : promeki::ToStringFormatter<promeki::Size2DTemplate<T>> {};
 
#endif // PROMEKI_ENABLE_CORE