@sentryware/s2-node 0.0.6

package/third_party/s2geometry/src/s2/util/units/length-units.h

@@ -0,0 +1,135 @@
+// Copyright 2003 Google Inc. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS-IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+
+// Define common length units.  New length units can be added as needed
+// provided there is a direct, multiplicative scaling to meters.
+//
+// When adding new units, you should add an appropriate GetMyUnit accessor
+// template and (optionally) define a shorthand typedef specialization for
+// float.  Also update the physical units unittest to check the conversion
+// ratio.
+
+#ifndef S2_UTIL_UNITS_LENGTH_UNITS_H_
+#define S2_UTIL_UNITS_LENGTH_UNITS_H_
+
+#include "s2/util/units/physical-units.h"
+
+namespace util {
+
+namespace units {
+
+struct LengthBase {
+  // the base unit type is meters
+  static const char* const output_suffix;
+
+  template <typename ValueType, class Unit>
+  static ValueType GetInBaseUnit(
+      const PhysicalUnit<ValueType, LengthBase, Unit> u) {
+    return GetMeters(u);
+  }
+};
+
+template <typename Float>
+class Length {
+  typedef UnitConversion<1, 1> MetersConversion;
+  typedef UnitConversion<1, 1000> KilometersConversion;
+  typedef UnitConversion<10000, 254> InchesConversion;
+  typedef UnitConversion<10000, 3048> FeetConversion;
+  typedef UnitConversion<1000, 1609344> MilesConversion;
+  typedef UnitConversion<1000, 1> MillimetersConversion;
+  typedef UnitConversion<1, 1852> NauticalMilesConversion;
+  typedef UnitConversion<10000, 9144> YardsConversion;
+
+ public:
+  typedef PhysicalUnit<Float, LengthBase, MetersConversion> Meters;
+  typedef PhysicalUnit<Float, LengthBase, KilometersConversion> Kilometers;
+  typedef PhysicalUnit<Float, LengthBase, InchesConversion> Inches;
+  typedef PhysicalUnit<Float, LengthBase, FeetConversion> Feet;
+  typedef PhysicalUnit<Float, LengthBase, MilesConversion> Miles;
+  typedef PhysicalUnit<Float, LengthBase, MillimetersConversion> Millimeters;
+  typedef PhysicalUnit<Float, LengthBase, NauticalMilesConversion>
+      NauticalMiles;
+  typedef PhysicalUnit<Float, LengthBase, YardsConversion> Yards;
+};
+
+// Define some shorthand, standard typenames.  The standard length
+// type is chosen to be float.  If you need greater precision for
+// a specific application, either use the fully qualified typename
+// Length<double>::* or declare local typedefs.  This would be an
+// ideal place for a template typedef, if only C++ supported them.
+// Note that units with different floating-point types do not
+// support implicit conversion (use the precision_cast<...> method).
+typedef Length<float>::Meters Meters;
+typedef Length<float>::Kilometers Kilometers;
+typedef Length<float>::Inches Inches;
+typedef Length<float>::Feet Feet;
+typedef Length<float>::Miles Miles;
+typedef Length<float>::Millimeters Millimeters;
+typedef Length<float>::NauticalMiles NauticalMiles;
+typedef Length<float>::Yards Yards;
+
+// Explicit unit accessors.  In general these are safer than using
+// the value() accessor, particularly in cases where the unit type
+// may not be immediately obvious (such as function returns).
+
+template <typename ValueType, class Unit>
+inline ValueType GetMeters(const PhysicalUnit<ValueType, LengthBase, Unit> u) {
+  return typename Length<ValueType>::Meters(u).value();
+}
+
+template <typename ValueType, class Unit>
+inline ValueType GetKilometers(
+    const PhysicalUnit<ValueType, LengthBase, Unit> u) {
+  return typename Length<ValueType>::Kilometers(u).value();
+}
+
+template <typename ValueType, class Unit>
+inline ValueType GetInches(const PhysicalUnit<ValueType, LengthBase, Unit> u) {
+  return typename Length<ValueType>::Inches(u).value();
+}
+
+template <typename ValueType, class Unit>
+inline ValueType GetFeet(const PhysicalUnit<ValueType, LengthBase, Unit> u) {
+  return typename Length<ValueType>::Feet(u).value();
+}
+
+template <typename ValueType, class Unit>
+inline ValueType GetMiles(const PhysicalUnit<ValueType, LengthBase, Unit> u) {
+  return typename Length<ValueType>::Miles(u).value();
+}
+
+template <typename ValueType, class Unit>
+inline ValueType GetMillimeters(
+    const PhysicalUnit<ValueType, LengthBase, Unit> u) {
+  return typename Length<ValueType>::Millimeters(u).value();
+}
+
+template <typename ValueType, class Unit>
+inline ValueType GetNauticalMiles(
+    const PhysicalUnit<ValueType, LengthBase, Unit> u) {
+  return typename Length<ValueType>::NauticalMiles(u).value();
+}
+
+template <typename ValueType, class Unit>
+inline ValueType GetYards(const PhysicalUnit<ValueType, LengthBase, Unit> u) {
+  return typename Length<ValueType>::Yards(u).value();
+}
+
+}  // end namespace units
+
+}  // end namespace util
+
+#endif  // S2_UTIL_UNITS_LENGTH_UNITS_H_

