/* 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 "Objects.h"

 namespace jc {

 class Zone;

 template <typename T> class Local;

 template <typename T> class ScopedRoot;

 template <typename T>

 class Handle

 {

     T * const *thingp_;

   public:

     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);

   public:

     T *operator ->() {

         return *thingp_;

     }

     T *operator *() {

         return *thingp_;

     }

     operator T *() { return *thingp_; }

     operator bool() const {

         return thingp_ && *thingp_;

     }

     T * const *address() const {

         return thingp_;

     }

   private:

     template <typename S>

     void typeCheck() {

 #ifdef DEBUG

         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_;

     }

     Object **address() {

         return (Object **)&thing_;

     }

     Object * const *address() const {

         return (Object * const *)&thing_;

     }

     operator T *() {

         return thing_;

     }

   private:

     // Disallow heap allocation.

     void *operator new(size_t size);

     void *operator new[](size_t size);

     // Disallow copy construction.

     Local(const Local<T> &other);

     Local &operator =(const Local &other);

 };

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

 // heap in bulk.

 template <typename T>

 class ScopedRoot

 {

     T **thingp_;

   private:

     // This is implemented in Zone.h.

     inline T **make(T *other);

     void assign(T *other) {

         if (!thingp_)

             thingp_ = make(other);

         else

             *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_ ? *thingp_ : NULL;

     }

     operator bool () const {

         return thingp_ && *thingp_;

     }

 };

 template <typename T> template <typename S> inline

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

 {

     typeCheck<S>();

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

 }

 }

 #endif // _include_jitcraft_rooting_h_