Groonga - fulltext search engine.

[Groonga-commit] groonga/grnxx at 2524c34 [master] Fix some problems in the primary template of Array.

susumu.yata null+****@clear*****
Fri Sep 5 16:45:28 JST 2014

• Previous message: [Groonga-commit] droonga/droonga-engine at 4ce1e25 [master] Fix typo
• Next message: [Groonga-commit] droonga/droonga-engine at d4e2966 [master] Call given block directly instead of yield.
• Messages sorted by: [ date ] [ thread ] [ subject ] [ author ]

susumu.yata	2014-09-05 16:45:28 +0900 (Fri, 05 Sep 2014)

  New Revision: 2524c34cfe96252c8eed4cb8a09c21dfcde14fc0
  https://github.com/groonga/grnxx/commit/2524c34cfe96252c8eed4cb8a09c21dfcde14fc0

  Message:
    Fix some problems in the primary template of Array.

  Added files:
    include/grnxx/array/primary.hpp
  Modified files:
    include/grnxx/array.hpp
    include/grnxx/array/Makefile.am

  Modified: include/grnxx/array.hpp (+281 -279)
===================================================================
--- include/grnxx/array.hpp    2014-09-05 14:46:23 +0900 (b0b9ea8)
+++ include/grnxx/array.hpp    2014-09-05 16:45:28 +0900 (0e70d2d)
@@ -5,287 +5,289 @@
 
 #include "grnxx/types.hpp"
 