package/third_party/s2geometry/src/s2/util/units/physical-units.h

@@ -0,0 +1,313 @@
+// Copyright 2003 Google Inc. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS-IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+
+// Basic physical unit classes.  These classes are not as fancy as
+// some general purpose physical unit libraries, but provide a
+// simple and efficient interface for unit tracking and conversion.
+// In particular, compound units cannot be automatically constructed
+// from or decomposed into simpler units (e.g. velocity = distance /
+// time), but can be defined explicitly as opaque types.
+//
+// These classes define overloaded operators and non-explicit single
+// argument ctors, which breaks the style guidelines, but an exception
+// has been allowed in this case.
+// - Douglas Greiman <dgreiman@google.com>
+//
+// Specific types of physical units are defined in other headers
+// (e.g. angle-units.h).  Each unit type can be specialized to either
+// float or double.  Non-floating-point types are disallowed, since
+// the implicit conversion logic generally fails for integer division.
+// Attempting to declare integer-based units results in a fairly
+// informative compiler error.
+//
+// All units share common functionality, as demonstrated in this
+// example:
+//
+//   #include "angle-units.h"
+//
+//   class Nomad {
+//     Radians latitude_;
+//     ...
+//     // With -O2 optimization, the use of Radians in this method is
+//     // completely equivalent to using float, but prevents unitless
+//     // angles from being passed.
+//     void SetLatitude(Radians angle) {
+//       S2_CHECK(angle.abs() < Degrees(90.0));
+//       latitude_ = angle;
+//       latitude_radius_ = EARTH_RADIUS * cos(angle.value());
+//     }
+//
+//     // This method contains an implicit unit conversion from degrees
+//     // to radians.  In practice it would make more sense to use
+//     // Radians as the argument type to avoid this extra work if
+//     // possible (see the two calls of this method below).
+//     void MoveNorth(Degrees angle) {
+//       SetLatitude(latitude_ + angle);
+//     }
+//   };
+//
+//   void do_tests(float degrees_to_move, float radians_to_move) {
+//     Nomad joe;
+//
+//     // The use of Degrees(30.0) to set the latitude in radians requires
+//     // no runtime conversion.
+//     joe.SetLatitude(Degrees(30.0));
+//
+//     // The Degrees(...) parameter will be converted to radians at
+//     // runtime prior to addition in Nomad::MoveNorth().
+//     joe.MoveNorth(Degrees(degrees_to_move));
+//
+//     // This is ok, but due to the poor choice of units for the MoveNorth
+//     // method's argument, incurs two pointless multiply operations to
+//     // convert from radians to degrees and back to radians.
+//     joe.MoveNorth(Radians(radians_to_move));
+//
+//     // Implicit conversions from unitless values generate errors at
+//     // compile time.
+//     // joe.MoveNorth(degrees_to_move); // compile ERROR!
+//   }
+//
+
+#ifndef S2_UTIL_UNITS_PHYSICAL_UNITS_H_
+#define S2_UTIL_UNITS_PHYSICAL_UNITS_H_
+
+#include <cmath>
+#include <iosfwd>
+#include <iostream>
+#include <string>
+#include <type_traits>
+
+#include "s2/base/integral_types.h"
+#include "s2/third_party/absl/base/macros.h"
+
+namespace util {
+
+namespace units {
+
+// Static conversion scale and offset to convert from a standard base
+// unit to a specific unit.  The scale and offset is specified as a
+// rational number to allow static construction at compile time.
+template <int ScaleNumerator, int ScaleDenominator,
+          int OffsetNumerator = 0, int OffsetDenominator = 1>
+struct UnitConversion {
+  static const int SCALE_NUMERATOR = ScaleNumerator;
+  static const int SCALE_DENOMINATOR = ScaleDenominator;
+  static const int OFFSET_NUMERATOR = OffsetNumerator;
+  static const int OFFSET_DENOMINATOR = OffsetDenominator;
+};
+
+template <class FromUnit, class ToUnit, typename Float>
+struct UnitConverter {
+  // Linear unit conversion: A' = A * s + t, where
+  // - s is a static scale factor and
+  // - t is a static offset
+  // composed from two UnitConversion structs.
+  // Cast one multiplicand to 64 bit to ensure that the integer expression
+  // is computed in 64 bit. Otherwise Feet(Miles(x)) will overflow.
+  constexpr static inline Float Convert(Float value) {
+    // scaling and offset
+    return static_cast<Float>(
+      (static_cast<double>(value *
+         (static_cast<double>(static_cast<uint64>(ToUnit::SCALE_NUMERATOR) *
+                              FromUnit::SCALE_DENOMINATOR) /
+          static_cast<double>(static_cast<uint64>(ToUnit::SCALE_DENOMINATOR) *
+                              FromUnit::SCALE_NUMERATOR)))) -
+      (static_cast<double>(static_cast<uint64>(ToUnit::SCALE_NUMERATOR) *
+                           FromUnit::SCALE_DENOMINATOR *
+                           FromUnit::OFFSET_NUMERATOR) /
+       static_cast<double>(static_cast<uint64>(ToUnit::SCALE_DENOMINATOR) *
+                           FromUnit::SCALE_NUMERATOR *
+                           FromUnit::OFFSET_DENOMINATOR)) +
+      (static_cast<double>(ToUnit::OFFSET_NUMERATOR) /
+       static_cast<double>(ToUnit::OFFSET_DENOMINATOR)));
+  }
+};
+
+// Some unit operations are only defined for base units that have linear
+// transformations, as in T(a+b) = T(a) + T(b).   Temperatures units are
+// an example of units that do not have linear transformations.  By
+// default unit transformations are assumed to be linear; see
+// temperature-units.h for an example of how to override this default.
+template <class Base>
+struct is_linear_unit_transformation : std::true_type { };
+
+// Template class holding a single value with an associated physical
+// unit.  The unit and conversion parameters are statically defined
+// and optimized at compile time.  With optimization (-O2), use of a
+// single physical unit type is as efficient as using a native
+// floating point type.  Conversions between units are optimized to
+// (typically) a single multiplication operation.  Unit conversions
+// for constants are done at compile time and incur no runtime
+// overhead (again at -O2).
+//
+// Template parameters:
+//   Base is the base unit class, such as Angle or Length. If operator<<
+//   is used, it must have:
+//   - a public static field "output_suffix" and
+//   - a public static method Float Base::GetInBaseUnit(PhysicalUnit). An
+//     example can be found in length-units.h
+//     LengthBase::GetInBaseUnit.
+//   Unit is the UnitConversion class that defines a specific unit
+//   (such as degrees) in terms of a reference unit (such as radians).
+template <class Float, class Base, class Unit>
+class PhysicalUnit {
+ public:
+  typedef PhysicalUnit<Float, Base, Unit> Type;
+  typedef Float FloatType;
+
+  // Use 'explicit' to prevent unintentional construction from untyped (or
+  // mistyped) values.  Note that this also prevents arguably reasonable
+  // constructs such as Unit unit = 10.0; use either Unit unit(10.0) or
+  // Unit unit =  Unit(10.0) instead.
+  PhysicalUnit(): value_(static_cast<Float>(0.0)) {}
+  constexpr explicit PhysicalUnit(Float value): value_(value) {}
+
+  // Conversion from other units of the same Base type.
+  //
+  // Policy decision: not using 'explicit' allows much more natural
+  // conversions between units of a given base type.  This can result in
+  // unintended implicit type conversions, but these incur very little
+  // overhead (inlined multiply at -O2) and should be inconsequential in
+  // most circumstances.  Casts between different base types (including
+  // different underlying value types) require explicit handling. The ClangTidy
+  // warnings regarding this are therefore suppressed with NOLINT below.
+  template <class Unit2>
+  constexpr PhysicalUnit(PhysicalUnit<Float, Base, Unit2> other)  // NOLINT
+      : value_(UnitConverter<Unit2, Unit, Float>::Convert(other.value())) {}
+
+  // Copy operation from other units of the same Base type.
+  template <class Unit2>
+  Type operator = (PhysicalUnit<Float, Base, Unit2> other) {
+    value_ = UnitConverter<Unit2, Unit, Float>::Convert(other.value());
+    return *this;
+  }
+
+  // Value accessor.  Consider using an explicitly typed accessor whenever
+  // the unit type is not immediately obvious (such as function return
+  // values).  For example:
+  //   float x = myclass.GetAngle().value();           // what unit is x?
+  //   float x = GetDegrees(myclass.GetAngle());       // much clearer.
+  //   float x = Degrees(myclass.GetAngle()).value();  // ok too.
+  //   Degrees degrees = myclass.GetAngle();           // using a temporary is
+  //   float x = degrees.value();                      // also good.
+  constexpr Float value() const { return value_; }
+
+  // Trivial arithematic operator wrapping.
+  Type operator - () const {
+    return Type(-value_);
+  }
+  Type operator * (const Float scale) const {
+    return Type(value_ * scale);
+  }
+  Type operator + (const Type other) const {
+    static_assert(is_linear_unit_transformation<Base>::value,
+                  "operation not defined");
+    return Type(value_ + other.value());
+  }
+  Type operator - (const Type other) const {
+    static_assert(is_linear_unit_transformation<Base>::value,
+                  "operation not defined");
+    return Type(value_ - other.value());
+  }
+  Float operator / (const Type other) const {
+    return value_ / other.value();
+  }
+  Type operator *= (const Float scale) {
+    value_ *= scale;
+    return *this;
+  }
+  Type operator += (const Type other) {
+    static_assert(is_linear_unit_transformation<Base>::value,
+                  "operation not defined");
+    value_ += other.value();
+    return *this;
+  }
+  Type operator -= (const Type other) {
+    static_assert(is_linear_unit_transformation<Base>::value,
+                  "operation not defined");
+    value_ -= other.value();
+    return *this;
+  }
+
+  // Simple comparisons.  Overloaded equality is intentionally omitted;
+  // use equals() instead.
+  bool operator < (const Type other) const {
+    return value_ < other.value();
+  }
+  bool operator > (const Type other) const {
+    return value_ > other.value();
+  }
+  bool operator <= (const Type other) const {
+    return value_ <= other.value();
+  }
+  bool operator >= (const Type other) const {
+    return value_ >= other.value();
+  }
+
+  // Test equality to within some epsilon.  Always false for
+  // epsilon < 0.
+  bool equals(const Type other,
+              const Type epsilon) const {
+    Float delta = value_ - other.value_;
+    if (delta < static_cast<Float>(0.0)) {
+       return -delta <= epsilon.value_;
+    }
+    return delta <= epsilon.value_;
+  }
+
+  // A little more sugar.
+  Type abs() const {
+    return (value_ < static_cast<Float>(0.0)) ? -(*this) : *this;
+  }
+
+  // Explicit precision casting within a base unit class.
+  template <typename OtherFloat>
+  PhysicalUnit<OtherFloat, Base, Unit> precision_cast() const {
+    typedef PhysicalUnit<OtherFloat, Base, Unit> CastType;
+    return CastType(static_cast<OtherFloat>(value_));
+  }
+
+ private:
+  Float value_;
+  // Enforce Float to be a floating point type, since unit conversions will
+  // generally fail with integers.
+  static_assert(std::is_floating_point<Float>::value,
+                "Only_use_floating_point_types");
+};
+
+// Allow 2*u (in addition to u*2).
+template <typename Scale, typename Float, class Base, class Unit>
+inline PhysicalUnit<Float, Base, Unit> operator * (
+         const Scale scale,
+         const PhysicalUnit<Float, Base, Unit> value) {
+  return value * static_cast<Float>(scale);
+}
+
+// we'll print the current value and the value converted to the natural
+// base type
+template <typename Float, typename Base, typename Unit>
+std::ostream& operator<<(std::ostream& os,
+                         PhysicalUnit<Float, Base, Unit> value) {
+  return os << value.value()
+            << " (" << Base::GetInBaseUnit(value)
+            << Base::output_suffix << ")";
+}
+
+} // end namespace units
+
+} // end namespace util
+
+#endif  // S2_UTIL_UNITS_PHYSICAL_UNITS_H_

