Add nostd::make_unique

api/include/opentelemetry/nostd/unique_ptr.h

@@ -175,6 +175,12 @@ bool operator!=(std::nullptr_t, const unique_ptr<T> &rhs) noexcept
 {
   return nullptr != rhs.get();
 }
+
+template <class T, class... Args>
+unique_ptr<T> make_unique(Args &&...args)
+{
+  return unique_ptr<T>(new T(std::forward<Args>(args)...));
+}
 }  // namespace nostd
 OPENTELEMETRY_END_NAMESPACE
 #endif /* OPENTELEMETRY_HAVE_STD_UNIQUE_PTR */

api/include/opentelemetry/std/unique_ptr.h

@@ -18,5 +18,16 @@ namespace nostd
 template <class... _Types>
 using unique_ptr = std::unique_ptr<_Types...>;
 
+#if (defined(__cplusplus) && __cplusplus >= 201402L) || \
+    (defined(_MSVC_LANG) && _MSVC_LANG >= 201402L)
+using std::make_unique;
+#else
+template <class T, class... Args>
+unique_ptr<T> make_unique(Args &&...args)
+{
+  return unique_ptr<T>(new T(std::forward<Args>(args)...));
+}
+#endif
+
 }  // namespace nostd
 OPENTELEMETRY_END_NAMESPACE

examples/multi_processor/main.cc

@@ -65,7 +65,7 @@ void CleanupTracer()
   trace_api::Provider::SetTracerProvider(none);
 }
 
