From 8a5d6dee3c0ae34ddb6447cc1b65d7e39ef77b67 Mon Sep 17 00:00:00 2001 From: Daniel Bevenius Date: Fri, 2 Mar 2018 11:46:20 +0100 Subject: [PATCH] src: add incr/decr operators for Reference MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit This commit adds operator overloads for increment/decrement to AliasedBuffer::Reference. The motivation for doing this is to hopefully make code that needs to increment/decrement a little simpler. PR-URL: https://github.com/nodejs/node/pull/19083 Reviewed-By: James M Snell Reviewed-By: Anna Henningsen Reviewed-By: Tobias Nießen Reviewed-By: Colin Ihrig Reviewed-By: Tiancheng "Timothy" Gu --- src/aliased_buffer.h | 16 ++++++++++++++++ src/env-inl.h | 16 +++++++--------- test/cctest/test_aliased_buffer.cc | 30 ++++++++++++++++++++++++++++++ 3 files changed, 53 insertions(+), 9 deletions(-) diff --git a/src/aliased_buffer.h b/src/aliased_buffer.h index b99b01f5d94ca2..8b103f4949030c 100644 --- a/src/aliased_buffer.h +++ b/src/aliased_buffer.h @@ -141,6 +141,22 @@ class AliasedBuffer { return aliased_buffer_->GetValue(index_); } + template + inline Reference& operator+=(const T& val) { + const T current = aliased_buffer_->GetValue(index_); + aliased_buffer_->SetValue(index_, current + val); + return *this; + } + + inline Reference& operator+=(const Reference& val) { + return this->operator+=(static_cast(val)); + } + + template + inline Reference& operator-=(const T& val) { + return this->operator+=(-val); + } + private: AliasedBuffer* aliased_buffer_; size_t index_; diff --git a/src/env-inl.h b/src/env-inl.h index f647f428c324ff..a3c57ecfda2f14 100644 --- a/src/env-inl.h +++ b/src/env-inl.h @@ -111,8 +111,7 @@ inline v8::Local Environment::AsyncHooks::provider_string(int idx) { } inline void Environment::AsyncHooks::no_force_checks() { - // fields_ does not have the -= operator defined - fields_[kCheck] = fields_[kCheck] - 1; + fields_[kCheck] -= 1; } inline Environment* Environment::AsyncHooks::env() { @@ -134,7 +133,7 @@ inline void Environment::AsyncHooks::push_async_ids(double async_id, grow_async_ids_stack(); async_ids_stack_[2 * offset] = async_id_fields_[kExecutionAsyncId]; async_ids_stack_[2 * offset + 1] = async_id_fields_[kTriggerAsyncId]; - fields_[kStackLength] = fields_[kStackLength] + 1; + fields_[kStackLength] += 1; async_id_fields_[kExecutionAsyncId] = async_id; async_id_fields_[kTriggerAsyncId] = trigger_async_id; } @@ -238,19 +237,19 @@ inline bool Environment::ImmediateInfo::has_outstanding() const { } inline void Environment::ImmediateInfo::count_inc(uint32_t increment) { - fields_[kCount] = fields_[kCount] + increment; + fields_[kCount] += increment; } inline void Environment::ImmediateInfo::count_dec(uint32_t decrement) { - fields_[kCount] = fields_[kCount] - decrement; + fields_[kCount] -= decrement; } inline void Environment::ImmediateInfo::ref_count_inc(uint32_t increment) { - fields_[kRefCount] = fields_[kRefCount] + increment; + fields_[kRefCount] += increment; } inline void Environment::ImmediateInfo::ref_count_dec(uint32_t decrement) { - fields_[kRefCount] = fields_[kRefCount] - decrement; + fields_[kRefCount] -= decrement; } inline Environment::TickInfo::TickInfo(v8::Isolate* isolate) @@ -461,8 +460,7 @@ inline std::vector* Environment::destroy_async_id_list() { } inline double Environment::new_async_id() { - async_hooks()->async_id_fields()[AsyncHooks::kAsyncIdCounter] = - async_hooks()->async_id_fields()[AsyncHooks::kAsyncIdCounter] + 1; + async_hooks()->async_id_fields()[AsyncHooks::kAsyncIdCounter] += 1; return async_hooks()->async_id_fields()[AsyncHooks::kAsyncIdCounter]; } diff --git a/test/cctest/test_aliased_buffer.cc b/test/cctest/test_aliased_buffer.cc index 0eaddf773555db..7afa466133b757 100644 --- a/test/cctest/test_aliased_buffer.cc +++ b/test/cctest/test_aliased_buffer.cc @@ -207,3 +207,33 @@ TEST_F(AliasBufferTest, SharedArrayBuffer4) { int8_t, v8::Int8Array, int32_t, v8::Int32Array>(isolate_, 1, 3, 1); } + +TEST_F(AliasBufferTest, OperatorOverloads) { + v8::Isolate::Scope isolate_scope(isolate_); + v8::HandleScope handle_scope(isolate_); + v8::Local context = v8::Context::New(isolate_); + v8::Context::Scope context_scope(context); + const size_t size = 10; + AliasedBuffer ab{isolate_, size}; + + EXPECT_EQ(static_cast(1), ab[0] = 1); + EXPECT_EQ(static_cast(4), ab[0] += 3); + EXPECT_EQ(static_cast(2), ab[0] -= 2); + EXPECT_EQ(static_cast(-2), -ab[0]); +} + +TEST_F(AliasBufferTest, OperatorOverloadsRefs) { + v8::Isolate::Scope isolate_scope(isolate_); + v8::HandleScope handle_scope(isolate_); + v8::Local context = v8::Context::New(isolate_); + v8::Context::Scope context_scope(context); + AliasedBuffer ab{isolate_, 2}; + using Reference = AliasedBuffer::Reference; + Reference ref = ab[0]; + Reference ref_value = ab[1] = 2; + + EXPECT_EQ(static_cast(2), ref = ref_value); + EXPECT_EQ(static_cast(4), ref += ref_value); + EXPECT_EQ(static_cast(2), ref -= ref_value); + EXPECT_EQ(static_cast(-2), -ref); +}