-namespace grnxx {
-
-class ArrayErrorReporter {
- public:
-  static void report_memory_error(Error *error);
-};
-
-template <typename T> class ArrayCRef;
-template <typename T> class ArrayRef;
-template <typename T> class Array;
-
-template <typename T>
-class ArrayCRef {
- public:
-  using Value = T;
-
-  ArrayCRef() = default;
-  ArrayCRef(const ArrayCRef &) = default;
-
-  ArrayCRef &operator=(const ArrayCRef &) = default;
-
-  bool operator==(ArrayCRef<Value> rhs) const {
-    return (values_ == rhs.values_) && (size_ == rhs.size_);
-  }
-  bool operator!=(ArrayCRef<Value> rhs) const {
-    return (values_ != rhs.values_) || (size_ != rhs.size_);
-  }
-
-  ArrayCRef ref(Int offset = 0) const {
-    return ArrayCRef(values_ + offset, size_ - offset);
-  }
-  ArrayCRef ref(Int offset, Int size) const {
-    return ArrayCRef(values_ + offset, size);
-  }
-
-  Value get(Int i) const {
-    return values_[i];
-  }
-
-  const Value &operator[](Int i) const {
-    return values_[i];
-  }
-
-  Int size() const {
-    return size_;
-  }
-
- private:
-  const Value *values_;
-  Int size_;
-
-  ArrayCRef(const Value *values, Int size) : values_(values), size_(size) {}
-
-  friend class ArrayRef<Value>;
-  friend class Array<Value>;
-};
-
-template <typename T>
-class ArrayRef {
- public:
-  using Value = T;
-
-  ArrayRef() = default;
-  ArrayRef(const ArrayRef &) = default;
-
-  ArrayRef &operator=(const ArrayRef &) = default;
-
-  operator ArrayCRef<Value>() const {
-    return ref();
-  }
-
-  bool operator==(ArrayCRef<Value> rhs) const {
-    return (values_ == rhs.values_) && (size_ == rhs.size_);
-  }
-  bool operator==(ArrayRef<Value> rhs) const {
-    return (values_ == rhs.values_) && (size_ == rhs.size_);
-  }
-
-  bool operator!=(ArrayCRef<Value> rhs) const {
-    return (values_ != rhs.values_) || (size_ != rhs.size_);
-  }
-  bool operator!=(ArrayRef<Value> rhs) const {
-    return (values_ != rhs.values_) || (size_ != rhs.size_);
-  }
-
-  ArrayCRef<Value> ref(Int offset = 0) const {
-    return ArrayCRef<Value>(values_ + offset, size_ - offset);
-  }
-  ArrayCRef<Value> ref(Int offset, Int size) const {
-    return ArrayCRef<Value>(values_ + offset, size);
-  }
-
-  ArrayRef ref(Int offset = 0) {
-    return ArrayRef(values_ + offset, size_ - offset);
-  }
-  ArrayRef ref(Int offset, Int size) {
-    return ArrayRef(values_ + offset, size);
-  }
-
-  Value get(Int i) const {
-    return values_[i];
-  }
-  void set(Int i, Value value) {
-    values_[i] = value;
-  }
-
-  Value &operator[](Int i) {
-    return values_[i];
-  }
-  const Value &operator[](Int i) const {
-    return values_[i];
-  }
-
-  Int size() const {
-    return size_;
-  }
-
-  void swap(Int i, Int j) {
-    std::swap(values_[i], values_[j]);
-  }
-
- private:
-  Value *values_;
-  Int size_;
-
-  ArrayRef(Value *values, Int size) : values_(values), size_(size) {}
-
-  friend class Array<Value>;
-};
-
-template <typename T>
-inline bool operator==(ArrayCRef<T> lhs, ArrayRef<T> rhs) {
-  return rhs == lhs;
-}
-template <typename T>
-inline bool operator!=(ArrayCRef<T> lhs, ArrayRef<T> rhs) {
-  return rhs != lhs;
-}
-
-template <typename T>
-class Array {
- public:
-  using Value = T;
-
-  Array() : values_() {}
-  ~Array() {}
-
-  Array(Array &&array) : values_(std::move(array.values_)) {}
+#include "grnxx/array/primary.hpp"
 
-  Array &operator=(Array &&array) {
-    values_ = std::move(array.values_);
-    return *this;
-  }
-
-  operator ArrayCRef<Value>() const {
-    return ref();
-  }
-  operator ArrayRef<Value>() {
-    return ref();
-  }
-
-  ArrayCRef<Value> ref(Int offset = 0) const {
-    return ArrayCRef<Value>(values_.data() + offset, size() - offset);
-  }
-  ArrayCRef<Value> ref(Int offset, Int size) const {
-    return ArrayCRef<Value>(values_.data() + offset, size);
-  }
-
-  ArrayRef<Value> ref(Int offset = 0) {
-    return ArrayRef<Value>(values_.data() + offset, size() - offset);
-  }
-  ArrayRef<Value> ref(Int offset, Int size) {
-    return ArrayRef<Value>(values_.data() + offset, size);
-  }
-
-  Value get(Int i) const {
-    return values_[i];
-  }
-  void set(Int i, Value value) {
-    values_[i] = value;
-  }
-
-  Value &operator[](Int i) {
-    return values_[static_cast<size_t>(i)];
-  }
-  const Value &operator[](Int i) const {
-    return values_[static_cast<size_t>(i)];
-  }
-
-  Value &front() {
-    return values_.front();
-  }
-  const Value &front() const {
-    return values_.front();
-  }
-
-  Value &back() {
-    return values_.back();
-  }
-  const Value &back() const {
-    return values_.back();
-  }
-
-  Value *data() {
-    return values_.data();
-  }
-  const Value *data() const {
-    return values_.data();
-  }
-
-  Int size() const {
-    return static_cast<Int>(values_.size());
-  }
-  Int capacity() const {
-    return static_cast<Int>(values_.capacity());
-  }
-
-  bool reserve(Error *error, Int new_size) try {
-    values_.reserve(new_size);
-    return true;
-  } catch (...) {
-    ArrayErrorReporter::report_memory_error(error);
-    return false;
-  }
-
-  bool resize(Error *error, Int new_size) try {
-    values_.resize(new_size);
-    return true;
-  } catch (...) {
-    ArrayErrorReporter::report_memory_error(error);
-    return false;
-  }
-  bool resize(Error *error, Int new_size, const Value &value) try {
-    values_.resize(new_size, value);
-    return true;
-  } catch (...) {
-    ArrayErrorReporter::report_memory_error(error);
-    return false;
-  }
-
-  bool shrink_to_fit(Error *error) try {
-    values_.shrink_to_fit();
-    return true;
-  } catch (...) {
-    ArrayErrorReporter::report_memory_error(error);
-    return false;
-  }
-
-  void clear() {
-    values_.clear();
-  }
-
-  void erase(Int i) {
-    values_.erase(values_.begin() + i);
-  }
-
-  bool push_back(Error *error, const Value &value) try {
-    values_.push_back(value);
-    return true;
-  } catch (...) {
-    ArrayErrorReporter::report_memory_error(error);
-    return false;
-  }
-  bool push_back(Error *error, Value &&value) try {
-    values_.push_back(std::move(value));
-    return true;
-  } catch (...) {
-    ArrayErrorReporter::report_memory_error(error);
-    return false;
-  }
-  void pop_back() {
-    values_.pop_back();
-  }
-
-  void swap(Int i, Int j) {
-    std::swap(values_[i], values_[j]);
-  }
+namespace grnxx {
 
- private:
-  std::vector<Value> values_;
-};
+//class ArrayErrorReporter {
+// public:
+//  static void report_memory_error(Error *error);
+//};
+
+//template <typename T> class ArrayCRef;
+//template <typename T> class ArrayRef;
+//template <typename T> class Array;
+
+//template <typename T>
+//class ArrayCRef {
+// public:
+//  using Value = T;
+
+//  ArrayCRef() = default;
+//  ArrayCRef(const ArrayCRef &) = default;
+
+//  ArrayCRef &operator=(const ArrayCRef &) = default;
+
+//  bool operator==(ArrayCRef<Value> rhs) const {
+//    return (values_ == rhs.values_) && (size_ == rhs.size_);
+//  }
+//  bool operator!=(ArrayCRef<Value> rhs) const {
+//    return (values_ != rhs.values_) || (size_ != rhs.size_);
+//  }
+
+//  ArrayCRef ref(Int offset = 0) const {
+//    return ArrayCRef(values_ + offset, size_ - offset);
+//  }
+//  ArrayCRef ref(Int offset, Int size) const {
+//    return ArrayCRef(values_ + offset, size);
+//  }
+
+//  Value get(Int i) const {
+//    return values_[i];
+//  }
+
+//  const Value &operator[](Int i) const {
+//    return values_[i];
+//  }
+
+//  Int size() const {
+//    return size_;
+//  }
+
+// private:
+//  const Value *values_;
+//  Int size_;
+
+//  ArrayCRef(const Value *values, Int size) : values_(values), size_(size) {}
+
+//  friend class ArrayRef<Value>;
+//  friend class Array<Value>;
+//};
+
+//template <typename T>
+//class ArrayRef {
+// public:
+//  using Value = T;
+
+//  ArrayRef() = default;
+//  ArrayRef(const ArrayRef &) = default;
+
+//  ArrayRef &operator=(const ArrayRef &) = default;
+
+//  operator ArrayCRef<Value>() const {
+//    return ref();
+//  }
+
+//  bool operator==(ArrayCRef<Value> rhs) const {
+//    return (values_ == rhs.values_) && (size_ == rhs.size_);
+//  }
+//  bool operator==(ArrayRef<Value> rhs) const {
+//    return (values_ == rhs.values_) && (size_ == rhs.size_);
+//  }
+
+//  bool operator!=(ArrayCRef<Value> rhs) const {
+//    return (values_ != rhs.values_) || (size_ != rhs.size_);
+//  }
+//  bool operator!=(ArrayRef<Value> rhs) const {
+//    return (values_ != rhs.values_) || (size_ != rhs.size_);
+//  }
+
+//  ArrayCRef<Value> ref(Int offset = 0) const {
+//    return ArrayCRef<Value>(values_ + offset, size_ - offset);
+//  }
+//  ArrayCRef<Value> ref(Int offset, Int size) const {
+//    return ArrayCRef<Value>(values_ + offset, size);
+//  }
+
+//  ArrayRef ref(Int offset = 0) {
+//    return ArrayRef(values_ + offset, size_ - offset);
+//  }
+//  ArrayRef ref(Int offset, Int size) {
+//    return ArrayRef(values_ + offset, size);
+//  }
+
+//  Value get(Int i) const {
+//    return values_[i];
+//  }
+//  void set(Int i, Value value) {
+//    values_[i] = value;
+//  }
+
+//  Value &operator[](Int i) {
+//    return values_[i];
+//  }
+//  const Value &operator[](Int i) const {
+//    return values_[i];
+//  }
+
+//  Int size() const {
+//    return size_;
+//  }
+
+//  void swap(Int i, Int j) {
+//    std::swap(values_[i], values_[j]);
+//  }
+
+// private:
+//  Value *values_;
+//  Int size_;
+
+//  ArrayRef(Value *values, Int size) : values_(values), size_(size) {}
+
+//  friend class Array<Value>;
+//};
+
+//template <typename T>
+//inline bool operator==(ArrayCRef<T> lhs, ArrayRef<T> rhs) {
+//  return rhs == lhs;
+//}
+//template <typename T>
+//inline bool operator!=(ArrayCRef<T> lhs, ArrayRef<T> rhs) {
+//  return rhs != lhs;
+//}
+
+//template <typename T>
+//class Array {
+// public:
+//  using Value = T;
+
+//  Array() : values_() {}
+//  ~Array() {}
+
+//  Array(Array &&array) : values_(std::move(array.values_)) {}
+
+//  Array &operator=(Array &&array) {
+//    values_ = std::move(array.values_);
+//    return *this;
+//  }
+
+//  operator ArrayCRef<Value>() const {
+//    return ref();
+//  }
+//  operator ArrayRef<Value>() {
+//    return ref();
+//  }
+
+//  ArrayCRef<Value> ref(Int offset = 0) const {
+//    return ArrayCRef<Value>(values_.data() + offset, size() - offset);
+//  }
+//  ArrayCRef<Value> ref(Int offset, Int size) const {
+//    return ArrayCRef<Value>(values_.data() + offset, size);
+//  }
+
+//  ArrayRef<Value> ref(Int offset = 0) {
+//    return ArrayRef<Value>(values_.data() + offset, size() - offset);
+//  }
+//  ArrayRef<Value> ref(Int offset, Int size) {
+//    return ArrayRef<Value>(values_.data() + offset, size);
+//  }
+
+//  Value get(Int i) const {
+//    return values_[i];
+//  }
+//  void set(Int i, Value value) {
+//    values_[i] = value;
+//  }
+
+//  Value &operator[](Int i) {
+//    return values_[static_cast<size_t>(i)];
+//  }
+//  const Value &operator[](Int i) const {
+//    return values_[static_cast<size_t>(i)];
+//  }
+
+//  Value &front() {
+//    return values_.front();
+//  }
+//  const Value &front() const {
+//    return values_.front();
+//  }
+
+//  Value &back() {
+//    return values_.back();
+//  }
+//  const Value &back() const {
+//    return values_.back();
+//  }
+
+//  Value *data() {
+//    return values_.data();
+//  }
+//  const Value *data() const {
+//    return values_.data();
+//  }
+
+//  Int size() const {
+//    return static_cast<Int>(values_.size());
+//  }
+//  Int capacity() const {
+//    return static_cast<Int>(values_.capacity());
+//  }
+
+//  bool reserve(Error *error, Int new_size) try {
+//    values_.reserve(new_size);
+//    return true;
+//  } catch (...) {
+//    ArrayErrorReporter::report_memory_error(error);
+//    return false;
+//  }
+
+//  bool resize(Error *error, Int new_size) try {
+//    values_.resize(new_size);
+//    return true;
+//  } catch (...) {
+//    ArrayErrorReporter::report_memory_error(error);
+//    return false;
+//  }
+//  bool resize(Error *error, Int new_size, const Value &value) try {
+//    values_.resize(new_size, value);
+//    return true;
+//  } catch (...) {
+//    ArrayErrorReporter::report_memory_error(error);
+//    return false;
+//  }
+
+//  bool shrink_to_fit(Error *error) try {
+//    values_.shrink_to_fit();
+//    return true;
+//  } catch (...) {
+//    ArrayErrorReporter::report_memory_error(error);
+//    return false;
+//  }
+
+//  void clear() {
+//    values_.clear();
+//  }
+
+//  void erase(Int i) {
+//    values_.erase(values_.begin() + i);
+//  }
+
+//  bool push_back(Error *error, const Value &value) try {
+//    values_.push_back(value);
+//    return true;
+//  } catch (...) {
+//    ArrayErrorReporter::report_memory_error(error);
+//    return false;
+//  }
+//  bool push_back(Error *error, Value &&value) try {
+//    values_.push_back(std::move(value));
+//    return true;
+//  } catch (...) {
+//    ArrayErrorReporter::report_memory_error(error);
+//    return false;
+//  }
+//  void pop_back() {
+//    values_.pop_back();
+//  }
+
+//  void swap(Int i, Int j) {
+//    std::swap(values_[i], values_[j]);
+//  }
+
+// private:
+//  std::vector<Value> values_;
+//};
 
 template <>
 class ArrayCRef<Record> {

  Modified: include/grnxx/array/Makefile.am (+2 -1)
===================================================================
--- include/grnxx/array/Makefile.am    2014-09-05 14:46:23 +0900 (48cda4d)
+++ include/grnxx/array/Makefile.am    2014-09-05 16:45:28 +0900 (0823624)
@@ -1,3 +1,4 @@
 pkgincludedir = ${includedir}/${PACKAGE}/array
 pkginclude_HEADERS =	\
-	bool.hpp
+	bool.hpp	\
+	primary.hpp

  Added: include/grnxx/array/primary.hpp (+286 -0) 100644
===================================================================
--- /dev/null
+++ include/grnxx/array/primary.hpp    2014-09-05 16:45:28 +0900 (5b53209)
@@ -0,0 +1,286 @@
+#ifndef GRNXX_ARRAY_PRIMARY_HPP
+#define GRNXX_ARRAY_PRIMARY_HPP
+
+#include "grnxx/types.hpp"
+
+namespace grnxx {
+
+class ArrayErrorReporter {
+ public:
+  static void report_memory_error(Error *error);
+};
+
+template <typename T> class ArrayCRef;
+template <typename T> class ArrayRef;
+template <typename T> class Array;
+
+template <typename T>
+class ArrayCRef {
+ public:
+  using Value = T;
+
+  ArrayCRef() = default;
+  ArrayCRef(const ArrayCRef &) = default;
+
+  ArrayCRef &operator=(const ArrayCRef &) = default;
+
+  bool operator==(const ArrayCRef<Value> &rhs) const {
+    return (values_ == rhs.values_) && (size_ == rhs.size_);
+  }
+  bool operator!=(const ArrayCRef<Value> &rhs) const {
+    return (values_ != rhs.values_) || (size_ != rhs.size_);
+  }
+
+  ArrayCRef ref(Int offset = 0) const {
+    return ArrayCRef(values_ + offset, size_ - offset);
+  }
+  ArrayCRef ref(Int offset, Int size) const {
+    return ArrayCRef(values_ + offset, size);
+  }
+
+  const Value &get(Int i) const {
+    return values_[i];
+  }
+
+  const Value &operator[](Int i) const {
+    return values_[i];
+  }
+
+  Int size() const {
+    return size_;
+  }
+
+ private:
+  const Value *values_;
+  Int size_;
+
+  ArrayCRef(const Value *values, Int size) : values_(values), size_(size) {}
+
+  friend class ArrayRef<Value>;
+  friend class Array<Value>;
+};
+
+template <typename T>
+class ArrayRef {
+ public:
+  using Value = T;
+
+  ArrayRef() = default;
+  ArrayRef(const ArrayRef &) = default;
+
+  ArrayRef &operator=(const ArrayRef &) = default;
+
+  operator ArrayCRef<Value>() const {
+    return ref();
+  }
+
+  bool operator==(const ArrayCRef<Value> &rhs) const {
+    return (values_ == rhs.values_) && (size_ == rhs.size_);
+  }
+  bool operator==(const ArrayRef<Value> &rhs) const {
+    return (values_ == rhs.values_) && (size_ == rhs.size_);
+  }
+
+  bool operator!=(const ArrayCRef<Value> &rhs) const {
+    return (values_ != rhs.values_) || (size_ != rhs.size_);
+  }
+  bool operator!=(const ArrayRef<Value> &rhs) const {
+    return (values_ != rhs.values_) || (size_ != rhs.size_);
+  }
+
+  ArrayCRef<Value> ref(Int offset = 0) const {
+    return ArrayCRef<Value>(values_ + offset, size_ - offset);
+  }
+  ArrayCRef<Value> ref(Int offset, Int size) const {
+    return ArrayCRef<Value>(values_ + offset, size);
+  }
+
+  ArrayRef ref(Int offset = 0) {
+    return ArrayRef(values_ + offset, size_ - offset);
+  }
+  ArrayRef ref(Int offset, Int size) {
+    return ArrayRef(values_ + offset, size);
+  }
+
+  const Value &get(Int i) const {
+    return values_[i];
+  }
+  void set(Int i, const Value &value) {
+    values_[i] = value;
+  }
+  void set(Int i, Value &&value) {
+    values_[i] = std::move(value);
+  }
+
+  Value &operator[](Int i) {
+    return values_[i];
+  }
+  const Value &operator[](Int i) const {
+    return values_[i];
+  }
+
+  Int size() const {
+    return size_;
+  }
+
+  void swap(Int i, Int j) {
+    Value temp = std::move(values_[i]);
+    values_[i] = std::move(values_[j]);
+    values_[j] = std::move(temp);
+  }
+
+ private:
+  Value *values_;
+  Int size_;
+
+  ArrayRef(Value *values, Int size) : values_(values), size_(size) {}
+
+  friend class Array<Value>;
+};
+
+template <typename T>
+class Array {
+ public:
+  using Value = T;
+
+  Array() : values_() {}
+  ~Array() {}
+
+  Array(Array &&array) : values_(std::move(array.values_)) {}
+
+  Array &operator=(Array &&array) {
+    values_ = std::move(array.values_);
+    return *this;
+  }
+
+  operator ArrayCRef<Value>() const {
+    return ref();
+  }
+
+  ArrayCRef<Value> ref(Int offset = 0) const {
+    return ArrayCRef<Value>(values_.data() + offset, size() - offset);
+  }
+  ArrayCRef<Value> ref(Int offset, Int size) const {
+    return ArrayCRef<Value>(values_.data() + offset, size);
+  }
+
+  ArrayRef<Value> ref(Int offset = 0) {
+    return ArrayRef<Value>(values_.data() + offset, size() - offset);
+  }
+  ArrayRef<Value> ref(Int offset, Int size) {
+    return ArrayRef<Value>(values_.data() + offset, size);
+  }
+
+  const Value &get(Int i) const {
+    return values_[i];
+  }
+  void set(Int i, const Value &value) {
+    values_[i] = value;
+  }
+  void set(Int i, Value &&value) {
+    values_[i] = value;
+  }
+
+  Value &operator[](Int i) {
+    return values_[static_cast<size_t>(i)];
+  }
+  const Value &operator[](Int i) const {
+    return values_[static_cast<size_t>(i)];
+  }
+
+  Value &front() {
+    return values_.front();
+  }
+  const Value &front() const {
+    return values_.front();
+  }
+
+  Value &back() {
+    return values_.back();
+  }
+  const Value &back() const {
+    return values_.back();
+  }
+
+  Value *data() {
+    return values_.data();
+  }
+  const Value *data() const {
+    return values_.data();
+  }
+
+  Int size() const {
+    return static_cast<Int>(values_.size());
+  }
+  Int capacity() const {
+    return static_cast<Int>(values_.capacity());
+  }
+
+  bool reserve(Error *error, Int new_size) try {
+    values_.reserve(new_size);
+    return true;
+  } catch (...) {
+    ArrayErrorReporter::report_memory_error(error);
+    return false;
+  }
+
+  bool resize(Error *error, Int new_size) try {
+    values_.resize(new_size);
+    return true;
+  } catch (...) {
+    ArrayErrorReporter::report_memory_error(error);
+    return false;
+  }
+  bool resize(Error *error, Int new_size, const Value &value) try {
+    values_.resize(new_size, value);
+    return true;
+  } catch (...) {
+    ArrayErrorReporter::report_memory_error(error);
+    return false;
+  }
+
+  bool shrink_to_fit(Error *error) try {
+    values_.shrink_to_fit();
+    return true;
+  } catch (...) {
+    ArrayErrorReporter::report_memory_error(error);
+    return false;
+  }
+
+  void clear() {
+    values_.clear();
+  }
+
+  void erase(Int i) {
+    values_.erase(values_.begin() + i);
+  }
+
+  bool push_back(Error *error, const Value &value) try {
+    values_.push_back(value);
+    return true;
+  } catch (...) {
+    ArrayErrorReporter::report_memory_error(error);
+    return false;
+  }
+  bool push_back(Error *error, Value &&value) try {
+    values_.push_back(std::move(value));
+    return true;
+  } catch (...) {
+    ArrayErrorReporter::report_memory_error(error);
+    return false;
+  }
+  void pop_back() {
+    values_.pop_back();
+  }
+
+  void swap(Int i, Int j) {
+    std::swap(values_[i], values_[j]);
+  }
+
+ private:
+  std::vector<Value> values_;
+};
+
+}  // namespace grnxx
+
+#endif  // GRNXX_ARRAY_PRIMARY_HPP
-------------- next part --------------
HTML����������������������������...
Download 

• Previous message: [Groonga-commit] droonga/droonga-engine at 4ce1e25 [master] Fix typo
• Next message: [Groonga-commit] droonga/droonga-engine at d4e2966 [master] Call given block directly instead of yield.
• Messages sorted by: [ date ] [ thread ] [ subject ] [ author ]