-void dumpSpans(std::vector<std::unique_ptr<trace_sdk::SpanData>> &spans)
+void dumpSpans(std::vector<opentelemetry::nostd::unique_ptr<trace_sdk::SpanData>> &spans)
 {
   char span_buf[trace_api::SpanId::kSize * 2];
   char trace_buf[trace_api::TraceId::kSize * 2];

exporters/memory/include/opentelemetry/exporters/memory/in_memory_data.h

@@ -27,24 +27,24 @@ class InMemoryData
   /**
    * @param data a required unique pointer to the data to add to the CircularBuffer
    */
-  void Add(std::unique_ptr<T> data) noexcept { data_.Add(data); }
+  void Add(nostd::unique_ptr<T> data) noexcept { data_.Add(data); }
 
   /**
    * @return Returns a vector of unique pointers containing all the data in the
    * CircularBuffer. This operation will empty the Buffer, which is why the data
    * is returned as unique pointers
    */
-  std::vector<std::unique_ptr<T>> Get() noexcept
+  std::vector<nostd::unique_ptr<T>> Get() noexcept
   {
-    std::vector<std::unique_ptr<T>> res;
+    std::vector<nostd::unique_ptr<T>> res;
 
     // Pointer swap is required because the Consume function requires that the
     // AtomicUniquePointer be set to null
     data_.Consume(
         data_.size(), [&](opentelemetry::sdk::common::CircularBufferRange<
                           opentelemetry::sdk::common::AtomicUniquePtr<T>> range) noexcept {
           range.ForEach([&](opentelemetry::sdk::common::AtomicUniquePtr<T> &ptr) noexcept {
-            std::unique_ptr<T> swap_ptr = nullptr;
+            nostd::unique_ptr<T> swap_ptr = nullptr;
             ptr.Swap(swap_ptr);
             res.push_back(std::move(swap_ptr));
             return true;

exporters/memory/include/opentelemetry/exporters/memory/in_memory_metric_data.h

@@ -9,6 +9,7 @@
 #include <tuple>
 
 #include "opentelemetry/exporters/memory/in_memory_data.h"
+#include "opentelemetry/nostd/unique_ptr.h"
 #include "opentelemetry/sdk/metrics/data/metric_data.h"
 
 OPENTELEMETRY_BEGIN_NAMESPACE
@@ -37,7 +38,7 @@ class InMemoryMetricData
   InMemoryMetricData &operator=(const InMemoryMetricData &) = delete;
   InMemoryMetricData &operator=(InMemoryMetricData &&)      = delete;
 
-  virtual void Add(std::unique_ptr<sdk::metrics::ResourceMetrics> resource_metrics) = 0;
+  virtual void Add(nostd::unique_ptr<sdk::metrics::ResourceMetrics> resource_metrics) = 0;
 };
 
 /// An implementation of InMemoryMetricData that stores full-fidelity data points in a circular
@@ -48,7 +49,7 @@ class CircularBufferInMemoryMetricData final : public InMemoryMetricData,
 {
 public:
   explicit CircularBufferInMemoryMetricData(size_t buffer_size);
-  void Add(std::unique_ptr<sdk::metrics::ResourceMetrics> resource_metrics) override;
+  void Add(nostd::unique_ptr<sdk::metrics::ResourceMetrics> resource_metrics) override;
 };
 
 /// An implementation of InMemoryMetricData that stores only the most recent data point in each time
@@ -59,7 +60,7 @@ class SimpleAggregateInMemoryMetricData final : public InMemoryMetricData
   using AttributeToPoint = std::map<opentelemetry::sdk::metrics::PointAttributes,
                                     opentelemetry::sdk::metrics::PointType>;
 
-  void Add(std::unique_ptr<sdk::metrics::ResourceMetrics> resource_metrics) override;
+  void Add(nostd::unique_ptr<sdk::metrics::ResourceMetrics> resource_metrics) override;
   const AttributeToPoint &Get(const std::string &scope, const std::string &metric);
   void Clear();
 

exporters/memory/include/opentelemetry/exporters/memory/in_memory_span_data.h

@@ -26,7 +26,7 @@ class InMemorySpanData final : public exporter::memory::InMemoryData<sdk::trace:
       : exporter::memory::InMemoryData<sdk::trace::SpanData>(buffer_size)
   {}
 
-  std::vector<std::unique_ptr<sdk::trace::SpanData>> GetSpans() noexcept { return Get(); }
+  std::vector<nostd::unique_ptr<sdk::trace::SpanData>> GetSpans() noexcept { return Get(); }
 };
 }  // namespace memory
 }  // namespace exporter

exporters/memory/src/in_memory_metric_data.cc

@@ -16,12 +16,12 @@ CircularBufferInMemoryMetricData::CircularBufferInMemoryMetricData(size_t buffer
     : InMemoryData(buffer_size)
 {}
 
-void CircularBufferInMemoryMetricData::Add(std::unique_ptr<ResourceMetrics> resource_metrics)
+void CircularBufferInMemoryMetricData::Add(nostd::unique_ptr<ResourceMetrics> resource_metrics)
 {
   InMemoryData::Add(std::move(resource_metrics));
 }
 
-void SimpleAggregateInMemoryMetricData::Add(std::unique_ptr<ResourceMetrics> resource_metrics)
+void SimpleAggregateInMemoryMetricData::Add(nostd::unique_ptr<ResourceMetrics> resource_metrics)
 {
   for (const auto &sm : resource_metrics->scope_metric_data_)
   {
@@ -31,7 +31,8 @@ void SimpleAggregateInMemoryMetricData::Add(std::unique_ptr<ResourceMetrics> res
       const auto &metric = m.instrument_descriptor.name_;
       for (const auto &pda : m.point_data_attr_)
       {
-        data_[{scope, metric}].insert({pda.attributes, pda.point_data});
+        data_[std::tuple<std::string, std::string>{scope, metric}].insert(
+            {pda.attributes, pda.point_data});
       }
     }
   }
@@ -41,7 +42,7 @@ const SimpleAggregateInMemoryMetricData::AttributeToPoint &SimpleAggregateInMemo
     const std::string &scope,
     const std::string &metric)
 {
-  return data_[{scope, metric}];
+  return data_[std::tuple<std::string, std::string>{scope, metric}];
 }
 
 void SimpleAggregateInMemoryMetricData::Clear()

exporters/memory/src/in_memory_metric_exporter_factory.cc

@@ -3,6 +3,7 @@
 
 #include "opentelemetry/exporters/memory/in_memory_metric_exporter_factory.h"
 #include "opentelemetry/exporters/memory/in_memory_metric_data.h"
+#include "opentelemetry/nostd/unique_ptr.h"
 #include "opentelemetry/sdk/common/global_log_handler.h"
 #include "opentelemetry/sdk/metrics/export/metric_producer.h"
 #include "opentelemetry/sdk/metrics/push_metric_exporter.h"
@@ -49,7 +50,7 @@ class InMemoryMetricExporter final : public sdk::metrics::PushMetricExporter
       OTEL_INTERNAL_LOG_ERROR("[In Memory Metric Exporter] Exporting failed, exporter is shutdown");
       return ExportResult::kFailure;
     }
-    data_->Add(std::make_unique<ResourceMetrics>(data));
+    data_->Add(opentelemetry::nostd::make_unique<ResourceMetrics>(data));
     return ExportResult::kSuccess;
   }
 
@@ -78,14 +79,15 @@ class InMemoryMetricExporter final : public sdk::metrics::PushMetricExporter
 std::unique_ptr<PushMetricExporter> InMemoryMetricExporterFactory::Create(
     const std::shared_ptr<InMemoryMetricData> &data)
 {
-  return Create(data, [](auto) { return AggregationTemporality::kCumulative; });
+  return Create(data,
+                [](sdk::metrics::InstrumentType) { return AggregationTemporality::kCumulative; });
 }
 
 std::unique_ptr<PushMetricExporter> InMemoryMetricExporterFactory::Create(
     const std::shared_ptr<InMemoryMetricData> &data,
     const AggregationTemporalitySelector &temporality)
 {
-  return std::make_unique<InMemoryMetricExporter>(data, temporality);
+  return std::unique_ptr<InMemoryMetricExporter>(new InMemoryMetricExporter{data, temporality});
 }
 
 }  // namespace memory

exporters/memory/test/in_memory_metric_data_test.cc

@@ -2,6 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0
 
 #include "opentelemetry/exporters/memory/in_memory_metric_data.h"
+#include "opentelemetry/nostd/unique_ptr.h"
 #include "opentelemetry/sdk/instrumentationscope/instrumentation_scope.h"
 #include "opentelemetry/sdk/metrics/export/metric_producer.h"
 #include "opentelemetry/sdk/resource/resource.h"
