Add float version of gfx::Range

ui/gfx/range/range.h

-// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Copyright 2015 The Chromium Authors. All rights reserved.

[Robert Sesek, 2015/02/02 21:42:11]

The copyright year should actually remain the same when modifying files.

https://groups.google.com/a/chromium.org/d/topic/chromium-dev/8p4JKV76kig/dis...

[ckocagil, 2015/02/03 00:51:05]

Done.

 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef UI_GFX_RANGE_RANGE_H_
 #define UI_GFX_RANGE_RANGE_H_
 
+#include <algorithm>
 #include <ostream>
+#include <sstream>
 #include <string>
 
 #include "base/basictypes.h"
 #include "ui/gfx/gfx_export.h"
 
 #if defined(OS_MACOSX)
 #if __OBJC__
 #import <Foundation/Foundation.h>
 #else
 typedef struct _NSRange NSRange;
 #endif
 #endif  // defined(OS_MACOSX)
 
 #if defined(OS_WIN)
 #include <windows.h>
 #include <richedit.h>
 #endif
 
 namespace gfx {
 
+namespace internal {
+
+template <typename T>
+class TRangeBase;
+
+template <typename T>
+TRangeBase<T> InvalidRange();
+
+template <>
+TRangeBase<size_t> InvalidRange<size_t>();
+
+template <>
+TRangeBase<float> InvalidRange<float>();
+
+bool IsValidRange(const TRangeBase<size_t>& range);
+bool IsValidRange(const TRangeBase<float>& range);
+
+size_t RangeLength(const TRangeBase<size_t>& range);
+float RangeLength(const TRangeBase<float>& range);
+
+bool RangeIsEmpty(const TRangeBase<size_t>& range);
+bool RangeIsEmpty(const TRangeBase<float>& range);
+
+template <typename T>
+class TRangeBase {
+ public:
+  // Initializes the range with a start and end.
+  TRangeBase(T start, T end) : start_(start), end_(end) {}
+
+  TRangeBase(const TRangeBase<T>& other)
+      : start_(other.start()), end_(other.end()) {}
+
+  // Returns a range that is invalid.
+  static const TRangeBase<T> InvalidRange() {
+    return internal::InvalidRange<T>();

[Robert Sesek, 2015/02/02 21:42:11]

Don't need internal:: since this is in the namespace.

[ckocagil, 2015/02/03 00:51:05]

In this case we actually need it since TRangeBase::InvalidRange and
internal::InvalidRange have the same name. For other cases below (RangeLength,
etc.) I removed internal::.

+  }
+
+  // Checks if the range is valid.
+  bool IsValid() const {
+    return internal::IsValidRange(*this);
+  }
+
+  // Getters and setters.
+  T start() const { return start_; }
+  void set_start(T start) { start_ = start; }
+
+  T end() const { return end_; }
+  void set_end(T end) { end_ = end; }
+
+  // Returns the absolute value of the length.
+  T length() const {
+    return internal::RangeLength(*this);
+  }
+
+  bool is_reversed() const { return start_ > end_; }
+  bool is_empty() const {
+    return internal::RangeIsEmpty(*this);
+  }
+
+  // Returns the minimum and maximum values.
+  T GetMin() const { return std::min(start_, end_); }
+  T GetMax() const { return std::max(start_, end_); }
+
+  bool operator==(const TRangeBase& other) const {
+    return start_ == other.start() && end_ == other.end();

[Robert Sesek, 2015/02/02 21:42:11]

Use other.start_ and other.end_ for consistency.

[ckocagil, 2015/02/03 00:51:05]

Done.

+  }
+  bool operator!=(const TRangeBase& other) const {
+    return !(*this == other);
+  }
+  bool EqualsIgnoringDirection(const TRangeBase& other) const {
+    return GetMin() == other.GetMin() && GetMax() == other.GetMax();
+  }
+
+  // Returns true if this range intersects the specified |range|.
+  bool Intersects(const TRangeBase& range) const {
+    return IsValid() && range.IsValid() &&
+        !(range.GetMax() < GetMin() || range.GetMin() >= GetMax());
+  }
+
+  // Returns true if this range contains the specified |range|.
+  bool Contains(const TRangeBase& range) const {
+    return IsValid() && range.IsValid() &&
+        GetMin() <= range.GetMin() && range.GetMax() <= GetMax();
+  }
+
+  // Computes the intersection of this range with the given |range|.
+  // If they don't intersect, it returns an InvalidRange().
+  // The returned range is always empty or forward (never reversed).
+  TRangeBase Intersect(const TRangeBase& range) const {
+    T min = std::max(GetMin(), range.GetMin());
+    T max = std::min(GetMax(), range.GetMax());
+
+    if (min >= max)  // No intersection.
+      return InvalidRange();
+
+    return TRangeBase(min, max);
+  }
+
+  std::string ToString() const {
+    std::ostringstream stream;
+    stream << "{" << start_ << "," << end_ << "}";
+    return stream.str();
+  }
+
+ private:
+  T start_;
+  T end_;
+};
+
+} //  namespace internal
+
 // A Range contains two integer values that represent a numeric range, like the
 // range of characters in a text selection. A range is made of a start and end
 // position; when they are the same, the Range is akin to a caret. Note that
 // |start_| can be greater than |end_| to respect the directionality of the
 // range.
-class GFX_EXPORT Range {
+// TODO(ckocagil): Move these constructors to TRangeBase and use delegated
+// constructors (C++11) after the feature is allowed.
+class GFX_EXPORT Range : public internal::TRangeBase<size_t> {
  public:
   // Creates an empty range {0,0}.
   Range();
 
   // Initializes the range with a start and end.
   Range(size_t start, size_t end);
 
+  Range(const internal::TRangeBase<size_t>& other);

[Robert Sesek, 2015/02/02 21:42:11]

Do you have to use the internal name here, or can |const Range& other| work?

[ckocagil, 2015/02/03 00:51:05]

We need to construct a Range from a TRangeBase here:
https://codereview.chromium.org/876873003/diff/140001/ui/gfx/range/range_win....

+
   // Initializes the range with the same start and end positions.
   explicit Range(size_t position);
 
   // Platform constructors.
 #if defined(OS_MACOSX)
   explicit Range(const NSRange& range);
 #elif defined(OS_WIN)
   // The |total_length| paramater should be used if the CHARRANGE is set to
   // {0,-1} to indicate the whole range.
   Range(const CHARRANGE& range, LONG total_length = -1);
 #endif
 
-  // Returns a range that is invalid, which is {size_t_max,size_t_max}.
-  static const Range InvalidRange();
-
-  // Checks if the range is valid through comparision to InvalidRange().
-  bool IsValid() const;
-
-  // Getters and setters.
-  size_t start() const { return start_; }
-  void set_start(size_t start) { start_ = start; }
-
-  size_t end() const { return end_; }
-  void set_end(size_t end) { end_ = end; }
-
-  // Returns the absolute value of the length.
-  size_t length() const {
-    ptrdiff_t length = end() - start();
-    return length >= 0 ? length : -length;
-  }
-
-  bool is_reversed() const { return start() > end(); }
-  bool is_empty() const { return start() == end(); }
-
-  // Returns the minimum and maximum values.
-  size_t GetMin() const;
-  size_t GetMax() const;
-
-  bool operator==(const Range& other) const;
-  bool operator!=(const Range& other) const;
-  bool EqualsIgnoringDirection(const Range& other) const;
-
-  // Returns true if this range intersects the specified |range|.
-  bool Intersects(const Range& range) const;
-
-  // Returns true if this range contains the specified |range|.
-  bool Contains(const Range& range) const;
-
-  // Computes the intersection of this range with the given |range|.
-  // If they don't intersect, it returns an InvalidRange().
-  // The returned range is always empty or forward (never reversed).
-  Range Intersect(const Range& range) const;
-
 #if defined(OS_MACOSX)
   Range& operator=(const NSRange& range);
 
   // NSRange does not store the directionality of a range, so if this
   // is_reversed(), the range will get flipped when converted to an NSRange.
   NSRange ToNSRange() const;
 #elif defined(OS_WIN)
   CHARRANGE ToCHARRANGE() const;
 #endif
   // GTK+ has no concept of a range.
+};
 
-  std::string ToString() const;
+// A RangeF contains two float values that represent a numeric range, like a
+// range of positions on a line. A RangeF is made of a start and end position;
+// when they are the same, the RangeF is considered empty. Note that |start_|
+// can be greater than |end_| to respect the directionality of the range.
+class GFX_EXPORT RangeF : public internal::TRangeBase<float> {
+ public:
+  // Creates an empty range {0,0}.
+  RangeF();
 
- private:
-  size_t start_;
-  size_t end_;
+  // Initializes the range with a start and end.
+  RangeF(float start, float end);
+
+  RangeF(const internal::TRangeBase<float>& other);

[Robert Sesek, 2015/02/02 21:42:11]

Same.

+
+  // Initializes the range with the same start and end positions.
+  explicit RangeF(float position);
 };
 
 GFX_EXPORT std::ostream& operator<<(std::ostream& os, const Range& range);
+GFX_EXPORT std::ostream& operator<<(std::ostream& os, const RangeF& range);
 
 }  // namespace gfx
 
 #endif  // UI_GFX_RANGE_RANGE_H_