Initial error handling code

include/core/SkRect.h

 
 /*
  * Copyright 2006 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 
 #ifndef SkRect_DEFINED
@@ skipping 82 matching lines @@
      *  This is a specific "truncation" of the average, which is different than
      *  (bottom + top) / 2 when the sum is negative.
      */
     int centerY() const { return (fBottom + fTop) >> 1; }
 
     /**
      *  Return true if the rectangle's width or height are <= 0
      */
     bool isEmpty() const { return fLeft >= fRight || fTop >= fBottom; }
 
+    bool isValid() const { return (fLeft <= fRight) && (fTop <= fBottom); }

[reed1, 2013/09/03 20:25:21]

I think we already have the notion of "inverted" for rects. Seems like this
could use that name somehow.

isInverted() perhaps. That at least is more specific than "valid".

BTW - is it valid/safe if left < right, but right - left overflows a signed int?

[sugoi1, 2013/09/04 18:01:10]

Good point, I added a check to make sure width() and height() aren't oveflowing
the signed int.

+
     bool isLargest() const { return SK_MinS32 == fLeft &&
                                     SK_MinS32 == fTop &&
                                     SK_MaxS32 == fRight &&
                                     SK_MaxS32 == fBottom; }
 
     friend bool operator==(const SkIRect& a, const SkIRect& b) {
         return !memcmp(&a, &b, sizeof(a));
     }
 
     friend bool operator!=(const SkIRect& a, const SkIRect& b) {
@@ skipping 299 matching lines @@
               SkIntToScalar(irect.fRight),
               SkIntToScalar(irect.fBottom));
         return r;
     }
 
     /**
      *  Return true if the rectangle's width or height are <= 0
      */
     bool isEmpty() const { return fLeft >= fRight || fTop >= fBottom; }
 
+    bool isValid() const { return SkScalarIsFinite(fLeft) &&
+                                  SkScalarIsFinite(fTop) &&
+                                  SkScalarIsFinite(fRight) &&
+                                  SkScalarIsFinite(fBottom) &&
+                                  (fLeft <= fRight) &&
+                                  (fTop <= fBottom); }
     /**
      *  Returns true iff all values in the rect are finite. If any are
      *  infinite or NaN (or SK_FixedNaN when SkScalar is fixed) then this
      *  returns false.
      */
     bool isFinite() const {
 #ifdef SK_SCALAR_IS_FLOAT
         float accum = 0;
         accum *= fLeft;
         accum *= fTop;
@@ skipping 365 matching lines @@
      */
     void sort();
 
     /**
      *  cast-safe way to treat the rect as an array of (4) SkScalars.
      */
     const SkScalar* asScalars() const { return &fLeft; }
 };
 
 #endif