Rename to_shared() to make_shared(), add make_shared(vargs...).

Author: evoskuil

include/bitcoin/system/data/memory.hpp

@@ -30,23 +30,33 @@ BC_PUSH_WARNING(NO_THROW_IN_NOEXCEPT)
 BC_PUSH_WARNING(SMART_PTR_NOT_NEEDED)
 BC_PUSH_WARNING(NO_VALUE_OR_CONST_REF_SHARED_PTR)
 
-/// shared_ptr
+/// make_shared (non-const)
 /// ---------------------------------------------------------------------------
 
+/// Create default shared pointer.
+template <typename Type>
+inline std::shared_ptr<Type> make_shared() NOEXCEPT
+{
+    return std::make_shared<Type>();
+}
+
 /// Create shared pointer to non-const from moved instance.
 template <typename Type>
 inline std::shared_ptr<Type> make_shared(Type&& value) NOEXCEPT
 {
     return std::make_shared<Type>(std::forward<Type>(value));
 }
 
-/// Create default shared pointer.
-template <typename Type>
-inline std::shared_ptr<Type> to_shared() NOEXCEPT
+/// Create shared pointer to non-const from vargs instance.
+template <typename Type, typename... Args>
+inline std::shared_ptr<Type> make_shared(Args&& ...args) NOEXCEPT
 {
-    return std::make_shared<Type>();
+    return std::make_shared<Type>(std::forward<Args>(args)...);
 }
 
+/// to_shared (const)
+/// ---------------------------------------------------------------------------
+
 /// Create shared pointer to const from instance pointer.
 template <typename Type>
 inline std::shared_ptr<const Type> to_shared(Type* value) NOEXCEPT

include/bitcoin/system/impl/hash/scrypt.ipp

@@ -329,7 +329,7 @@ block_mix(rblock_t& rblock) NOEXCEPT
     // Make 2R working blocks (1 rblock).
     // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
     // [P * (R * 128)] bytes heap allocated.
-    const auto ptr = to_shared<rblock_t>();
+    const auto ptr = make_shared<rblock_t>();
     if (!ptr) return false;
     auto& yrblock = *ptr;
     // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
@@ -356,7 +356,7 @@ block_mix(rblock_t& rblock) NOEXCEPT
     // Make 2R working blocks (1 rblock).
     // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
     // [P * (R * 128)] bytes heap allocated.
-    const auto ptr = to_shared<rblock_t>();
+    const auto ptr = make_shared<rblock_t>();
     if (!ptr) return false;
     auto& yrblock = *ptr;
     // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
@@ -375,7 +375,7 @@ block_mix(rblock_t& rblock) NOEXCEPT
     // Make R working blocks (half rblock).
     // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
     // [P * (R * 64)] bytes heap allocated.
-    const auto ptr = to_shared<std_array<block_t, R>>();
+    const auto ptr = make_shared<std_array<block_t, R>>();
     if (!ptr) return false;
     auto& yblock = *ptr;
     // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
@@ -394,7 +394,7 @@ block_mix(rblock_t& rblock) NOEXCEPT
     // Make R-1 working blocks.
     // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
     // [P * (sub1(R) * 64)] bytes heap allocated.
-    const auto ptr = to_shared<std_array<block_t, sub1(R)>>();
+    const auto ptr = make_shared<std_array<block_t, sub1(R)>>();
     if (!ptr) return false;
     auto& yblock = *ptr;
     // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
@@ -436,7 +436,7 @@ romix(rblock_t& rblock) NOEXCEPT
     // Make a working set of W rblocks.
     // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
     // [P * (W * (R * 128))] bytes heap allocated.
-    const auto ptr = to_shared<wrblock_t>();
+    const auto ptr = make_shared<wrblock_t>();
     if (!ptr) return false;
     auto& wrblocks = *ptr;
     // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
