/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*-
 * vim: set ts=8 sts=2 et sw=2 tw=80:
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

/*
 * Template types for use in generic code: to use Rooted/Handle/MutableHandle in
 * cases where GC may occur, or to use mock versions of those types that perform
 * no rooting or root list manipulation when GC cannot occur.
 */

#ifndef gc_MaybeRooted_h
#define gc_MaybeRooted_h

#include "mozilla/Attributes.h"  // MOZ_IMPLICIT, MOZ_RAII

#include <type_traits>  // std::true_type

#include "gc/Allocator.h"            // js::AllowGC, js::CanGC, js::NoGC
#include "js/ComparisonOperators.h"  // JS::detail::DefineComparisonOps
#include "js/RootingAPI.h"  // js::{Rooted,MutableHandle}Base, JS::SafelyInitialized, DECLARE_POINTER_{CONSTREF,ASSIGN}_OPS, DECLARE_NONPOINTER_{,MUTABLE_}ACCESSOR_METHODS, JS::Rooted, JS::{,Mutable}Handle

namespace js {

/**
 * Interface substitute for Rooted<T> which does not root the variable's
 * memory.
 */
template <typename T>
class MOZ_RAII FakeRooted : public RootedBase<T, FakeRooted<T>> {
 public:
  using ElementType = T;

  template <typename CX>
  explicit FakeRooted(CX* cx) : ptr(JS::SafelyInitialized<T>()) {}

  template <typename CX>
  FakeRooted(CX* cx, T initial) : ptr(initial) {}

  DECLARE_POINTER_CONSTREF_OPS(T);
  DECLARE_POINTER_ASSIGN_OPS(FakeRooted, T);
  DECLARE_NONPOINTER_ACCESSOR_METHODS(ptr);
  DECLARE_NONPOINTER_MUTABLE_ACCESSOR_METHODS(ptr);

 private:
  T ptr;

  void set(const T& value) { ptr = value; }

  FakeRooted(const FakeRooted&) = delete;
};

}  // namespace js

namespace JS {

namespace detail {

template <typename T>
struct DefineComparisonOps<js::FakeRooted<T>> : std::true_type {
  static const T& get(const js::FakeRooted<T>& v) { return v.get(); }
};

}  // namespace detail

}  // namespace JS

namespace js {

/**
 * Interface substitute for MutableHandle<T> which is not required to point to
 * rooted memory.
 */
template <typename T>
class FakeMutableHandle
    : public js::MutableHandleBase<T, FakeMutableHandle<T>> {
 public:
  using ElementType = T;

  MOZ_IMPLICIT FakeMutableHandle(T* t) : ptr(t) {}

  MOZ_IMPLICIT FakeMutableHandle(FakeRooted<T>* root) : ptr(root->address()) {}

  void set(const T& v) { *ptr = v; }

  DECLARE_POINTER_CONSTREF_OPS(T);
  DECLARE_NONPOINTER_ACCESSOR_METHODS(*ptr);
  DECLARE_NONPOINTER_MUTABLE_ACCESSOR_METHODS(*ptr);

 private:
  FakeMutableHandle() : ptr(nullptr) {}
  DELETE_ASSIGNMENT_OPS(FakeMutableHandle, T);

  T* ptr;
};

}  // namespace js

namespace JS {

namespace detail {

template <typename T>
struct DefineComparisonOps<js::FakeMutableHandle<T>> : std::true_type {
  static const T& get(const js::FakeMutableHandle<T>& v) { return v.get(); }
};

}  // namespace detail

}  // namespace JS

namespace js {

/**
 * Types for a variable that either should or shouldn't be rooted, depending on
 * the template parameter allowGC. Used for implementing functions that can
 * operate on either rooted or unrooted data.
 */

template <typename T, AllowGC allowGC>
class MaybeRooted;

template <typename T>
class MaybeRooted<T, CanGC> {
 public:
  using HandleType = JS::Handle<T>;
  using RootType = JS::Rooted<T>;
  using MutableHandleType = JS::MutableHandle<T>;

  template <typename T2>
  static JS::Handle<T2*> downcastHandle(HandleType v) {
    return v.template as<T2>();
  }
};

template <typename T>
class MaybeRooted<T, NoGC> {
 public:
  using HandleType = const T&;
  using RootType = FakeRooted<T>;
  using MutableHandleType = FakeMutableHandle<T>;

  template <typename T2>
  static T2* downcastHandle(HandleType v) {
    return &v->template as<T2>();
  }
};

}  // namespace js

#endif  // gc_MaybeRooted_h
