susumu.yata
null+****@clear*****
Fri Aug 8 12:28:32 JST 2014
susumu.yata 2014-08-08 12:28:32 +0900 (Fri, 08 Aug 2014) New Revision: b5ce769df4bc62a02bec9eb4fcd56e2cce99e0db https://github.com/groonga/grnxx/commit/b5ce769df4bc62a02bec9eb4fcd56e2cce99e0db Message: Rename Subarray to ArrayRef. Modified files: include/grnxx/array.hpp include/grnxx/expression.hpp lib/grnxx/expression.cpp lib/grnxx/expression2.cpp Modified: include/grnxx/array.hpp (+29 -29) =================================================================== --- include/grnxx/array.hpp 2014-08-07 16:38:30 +0900 (0b91433) +++ include/grnxx/array.hpp 2014-08-08 12:28:32 +0900 (0189126) @@ -13,19 +13,19 @@ class ArrayErrorReporter { }; template <typename T> -class Subarray { +class ArrayRef { public: - Subarray() = default; - Subarray(T *values, Int size) : values_(values), size_(size) {} - Subarray(const Subarray &) = default; + ArrayRef() = default; + ArrayRef(T *values, Int size) : values_(values), size_(size) {} + ArrayRef(const ArrayRef &) = default; - Subarray &operator=(const Subarray &) = default; + ArrayRef &operator=(const ArrayRef &) = default; - Subarray subarray(Int offset = 0) const { - return Subarray(values_ + offset, size_ - offset); + ArrayRef ref(Int offset = 0) const { + return ArrayRef(values_ + offset, size_ - offset); } - Subarray subarray(Int offset, Int size) const { - return Subarray(values_ + offset, size); + ArrayRef ref(Int offset, Int size) const { + return ArrayRef(values_ + offset, size); } T &operator[](Int i) { @@ -57,11 +57,11 @@ class Array { return *this; } - Subarray<T> subarray(Int offset = 0) const { - return Subarray<T>(const_cast<T *>(data()) + offset, size() - offset); + ArrayRef<T> ref(Int offset = 0) const { + return ArrayRef<T>(const_cast<T *>(data()) + offset, size() - offset); } - Subarray<T> subarray(Int offset, Int size) const { - return Subarray<T>(const_cast<T *>(data()) + offset, size); + ArrayRef<T> ref(Int offset, Int size) const { + return ArrayRef<T>(const_cast<T *>(data()) + offset, size); } T &operator[](Int i) { @@ -200,27 +200,27 @@ inline bool operator!=(const BoolReference &lhs, Bool rhs) { return static_cast<Bool>(lhs) != rhs; } -// Subarray<Bool> is specialized because a bit does not have its own unique -// address and thus a pointer type for Bool is not a available. +// ArrayRef<Bool> is specialized because a bit does not have its own unique +// address and thus a pointer type for Bool is not available. template <> -class Subarray<Bool> { +class ArrayRef<Bool> { public: - Subarray() = default; - Subarray(uint64_t *blocks, Int offset, Int size) + ArrayRef() = default; + ArrayRef(uint64_t *blocks, Int offset, Int size) : blocks_(blocks + (offset / 64)), offset_(static_cast<uint64_t>(offset % 64)), size_(static_cast<uint64_t>(size)) {} - Subarray(const Subarray &) = default; + ArrayRef(const ArrayRef &) = default; - Subarray &operator=(const Subarray &) = default; + ArrayRef &operator=(const ArrayRef &) = default; - Subarray subarray(Int offset = 0) const { + ArrayRef ref(Int offset = 0) const { offset += static_cast<Int>(offset_); - return Subarray(blocks_, offset, size() - offset); + return ArrayRef(blocks_, offset, size() - offset); } - Subarray subarray(Int offset, Int size) const { + ArrayRef ref(Int offset, Int size) const { offset += static_cast<Int>(offset_); - return Subarray(blocks_, offset, size); + return ArrayRef(blocks_, offset, size); } BoolReference operator[](Int i) { @@ -253,7 +253,7 @@ class Subarray<Bool> { }; // Array<Bool> is specialized because a bit does not have its own unique -// address and thus a pointer type for Bool is not a available. +// address and thus a pointer type for Bool is not available. template <> class Array<Bool> { public: @@ -267,12 +267,12 @@ class Array<Bool> { return *this; } - Subarray<Bool> subarray(Int offset = 0) const { - return Subarray<Bool>(const_cast<uint64_t *>(blocks()), + ArrayRef<Bool> ref(Int offset = 0) const { + return ArrayRef<Bool>(const_cast<uint64_t *>(blocks()), offset, size() - offset); } - Subarray<Bool> subarray(Int offset, Int size) const { - return Subarray<Bool>(const_cast<uint64_t *>(blocks()), offset, size); + ArrayRef<Bool> ref(Int offset, Int size) const { + return ArrayRef<Bool>(const_cast<uint64_t *>(blocks()), offset, size); } BoolReference operator[](Int i) { Modified: include/grnxx/expression.hpp (+2 -2) =================================================================== --- include/grnxx/expression.hpp 2014-08-07 16:38:30 +0900 (71fdda6) +++ include/grnxx/expression.hpp 2014-08-08 12:28:32 +0900 (d103ced) @@ -129,7 +129,7 @@ class Expression { template <typename T> bool evaluate(Error *error, const RecordSubset &record_set, - Subarray<T> *results); + ArrayRef<T> *results); private: const Table *table_; @@ -140,7 +140,7 @@ class Expression { template <typename T> bool evaluate_block(Error *error, const RecordSubset &record_set, - Subarray<T> *results); + ArrayRef<T> *results); }; class ExpressionBuilder { Modified: lib/grnxx/expression.cpp (+10 -10) =================================================================== --- lib/grnxx/expression.cpp 2014-08-07 16:38:30 +0900 (8a6c2c0) +++ lib/grnxx/expression.cpp 2014-08-08 12:28:32 +0900 (a3320aa) @@ -690,12 +690,12 @@ bool LogicalOrNode::filter(Error *error, left_count = 0; right_count = 0; for (Int i = 0; i < input_records.size(); ++i) { - if (input_records.get(i).row_id == - left_record_set_.get(left_count).row_id) { + if (input_records.get_row_id(i) == + left_record_set_.get_row_id(left_count)) { output_records->set(left_count + right_count, input_records.get(i)); ++left_count; - } else if (input_records.get(i).row_id == - right_record_set_.get(right_count).row_id) { + } else if (input_records.get_row_id(i) == + right_record_set_.get_row_id(right_count)) { output_records->set(left_count + right_count, input_records.get(i)); ++right_count; } @@ -804,8 +804,8 @@ bool Expression::evaluate(Error *error, if (!results->resize(error, record_set.size())) { return false; } - Subarray<T> subarray = results->subarray(); - return evaluate(error, record_set, &subarray); + ArrayRef<T> ref = results->ref(); + return evaluate(error, record_set, &ref); } template bool Expression::evaluate(Error *error, @@ -830,7 +830,7 @@ template bool Expression::evaluate(Error *error, template <typename T> bool Expression::evaluate(Error *error, const RecordSubset &record_set, - Subarray<T> *results) { + ArrayRef<T> *results) { if (TypeTraits<T>::data_type() != data_type()) { GRNXX_ERROR_SET(error, INVALID_ARGUMENT, "Invalid data type"); return false; @@ -842,14 +842,14 @@ bool Expression::evaluate(Error *error, return false; } RecordSubset input = record_set; - Subarray<T> output = *results; + ArrayRef<T> output = *results; while (input.size() > block_size()) { RecordSubset subset = input.subset(0, block_size()); if (!evaluate_block(error, subset, &output)) { return false; } input = input.subset(block_size()); - output = output.subarray(block_size()); + output = output.ref(block_size()); } return evaluate_block(error, input, &output); } @@ -861,7 +861,7 @@ Expression::Expression(const Table *table, unique_ptr<ExpressionNode> &&root) template <typename T> bool Expression::evaluate_block(Error *error, const RecordSubset &record_set, - Subarray<T> *results) { + ArrayRef<T> *results) { Node<T> *node = static_cast<Node<T> *>(root_.get()); if (!node->evaluate(error, record_set)) { return false; Modified: lib/grnxx/expression2.cpp (+31 -31) =================================================================== --- lib/grnxx/expression2.cpp 2014-08-07 16:38:30 +0900 (4b8a5d9) +++ lib/grnxx/expression2.cpp 2014-08-08 12:28:32 +0900 (b9dbdb8) @@ -88,7 +88,7 @@ class TypedNode : public Node { // "error" != nullptr. virtual bool evaluate(Error *error, const RecordSubset &records, - Subarray<Value> *results) = 0; + ArrayRef<Value> *results) = 0; }; template <typename T> @@ -109,7 +109,7 @@ bool TypedNode<Bool>::filter(Error *error, if (!results.resize(error, input_records.size())) { return false; } - Subarray<Bool> results_ref = results.subarray(); + ArrayRef<Bool> results_ref = results.ref(); if (!evaluate(error, input_records, &results_ref)) { return false; } @@ -139,7 +139,7 @@ bool TypedNode<Float>::adjust(Error *error, RecordSubset *records) { if (!scores.resize(error, records->size())) { return false; } - Subarray<Float> scores_ref = scores.subarray(); + ArrayRef<Float> scores_ref = scores.ref(); if (!evaluate(error, *records, &scores_ref)) { return false; } @@ -166,7 +166,7 @@ class DatumNode : public TypedNode<T> { bool evaluate(Error *error, const RecordSubset &records, - Subarray<Value> *results); + ArrayRef<Value> *results); private: T datum_; @@ -175,7 +175,7 @@ class DatumNode : public TypedNode<T> { template <typename T> bool DatumNode<T>::evaluate(Error *error, const RecordSubset &records, - Subarray<Value> *results) { + ArrayRef<Value> *results) { for (Int i = 0; i < records.size(); ++i) { (*results)[i] = datum_; } @@ -200,7 +200,7 @@ class DatumNode<Bool> : public TypedNode<Bool> { RecordSubset *output_records); bool evaluate(Error *error, const RecordSubset &records, - Subarray<Bool> *results); + ArrayRef<Bool> *results); private: Bool datum_; @@ -223,7 +223,7 @@ bool DatumNode<Bool>::filter(Error *error, bool DatumNode<Bool>::evaluate(Error *error, const RecordSubset &records, - Subarray<Bool> *results) { + ArrayRef<Bool> *results) { // TODO: Fill results per 64 bits. for (Int i = 0; i < records.size(); ++i) { (*results)[i] = datum_; @@ -247,7 +247,7 @@ class DatumNode<Float> : public TypedNode<Float> { bool adjust(Error *error, RecordSubset *records); bool evaluate(Error *error, const RecordSubset &records, - Subarray<Float> *results); + ArrayRef<Float> *results); private: Float datum_; @@ -262,7 +262,7 @@ bool DatumNode<Float>::adjust(Error *error, RecordSubset *records) { bool DatumNode<Float>::evaluate(Error *error, const RecordSubset &records, - Subarray<Float> *results) { + ArrayRef<Float> *results) { for (Int i = 0; i < records.size(); ++i) { (*results)[i] = datum_; } @@ -285,7 +285,7 @@ class DatumNode<Text> : public TypedNode<Text> { bool evaluate(Error *error, const RecordSubset &records, - Subarray<Text> *results); + ArrayRef<Text> *results); private: std::string datum_; @@ -293,7 +293,7 @@ class DatumNode<Text> : public TypedNode<Text> { bool DatumNode<Text>::evaluate(Error *error, const RecordSubset &records, - Subarray<Text> *results) { + ArrayRef<Text> *results) { Text datum = Text(datum_.data(), datum_.size()); for (Int i = 0; i < records.size(); ++i) { (*results)[i] = datum; @@ -316,12 +316,12 @@ class RowIDNode : public TypedNode<Int> { bool evaluate(Error *error, const RecordSubset &records, - Subarray<Int> *results); + ArrayRef<Int> *results); }; bool RowIDNode::evaluate(Error *error, const RecordSubset &records, - Subarray<Int> *results) { + ArrayRef<Int> *results) { for (Int i = 0; i < records.size(); ++i) { (*results)[i] = records.get_row_id(i); } @@ -343,7 +343,7 @@ class ScoreNode : public TypedNode<Float> { bool adjust(Error *error, RecordSubset *records); bool evaluate(Error *error, const RecordSubset &records, - Subarray<Float> *results); + ArrayRef<Float> *results); }; bool ScoreNode::adjust(Error *error, RecordSubset *records) { @@ -353,7 +353,7 @@ bool ScoreNode::adjust(Error *error, RecordSubset *records) { bool ScoreNode::evaluate(Error *error, const RecordSubset &records, - Subarray<Float> *results) { + ArrayRef<Float> *results) { for (Int i = 0; i < records.size(); ++i) { (*results)[i] = records.get_score(i); } @@ -377,7 +377,7 @@ class ColumnNode : public TypedNode<T> { bool evaluate(Error *error, const RecordSubset &records, - Subarray<Value> *results); + ArrayRef<Value> *results); private: const ColumnImpl<T> *column_; @@ -386,7 +386,7 @@ class ColumnNode : public TypedNode<T> { template <typename T> bool ColumnNode<T>::evaluate(Error *error, const RecordSubset &records, - Subarray<Value> *results) { + ArrayRef<Value> *results) { for (Int i = 0; i < records.size(); ++i) { (*results)[i] = column_->get(records.get_row_id(i)); } @@ -411,7 +411,7 @@ class ColumnNode<Bool> : public TypedNode<Bool> { RecordSubset *output_records); bool evaluate(Error *error, const RecordSubset &records, - Subarray<Bool> *results); + ArrayRef<Bool> *results); private: const ColumnImpl<Bool> *column_; @@ -433,7 +433,7 @@ bool ColumnNode<Bool>::filter(Error *error, bool ColumnNode<Bool>::evaluate(Error *error, const RecordSubset &records, - Subarray<Bool> *results) { + ArrayRef<Bool> *results) { for (Int i = 0; i < records.size(); ++i) { (*results)[i] = column_->get(records.get_row_id(i)); } @@ -456,7 +456,7 @@ class ColumnNode<Float> : public TypedNode<Float> { bool adjust(Error *error, RecordSubset *records); bool evaluate(Error *error, const RecordSubset &records, - Subarray<Float> *results); + ArrayRef<Float> *results); private: const ColumnImpl<Float> *column_; @@ -471,7 +471,7 @@ bool ColumnNode<Float>::adjust(Error *error, RecordSubset *records) { bool ColumnNode<Float>::evaluate(Error *error, const RecordSubset &records, - Subarray<Float> *results) { + ArrayRef<Float> *results) { for (Int i = 0; i < records.size(); ++i) { (*results)[i] = column_->get(records.get_row_id(i)); } @@ -512,16 +512,16 @@ bool fill_node_arg_values(Error *error, const RecordSubset &records, switch (arg->node_type()) { case DATUM_NODE: { if (old_size < records.size()) { - Subarray<T> subarray = arg_values->subarray(old_size); - if (!arg->evaluate(error, records.subset(old_size), &subarray)) { + ArrayRef<T> ref = arg_values->ref(old_size); + if (!arg->evaluate(error, records.subset(old_size), &ref)) { return false; } } break; } default: { - Subarray<T> subarray = arg_values->subarray(0, records.size()); - if (!arg->evaluate(error, records, &subarray)) { + ArrayRef<T> ref = arg_values->ref(0, records.size()); + if (!arg->evaluate(error, records, &ref)) { return false; } } @@ -567,7 +567,7 @@ class LogicalNotNode : public UnaryNode<Bool, Bool> { RecordSubset *output_records); bool evaluate(Error *error, const RecordSubset &records, - Subarray<Bool> *results); + ArrayRef<Bool> *results); private: RecordSet temp_records_; @@ -607,7 +607,7 @@ bool LogicalNotNode::filter(Error *error, bool LogicalNotNode::evaluate(Error *error, const RecordSubset &records, - Subarray<Bool> *results) { + ArrayRef<Bool> *results) { if (!arg_->evaluate(error, records, results)) { return false; } @@ -633,7 +633,7 @@ class BitwiseNotNode : public UnaryNode<Bool, Bool> { RecordSubset *output_records); bool evaluate(Error *error, const RecordSubset &records, - Subarray<Bool> *results); + ArrayRef<Bool> *results); }; bool BitwiseNotNode::filter(Error *error, @@ -655,7 +655,7 @@ bool BitwiseNotNode::filter(Error *error, bool BitwiseNotNode::evaluate(Error *error, const RecordSubset &records, - Subarray<Bool> *results) { + ArrayRef<Bool> *results) { if (!arg_->evaluate(error, records, results)) { return false; } @@ -722,7 +722,7 @@ class LogicalAndNode : public BinaryNode<Bool, Bool, Bool> { RecordSubset *output_records); bool evaluate(Error *error, const RecordSubset &records, - Subarray<Bool> *results); + ArrayRef<Bool> *results); private: RecordSet temp_records_; @@ -737,7 +737,7 @@ bool LogicalAndNode::filter(Error *error, bool LogicalAndNode::evaluate(Error *error, const RecordSubset &records, - Subarray<Bool> *results) { + ArrayRef<Bool> *results) { // TODO return false; } -------------- next part -------------- HTML����������������������������...Download