package/third_party/s2geometry/src/s2/value_lexicon.h

@@ -0,0 +1,234 @@
+// Copyright 2016 Google Inc. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS-IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+// Author: ericv@google.com (Eric Veach)
+
+#ifndef S2_VALUE_LEXICON_H_
+#define S2_VALUE_LEXICON_H_
+
+#include <functional>
+#include <limits>
+#include <vector>
+
+#include "s2/base/integral_types.h"
+#include "s2/util/gtl/dense_hash_set.h"
+
+// ValueLexicon is a class that maps distinct values to sequentially numbered
+// integer identifiers.  It automatically eliminates duplicates and uses a
+// compact representation.  See also SequenceLexicon.
+//
+// Each distinct value is mapped to a 32-bit integer.  The space used for each
+// value is approximately 7 bytes plus the space needed for the value itself.
+// For example, int64 values would need approximately 15 bytes each.  Note
+// also that values are referred to using 32-bit ids rather than 64-bit
+// pointers.
+//
+// This class has the same thread-safety properties as "string": const methods
+// are thread safe, and non-const methods are not thread safe.
+//
+// Example usage:
+//
+//   ValueLexicon<string> lexicon;
+//   uint32 cat_id = lexicon.Add("cat");
+//   EXPECT_EQ(cat_id, lexicon.Add("cat"));
+//   EXPECT_EQ("cat", lexicon.value(cat_id));
+//
+template <class T,
+          class Hasher = std::hash<T>,
+          class KeyEqual = std::equal_to<T>>
+class ValueLexicon {
+ public:
+  explicit ValueLexicon(const Hasher& hasher = Hasher(),
+                        const KeyEqual& key_equal = KeyEqual());
+
+  // ValueLexicon is movable and copyable.
+  ValueLexicon(const ValueLexicon&);
+  ValueLexicon& operator=(const ValueLexicon&);
+  ValueLexicon(ValueLexicon&&);
+  ValueLexicon& operator=(ValueLexicon&&);
+
+  // Clears all data from the lexicon.
+  void Clear();
+
+  // Add the given value to the lexicon if it is not already present, and
+  // return its integer id.  Ids are assigned sequentially starting from zero.
+  uint32 Add(const T& value);
+
+  // Return the number of values in the lexicon.
+  uint32 size() const;
+
+  // Return the value with the given id.
+  const T& value(uint32 id) const;
+
+ private:
+  friend class IdKeyEqual;
+  // Choose kEmptyKey to be the last key that will ever be generated.
+  static const uint32 kEmptyKey = std::numeric_limits<uint32>::max();
+
+  class IdHasher {
+   public:
+    IdHasher(const Hasher& hasher, const ValueLexicon* lexicon);
+    const Hasher& hasher() const;
+    size_t operator()(uint32 id) const;
+   private:
+    Hasher hasher_;
+    const ValueLexicon* lexicon_;
+  };
+
+  class IdKeyEqual {
+   public:
+    IdKeyEqual(const KeyEqual& key_equal, const ValueLexicon* lexicon);
+    bool operator()(uint32 id1, uint32 id2) const;
+   private:
+    KeyEqual key_equal_;
+    const ValueLexicon* lexicon_;
+  };
+
+  using IdSet = gtl::dense_hash_set<uint32, IdHasher, IdKeyEqual>;
+
+  KeyEqual key_equal_;
+  std::vector<T> values_;
+  IdSet id_set_;
+};
+
+
+//////////////////   Implementation details follow   ////////////////////
+
+
+template <class T, class Hasher, class KeyEqual>
+const uint32 ValueLexicon<T, Hasher, KeyEqual>::kEmptyKey;
+
+template <class T, class Hasher, class KeyEqual>
+ValueLexicon<T, Hasher, KeyEqual>::IdHasher::IdHasher(
+    const Hasher& hasher, const ValueLexicon* lexicon)
+    : hasher_(hasher), lexicon_(lexicon) {
+}
+
+template <class T, class Hasher, class KeyEqual>
+const Hasher& ValueLexicon<T, Hasher, KeyEqual>::IdHasher::hasher() const {
+  return hasher_;
+}
+
+template <class T, class Hasher, class KeyEqual>
+inline size_t ValueLexicon<T, Hasher, KeyEqual>::IdHasher::operator()(
+    uint32 id) const {
+  return hasher_(lexicon_->value(id));
+}
+
+template <class T, class Hasher, class KeyEqual>
+ValueLexicon<T, Hasher, KeyEqual>::IdKeyEqual::IdKeyEqual(
+    const KeyEqual& key_equal, const ValueLexicon* lexicon)
+    : key_equal_(key_equal), lexicon_(lexicon) {
+}
+
+template <class T, class Hasher, class KeyEqual>
+inline bool ValueLexicon<T, Hasher, KeyEqual>::IdKeyEqual::operator()(
+    uint32 id1, uint32 id2) const {
+  if (id1 == id2) return true;
+  if (id1 == lexicon_->kEmptyKey || id2 == lexicon_->kEmptyKey) {
+    return false;
+  }
+  return key_equal_(lexicon_->value(id1), lexicon_->value(id2));
+}
+
+template <class T, class Hasher, class KeyEqual>
+ValueLexicon<T, Hasher, KeyEqual>::ValueLexicon(const Hasher& hasher,
+                                                const KeyEqual& key_equal)
+    : key_equal_(key_equal),
+      id_set_(0, IdHasher(hasher, this),
+                 IdKeyEqual(key_equal, this)) {
+  id_set_.set_empty_key(kEmptyKey);
+}
+
+template <class T, class Hasher, class KeyEqual>
+ValueLexicon<T, Hasher, KeyEqual>::ValueLexicon(const ValueLexicon& x)
+    : key_equal_(x.key_equal_), values_(x.values_),
+      // Unfortunately we can't copy "id_set_" because we need to change the
+      // "this" pointers associated with hasher() and key_equal().
+      id_set_(x.id_set_.begin(), x.id_set_.end(), kEmptyKey, 0,
+              IdHasher(x.id_set_.hash_funct().hasher(), this),
+              IdKeyEqual(x.key_equal_, this)) {
+}
+
+template <class T, class Hasher, class KeyEqual>
+ValueLexicon<T, Hasher, KeyEqual>::ValueLexicon(ValueLexicon&& x)
+    : key_equal_(std::move(x.key_equal_)), values_(std::move(x.values_)),
+      // Unfortunately we can't move "id_set_" because we need to change the
+      // "this" pointers associated with hasher() and key_equal().
+      id_set_(x.id_set_.begin(), x.id_set_.end(), kEmptyKey, 0,
+              IdHasher(x.id_set_.hash_funct().hasher(), this),
+              IdKeyEqual(x.key_equal_, this)) {
+}
+
+template <class T, class Hasher, class KeyEqual>
+ValueLexicon<T, Hasher, KeyEqual>&
+ValueLexicon<T, Hasher, KeyEqual>::operator=(const ValueLexicon& x) {
+  // Note that self-assignment is handled correctly by this code.
+  key_equal_ = x.key_equal_;
+  values_ = x.values_;
+  // Unfortunately we can't copy-assign "id_set_" because we need to change
+  // the "this" pointers associated with hasher() and key_equal().
+  id_set_ = IdSet(x.id_set_.begin(), x.id_set_.end(), kEmptyKey, 0,
+                  IdHasher(x.id_set_.hash_funct().hasher(), this),
+                  IdKeyEqual(x.key_equal_, this));
+  return *this;
+}
+
+template <class T, class Hasher, class KeyEqual>
+ValueLexicon<T, Hasher, KeyEqual>&
+ValueLexicon<T, Hasher, KeyEqual>::operator=(ValueLexicon&& x) {
+  // Note that move self-assignment has undefined behavior.
+  key_equal_ = std::move(x.key_equal_);
+  values_ = std::move(x.values_);
+  // Unfortunately we can't move-assign "id_set_" because we need to change
+  // the "this" pointers associated with hasher() and key_equal().
+  id_set_ = IdSet(x.id_set_.begin(), x.id_set_.end(), kEmptyKey, 0,
+                  IdHasher(x.id_set_.hash_funct().hasher(), this),
+                  IdKeyEqual(x.key_equal_, this));
+  return *this;
+}
+
+template <class T, class Hasher, class KeyEqual>
+void ValueLexicon<T, Hasher, KeyEqual>::Clear() {
+  values_.clear();
+  id_set_.clear();
+}
+
+template <class T, class Hasher, class KeyEqual>
+uint32 ValueLexicon<T, Hasher, KeyEqual>::Add(const T& value) {
+  if (!values_.empty() && key_equal_(value, values_.back())) {
+    return values_.size() - 1;
+  }
+  values_.push_back(value);
+  auto result = id_set_.insert(values_.size() - 1);
+  if (result.second) {
+    return values_.size() - 1;
+  } else {
+    values_.pop_back();
+    return *result.first;
+  }
+}
+
+template <class T, class Hasher, class KeyEqual>
+inline uint32 ValueLexicon<T, Hasher, KeyEqual>::size() const {
+  return values_.size();
+}
+
+template <class T, class Hasher, class KeyEqual>
+inline const T& ValueLexicon<T, Hasher, KeyEqual>::value(uint32 id) const {
+  return values_[id];
+}
+
+#endif  // S2_VALUE_LEXICON_H_