#ifndef SRC_NODE_UNION_BYTES_H_

#define SRC_NODE_UNION_BYTES_H_

#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS

#include "v8.h"

namespace node {

// An external resource intended to be used with static lifetime.

template <typename Char, typename IChar, typename Base>

class StaticExternalByteResource : public Base {

  static_assert(sizeof(IChar) == sizeof(Char),

                "incompatible interface and internal pointers");

 public:

  explicit StaticExternalByteResource(const Char* data,

                                      size_t length,

                                      std::shared_ptr<void> owning_ptr)

      : data_(data), length_(length), owning_ptr_(owning_ptr) {}

node::StaticExternalByteResource<unsigned short, unsigned short, v8::String::ExternalStringResource>::StaticExternalByteResource(unsigned short const*, unsigned long, std::__1::shared_ptr<void>)

Line

Count

Source

21

288

      : data_(data), length_(length), owning_ptr_(owning_ptr) {}

node::StaticExternalByteResource<unsigned char, char, v8::String::ExternalOneByteStringResource>::StaticExternalByteResource(unsigned char const*, unsigned long, std::__1::shared_ptr<void>)

Line

Count

Source

21

26.0k

      : data_(data), length_(length), owning_ptr_(owning_ptr) {}

  const IChar* data() const override {

    return reinterpret_cast<const IChar*>(data_);

  }

node::StaticExternalByteResource<unsigned short, unsigned short, v8::String::ExternalStringResource>::data() const

Line

Count

Source

23

385

  const IChar* data() const override {

24

385

    return reinterpret_cast<const IChar*>(data_);

25

385

  }

node::StaticExternalByteResource<unsigned char, char, v8::String::ExternalOneByteStringResource>::data() const

Line

Count

Source

23

18.0k

  const IChar* data() const override {

24

18.0k

    return reinterpret_cast<const IChar*>(data_);

25

18.0k

  }

  size_t length() const override { return length_; }

node::StaticExternalByteResource<unsigned short, unsigned short, v8::String::ExternalStringResource>::length() const

Line

Count

Source

26

280

  size_t length() const override { return length_; }

node::StaticExternalByteResource<unsigned char, char, v8::String::ExternalOneByteStringResource>::length() const

Line

Count

Source

26

10.0k

  size_t length() const override { return length_; }

  void Dispose() override {

    // We ignore Dispose calls from V8, even if we "own" a resource via

    // owning_ptr_. All instantiations of this class are static or owned by a

    // static map, and will be destructed when static variables are destructed.

  }

node::StaticExternalByteResource<unsigned short, unsigned short, v8::String::ExternalStringResource>::Dispose()

Line

Count

Source

28

70

  void Dispose() override {

29

    // We ignore Dispose calls from V8, even if we "own" a resource via

30

    // owning_ptr_. All instantiations of this class are static or owned by a

31

    // static map, and will be destructed when static variables are destructed.

32

70

  }

node::StaticExternalByteResource<unsigned char, char, v8::String::ExternalOneByteStringResource>::Dispose()

Line

Count

Source

28

2.52k

  void Dispose() override {

29

    // We ignore Dispose calls from V8, even if we "own" a resource via

30

    // owning_ptr_. All instantiations of this class are static or owned by a

31

    // static map, and will be destructed when static variables are destructed.

32

2.52k

  }

  StaticExternalByteResource(const StaticExternalByteResource&) = delete;

  StaticExternalByteResource& operator=(const StaticExternalByteResource&) =

      delete;

 private:

  const Char* data_;

  const size_t length_;

  std::shared_ptr<void> owning_ptr_;

};

using StaticExternalOneByteResource =

    StaticExternalByteResource<uint8_t,

                               char,

                               v8::String::ExternalOneByteStringResource>;

using StaticExternalTwoByteResource =

    StaticExternalByteResource<uint16_t,

                               uint16_t,

                               v8::String::ExternalStringResource>;

// Similar to a v8::String, but it's independent from Isolates

// and can be materialized in Isolates as external Strings

// via ToStringChecked.

class UnionBytes {

 public:

  explicit UnionBytes(StaticExternalOneByteResource* one_byte_resource)

      : one_byte_resource_(one_byte_resource), two_byte_resource_(nullptr) {}

  explicit UnionBytes(StaticExternalTwoByteResource* two_byte_resource)

      : one_byte_resource_(nullptr), two_byte_resource_(two_byte_resource) {}

  UnionBytes(const UnionBytes&) = default;

  UnionBytes& operator=(const UnionBytes&) = default;

  UnionBytes(UnionBytes&&) = default;

  UnionBytes& operator=(UnionBytes&&) = default;

  bool is_one_byte() const { return one_byte_resource_ != nullptr; }

  v8::Local<v8::String> ToStringChecked(v8::Isolate* isolate) const;

 private:

  StaticExternalOneByteResource* one_byte_resource_;

  StaticExternalTwoByteResource* two_byte_resource_;

};

}  // namespace node

#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS

#endif  // SRC_NODE_UNION_BYTES_H_