1 files changed, 109 insertions, 0 deletions
diff --git a/mocktracer/src/tracer.cpp b/mocktracer/src/tracer.cpp
new file mode 100644
index 0000000..e5f9127
--- /dev/null
+++ b/mocktracer/src/tracer.cpp
@@ -0,0 +1,109 @@
+#include <opentracing/mocktracer/tracer.h>
+#include <cstdio>
+#include <exception>
+
+#include "mock_span.h"
+#include "mock_span_context.h"
+#include "propagation.h"
+
+#include <opentracing/dynamic_load.h>
+#include <opentracing/mocktracer/tracer_factory.h>
+#include <cstdio>
+#include <cstring>
+#include <exception>
+
+namespace opentracing {
+BEGIN_OPENTRACING_ABI_NAMESPACE
+namespace mocktracer {
+
+template <class Carrier>
+static expected<void> InjectImpl(const PropagationOptions& propagation_options,
+                                 const opentracing::SpanContext& span_context,
+                                 Carrier& writer) {
+  if (propagation_options.inject_error_code.value() != 0) {
+    return opentracing::make_unexpected(propagation_options.inject_error_code);
+  }
+  auto mock_span_context = dynamic_cast<const MockSpanContext*>(&span_context);
+  if (mock_span_context == nullptr) {
+    return opentracing::make_unexpected(
+        opentracing::invalid_span_context_error);
+  }
+  return mock_span_context->Inject(propagation_options, writer);
+}
+
+template <class Carrier>
+opentracing::expected<std::unique_ptr<opentracing::SpanContext>> ExtractImpl(
+    const PropagationOptions& propagation_options, Carrier& reader) {
+  if (propagation_options.extract_error_code.value() != 0) {
+    return opentracing::make_unexpected(propagation_options.extract_error_code);
+  }
+  MockSpanContext* mock_span_context;
+  try {
+    mock_span_context = new MockSpanContext{};
+  } catch (const std::bad_alloc&) {
+    return opentracing::make_unexpected(
+        make_error_code(std::errc::not_enough_memory));
+  }
+  std::unique_ptr<opentracing::SpanContext> span_context(mock_span_context);
+  auto result = mock_span_context->Extract(propagation_options, reader);
+  if (!result) {
+    return opentracing::make_unexpected(result.error());
+  }
+  if (!*result) {
+    span_context.reset();
+  }
+  return std::move(span_context);
+}
+
+MockTracer::MockTracer(MockTracerOptions&& options)
+    : recorder_{std::move(options.recorder)},
+      propagation_options_{std::move(options.propagation_options)} {}
+
+std::unique_ptr<Span> MockTracer::StartSpanWithOptions(
+    string_view operation_name, const StartSpanOptions& options) const
+    noexcept try {
+  return std::unique_ptr<Span>{new MockSpan{shared_from_this(), recorder_.get(),
+                                            operation_name, options}};
+} catch (const std::exception& e) {
+  fprintf(stderr, "Failed to start span: %s\n", e.what());
+  return nullptr;
+}
+
+void MockTracer::Close() noexcept {
+  if (recorder_ != nullptr) {
+    recorder_->Close();
+  }
+}
+
+expected<void> MockTracer::Inject(const SpanContext& sc,
+                                  std::ostream& writer) const {
+  return InjectImpl(propagation_options_, sc, writer);
+}
+
+expected<void> MockTracer::Inject(const SpanContext& sc,
+                                  const TextMapWriter& writer) const {
+  return InjectImpl(propagation_options_, sc, writer);
+}
+
+expected<void> MockTracer::Inject(const SpanContext& sc,
+                                  const HTTPHeadersWriter& writer) const {
+  return InjectImpl(propagation_options_, sc, writer);
+}
+
+expected<std::unique_ptr<SpanContext>> MockTracer::Extract(
+    std::istream& reader) const {
+  return ExtractImpl(propagation_options_, reader);
+}
+
+expected<std::unique_ptr<SpanContext>> MockTracer::Extract(
+    const TextMapReader& reader) const {
+  return ExtractImpl(propagation_options_, reader);
+}
+
+expected<std::unique_ptr<SpanContext>> MockTracer::Extract(
+    const HTTPHeadersReader& reader) const {
+  return ExtractImpl(propagation_options_, reader);
+}
+}  // namespace mocktracer
+END_OPENTRACING_ABI_NAMESPACE
+}  // namespace opentracing