/* vim: set ts=4 sw=4 tw=99 et:

  *

  * Copyright (C) 2012 David Anderson

  *

  * This file is part of JITCraft.

  *

  * JITCraft is free software: you can redistribute it and/or modify it under

  * the terms of the GNU General Public License as published by the Free

  * Software Foundation, either version 3 of the License, or (at your option)

  * any later version.

  * 

  * Foobar is distributed in the hope that it will be useful, but WITHOUT ANY

  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS

  * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

  *

  * You should have received a copy of the GNU General Public License along with

  * JITCraft. If not, see http://www.gnu.org/licenses/.

  */

 #ifndef _include_jitcraft_rooting_h_

 #define _include_jitcraft_rooting_h_

 #include <stdlib.h>

 #include "PoolAllocator.h"

 namespace ke {

 class Zone;

 class Object;

 template <typename T> class Local;

 template <typename T> class ScopedRoot;

 struct NullAddress

 {

     static void * const Sentinel;

 };

 /*

  * Internal handles work differently from API handles. An API handle is a

  * root, whereas as an internal handle points to a rooted location. This

  * subtle difference makes handles easy for embedders, but somewhat

  * cumbersome internally.

  */

 template <typename T>

 class Handle

 {

     T * const *thingp_;

   private:

     Handle()

       : thingp_(reinterpret_cast<T * const *>(&NullAddress::Sentinel))

     {

     }

   public:

     Handle(const Handle &other) {

         thingp_ = other.address();

     }

     template <typename S> Handle(const Handle<S> &handle) {

         typeCheck<S>();

         thingp_ = reinterpret_cast<T * const *>(handle.address());

     }

     template <typename S> inline Handle(const Local<S> &local);

     template <typename S> inline Handle(const ScopedRoot<S> &root);

     static inline Handle Null() {

         return Handle();

     }

   public:

     T *operator ->() {

         return *thingp_;

     }

     T *operator *() {

         return *thingp_;

     }

     operator T *() const { return *thingp_; }

     operator bool() const {

         return thingp_ && *thingp_;

     }

     T * const *address() const {

         return thingp_;

     }

     bool operator ==(const Handle<T> &other) const {

         return (!thingp_ && !other.thingp_) ||

                *thingp_ == *other.thingp_;

     }

     bool operator !=(const Handle<T> &other) const {

         return (!thingp_ != !other.thingp_) ||

                *thingp_ != *other.thingp_;

     }

   private:

     template <typename S>

     void typeCheck() {

 #ifndef NDEBUG

         T *v1 = NULL;

         S *v2 = NULL;

         v1 = v2;

         (void)v1;

 #endif

     }

 };

 template <typename T>

 class Local

 {

     friend class Zone;

     Zone *zone_;

     T *thing_;

     Local<Object> *prev_;

     Local<Object> *prev() {

         return prev_;

     }

     Local<Object> *toRaw() {

         return reinterpret_cast<Local<Object>*>(this);

     }

   public:

     // These are implemented in Zone.h.

     inline explicit Local(Zone *zone, T *thing = NULL);

     inline ~Local();

     const Local &operator =(T *thing) {

         thing_ = thing;

         return *this;

     }

     T *operator ->() const {

         return operator *();

     }

     T *operator *() const {

         return thing_;

     }

     operator bool () const {

         return !!thing_;

     }

     bool operator !=(const Local &other) {

         return thing_ != other.thing_;

     }

     T **address() {

         return (T **)&thing_;

     }

     T * const *address() const {

         return (T * const *)&thing_;

     }

     T **ref() {

         return &thing_;

     }

     operator T *() {

         return thing_;

     }

     Local &operator =(const Local &other) {

         thing_ = other.thing_;

         return *this;

     }

   private:

     // Disallow heap allocation.

     void *operator new(size_t size);

     void *operator new[](size_t size);

     // Disallow copy construction.

     Local(const Local<T> &other);

 };

 // A ScopedRoot is a special kind of handle for storing references on the

 // heap in bulk.

 template <typename T>

 class ScopedRoot : public PoolObject

 {

     T **thingp_;

   private:

     // This is implemented in Zone.h.

     inline T **make(T *other);

     void assign(T *other) {

         *thingp_ = other;

     }

   public:

     ScopedRoot();

     // This is implemented in Zone.h.

     inline ScopedRoot(T *thing);

     ScopedRoot &operator =(const ScopedRoot<T> &other) {

         assign(*other);

         return *this;

     }

     ScopedRoot &operator =(T *other) {

         assign(other);

         return *this;

     }

     T *operator ->() const {

         return operator *();

     }

     T *operator *() const {

         return *thingp_;

     }

     operator T *() const {

         return *thingp_;

     }

     operator bool () const {

         return !!*thingp_;

     }

     T **address() const {

         return thingp_;

     }

 };

 template <typename T> template <typename S> inline

 Handle<T>::Handle(const Local<S> &local)

 {

     typeCheck<S>();

     thingp_ = reinterpret_cast<T * const *>(local.address());

 }

 template <typename T> template <typename S> inline

 Handle<T>::Handle(const ScopedRoot<S> &root)

 {

     typeCheck<S>();

     thingp_ = reinterpret_cast<T * const *>(root.address());

 }

 }

 #endif // _include_jitcraft_rooting_h_