@@ -479,7 +479,7 @@ CLASS::hash(data_array<Size>& out, const data_slice& password,
     // Make a working set of P rblocks.
     // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
     // [P * (R * 128)] bytes heap allocated.
-    const auto ptr = to_shared<prblock_t>();
+    const auto ptr = make_shared<prblock_t>();
     if (!ptr) return false;
     auto& prblocks = *ptr;
     // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

src/chain/block.cpp

@@ -48,7 +48,7 @@ BC_PUSH_WARNING(NO_UNGUARDED_POINTERS)
 // ----------------------------------------------------------------------------
 
 block::block() NOEXCEPT
-  : block(to_shared<chain::header>(), to_shared<transaction_cptrs>(),
+  : block(make_shared<chain::header>(), make_shared<transaction_cptrs>(),
       false)
 {
 }
@@ -66,8 +66,8 @@ block::block(const chain::header& header,
 
 block::block(const chain::header::cptr& header,
     const transactions_cptr& txs) NOEXCEPT
-  : block(header ? header : to_shared<chain::header>(),
-      txs ? txs : to_shared<transaction_cptrs>(), true)
+  : block(header ? header : make_shared<chain::header>(),
+      txs ? txs : make_shared<transaction_cptrs>(), true)
 {
 }
 
@@ -208,7 +208,7 @@ const chain::header::cptr block::header_ptr() const NOEXCEPT
 // Roll up inputs for concurrent prevout processing.
 const inputs_cptr block::inputs_ptr() const NOEXCEPT
 {
-    const auto inputs = to_shared<input_cptrs>();
+    const auto inputs = make_shared<input_cptrs>();
     const auto append_ins = [&inputs](const auto& tx) NOEXCEPT
     {
         const auto& tx_ins = tx->inputs_ptr();

src/chain/input.cpp

@@ -55,7 +55,7 @@ const witness& input::no_witness() NOEXCEPT
 // static/private
 const witness::cptr& input::no_witness_cptr() NOEXCEPT
 {
-    static const auto empty = to_shared<const chain::witness>();
+    static const auto empty = make_shared<const chain::witness>();
     return empty;
 }
 
@@ -76,9 +76,9 @@ const chain::witness::cptr& input::get_witness_cptr() const NOEXCEPT
 // Default metadata is spent, invalid, max_size_t value. 
 input::input() NOEXCEPT
   : input(
-      to_shared<chain::point>(),
-      to_shared<chain::script>(),
-      to_shared<chain::witness>(),
+      make_shared<chain::point>(),
+      make_shared<chain::script>(),
+      make_shared<chain::witness>(),
       0, false)
 {
 }
@@ -88,7 +88,7 @@ input::input(chain::point&& point, chain::script&& script,
   : input(
       to_shared(std::move(point)),
       to_shared(std::move(script)),
-      to_shared<chain::witness>(),
+      make_shared<chain::witness>(),
       sequence, true)
 {
 }
@@ -98,17 +98,17 @@ input::input(const chain::point& point, const chain::script& script,
   : input(
       to_shared(point),
       to_shared(script),
-      to_shared<chain::witness>(),
+      make_shared<chain::witness>(),
       sequence, true)
 {
 }
 
 input::input(const chain::point::cptr& point,
     const chain::script::cptr& script, uint32_t sequence) NOEXCEPT
   : input(
-      point ? point : to_shared<chain::point>(),
-      script ? script : to_shared<chain::script>(),
-      to_shared<chain::witness>(),
+      point ? point : make_shared<chain::point>(),
+      script ? script : make_shared<chain::script>(),
+      make_shared<chain::witness>(),
       sequence, true)
 {
 }

src/chain/operation.cpp

@@ -68,7 +68,7 @@ const data_chunk& operation::no_data() NOEXCEPT
 // static/private
 const chunk_cptr& operation::no_data_cptr() NOEXCEPT
 {
-    static const auto empty = to_shared<const data_chunk>();
+    static const auto empty = make_shared<const data_chunk>();
     return empty;
 }
 

src/chain/output.cpp

@@ -48,7 +48,7 @@ const uint64_t output::not_found = sighash_null_value;
 // Invalid default used in signature hashing (validity ignored).
 // Invalidity is also used to determine that a prevout is not found.
 output::output() NOEXCEPT
-  : output(output::not_found, to_shared<chain::script>(), false)
+  : output(output::not_found, make_shared<chain::script>(), false)
 {
 }
 
@@ -63,7 +63,7 @@ output::output(uint64_t value, const chain::script& script) NOEXCEPT
 }
 
 output::output(uint64_t value, const chain::script::cptr& script) NOEXCEPT
-  : output(value, script ? script : to_shared<chain::script>(), true)
+  : output(value, script ? script : make_shared<chain::script>(), true)
 {
 }
 

src/chain/script_extract.cpp

@@ -35,7 +35,7 @@ namespace chain {
 
 const chunk_cptr& script::witness_program() const NOEXCEPT
 {
-    static const auto empty = to_shared<const data_chunk>();
+    static const auto empty = make_shared<const data_chunk>();
     return is_witness_program_pattern(ops()) ? ops().at(1).data_ptr() : empty;
 }
 

src/chain/transaction.cpp

@@ -48,8 +48,8 @@ BC_PUSH_WARNING(NO_THROW_IN_NOEXCEPT)
 
 transaction::transaction() NOEXCEPT
   : transaction(0,
-      to_shared<input_cptrs>(),
-      to_shared<output_cptrs>(),
+      make_shared<input_cptrs>(),
+      make_shared<output_cptrs>(),
       0, false, false)
 {
 }
@@ -112,8 +112,8 @@ transaction::transaction(uint32_t version,
     const chain::inputs_cptr& inputs, const chain::outputs_cptr& outputs,
     uint32_t locktime, bool segregated, bool valid) NOEXCEPT
   : version_(version),
-    inputs_(inputs ? inputs : to_shared<input_cptrs>()),
-    outputs_(outputs ? outputs : to_shared<output_cptrs>()),
+    inputs_(inputs ? inputs : make_shared<input_cptrs>()),
+    outputs_(outputs ? outputs : make_shared<output_cptrs>()),
     locktime_(locktime),
     segregated_(segregated),
     valid_(valid),

test/data/memory.cpp

@@ -35,9 +35,25 @@ struct type
 
 using test_array_shared_ptr = std::shared_ptr<data_array<3>>;
 
+BOOST_AUTO_TEST_CASE(memory__make_shared__array_default__default_values)
+{
+    const test_array_shared_ptr ptr = make_shared<data_array<3>>();
+    BOOST_REQUIRE_EQUAL(ptr->at(0), 0);
+    BOOST_REQUIRE_EQUAL(ptr->at(1), 0);
+    BOOST_REQUIRE_EQUAL(ptr->at(2), 0);
+}
+
 BOOST_AUTO_TEST_CASE(memory__make_shared__array_move__expected_values)
 {
-    const test_array_shared_ptr ptr = make_shared<data_array<3>>(data_array<3>{ 1, 2, 3 });
+    const test_array_shared_ptr ptr = make_shared(data_array<3>{ 1, 2, 3 });
+    BOOST_REQUIRE_EQUAL(ptr->at(0), 1);
+    BOOST_REQUIRE_EQUAL(ptr->at(1), 2);
+    BOOST_REQUIRE_EQUAL(ptr->at(2), 3);
+}
+
+BOOST_AUTO_TEST_CASE(memory__make_shared__array_vargs__expected_values)
+{
+    const test_array_shared_ptr ptr = make_shared<data_array<3>>({ 1, 2, 3 });
     BOOST_REQUIRE_EQUAL(ptr->at(0), 1);
     BOOST_REQUIRE_EQUAL(ptr->at(1), 2);
     BOOST_REQUIRE_EQUAL(ptr->at(2), 3);
@@ -47,14 +63,6 @@ BOOST_AUTO_TEST_CASE(memory__make_shared__array_move__expected_values)
 
 using test_const_array_shared_ptr = std::shared_ptr<const data_array<3>>;
 
-BOOST_AUTO_TEST_CASE(memory__to_shared1__array_default__default_values)
-{
-    const test_const_array_shared_ptr ptr = to_shared<data_array<3>>();
-    BOOST_REQUIRE_EQUAL(ptr->at(0), 0);
-    BOOST_REQUIRE_EQUAL(ptr->at(1), 0);
-    BOOST_REQUIRE_EQUAL(ptr->at(2), 0);
-}
-
 BOOST_AUTO_TEST_CASE(memory__to_shared5__array_copy__expected_values)
 {
     const data_array<3> copy{ 1, 2, 3 };
@@ -74,9 +82,9 @@ BOOST_AUTO_TEST_CASE(memory__to_shared5__array_move__expected_values)
 
 using test_shared_ptr = std::shared_ptr<const type>;
 
-BOOST_AUTO_TEST_CASE(memory__to_shared1__always__default)
+BOOST_AUTO_TEST_CASE(memory__make_shared__always__default)
 {
-    const test_shared_ptr ptr = to_shared<type>();
+    const test_shared_ptr ptr = make_shared<type>();
     BOOST_REQUIRE_EQUAL(ptr->left, 0);
     BOOST_REQUIRE_EQUAL(ptr->right, type::expected);
 }