@@ -23,7 +24,7 @@ TEST(InMemoryMetricDataTest, CircularBuffer)
 {
   CircularBufferInMemoryMetricData buf(10);
   Resource resource = Resource::GetEmpty();
-  buf.Add(std::make_unique<ResourceMetrics>(
+  buf.Add(opentelemetry::nostd::make_unique<ResourceMetrics>(
       &resource, std::vector<ScopeMetrics>{{nullptr, std::vector<MetricData>{}}}));
   EXPECT_EQ((*buf.Get().begin())->resource_, &resource);
 }
@@ -45,7 +46,7 @@ TEST(InMemoryMetricDataTest, SimpleAggregate)
   md.instrument_descriptor.name_ = "my-metric";
   md.point_data_attr_.push_back(pda);
 
-  agg.Add(std::make_unique<ResourceMetrics>(
+  agg.Add(opentelemetry::nostd::make_unique<ResourceMetrics>(
       &resource, std::vector<ScopeMetrics>{{scope.get(), std::vector<MetricData>{md}}}));
   auto it = agg.Get("my-scope", "my-metric").begin();
 

sdk/include/opentelemetry/sdk/common/atomic_unique_ptr.h

@@ -6,6 +6,7 @@
 #include <atomic>
 #include <memory>
 
+#include "opentelemetry/nostd/unique_ptr.h"
 #include "opentelemetry/version.h"
 
 OPENTELEMETRY_BEGIN_NAMESPACE
@@ -25,6 +26,10 @@ class AtomicUniquePtr
 
   explicit AtomicUniquePtr(std::unique_ptr<T> &&other) noexcept : ptr_(other.release()) {}
 
+#if !defined(OPENTELEMETRY_HAVE_STD_UNIQUE_PTR)
+  explicit AtomicUniquePtr(nostd::unique_ptr<T> &&other) noexcept : ptr_(other.release()) {}
+#endif
+
   ~AtomicUniquePtr() noexcept { Reset(); }
 
   T &operator*() const noexcept { return *Get(); }
@@ -66,6 +71,33 @@ class AtomicUniquePtr
    */
   void Swap(std::unique_ptr<T> &other) noexcept { other.reset(ptr_.exchange(other.release())); }
 
+#if !defined(OPENTELEMETRY_HAVE_STD_UNIQUE_PTR)
+  /**
+   * Atomically swap the pointer only if it's null.
+   * @param owner the pointer to swap with
+   * @return true if the swap was successful
+   */
+  bool SwapIfNull(nostd::unique_ptr<T> &owner) noexcept
+  {
+    auto ptr            = owner.get();
+    T *expected         = nullptr;
+    auto was_successful = ptr_.compare_exchange_weak(expected, ptr, std::memory_order_release,
+                                                     std::memory_order_relaxed);
+    if (was_successful)
+    {
+      owner.release();
+      return true;
+    }
+    return false;
+  }
+
+  /**
+   * Atomically swap the pointer with another.
+   * @param ptr the pointer to swap with
+   */
+  void Swap(nostd::unique_ptr<T> &other) noexcept { other.reset(ptr_.exchange(other.release())); }
+#endif
+
   /**
    * Set the pointer to a new value and delete the current value if non-null.
    * @param ptr the new pointer value to set

sdk/include/opentelemetry/sdk/common/circular_buffer.h

@@ -11,6 +11,7 @@
 #include <memory>
 
 #include "opentelemetry/nostd/span.h"
+#include "opentelemetry/nostd/unique_ptr.h"
 #include "opentelemetry/sdk/common/atomic_unique_ptr.h"
 #include "opentelemetry/sdk/common/circular_buffer_range.h"
 #include "opentelemetry/version.h"
@@ -83,7 +84,7 @@ class CircularBuffer
    * @param ptr a pointer to the element to add
    * @return true if the element was successfully added; false, otherwise.
    */
-  bool Add(std::unique_ptr<T> &ptr) noexcept
+  bool Add(nostd::unique_ptr<T> &ptr) noexcept
   {
     while (true)
     {
@@ -118,14 +119,27 @@ class CircularBuffer
     }
   }
 
-  bool Add(std::unique_ptr<T> &&ptr) noexcept
+  bool Add(nostd::unique_ptr<T> &&ptr) noexcept
   {
     // rvalue to lvalue reference
     bool result = Add(std::ref(ptr));
     ptr.reset();
     return result;
   }
 
+#if !defined(OPENTELEMETRY_HAVE_STD_UNIQUE_PTR)
+  bool Add(std::unique_ptr<T> &ptr) noexcept
+  {
+    nostd::unique_ptr<T> convert_ptr{std::move(ptr)};
+
+    bool result = Add(convert_ptr);
+    ptr.reset(convert_ptr.release());
+    return result;
+  }
+
+  bool Add(std::unique_ptr<T> &&ptr) noexcept { return Add(nostd::unique_ptr<T>{std::move(ptr)}); }
+#endif
+
   /**
    * Clear the circular buffer.
    *