/*

  * 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 "Heap.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<const T **>(handle.thingp_);

     }

     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 **addr() 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_;

     Local<Object> *prev_;

     T *thing_;

     Local<Object> *prev() {

         return prev_;

     }

     Local<Object> *toRaw() {

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

     }

   public:

     inline explicit Local(Zone *zone);

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

     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 **addr() {

         return (Object **)&thing_;

     }

     Object * const *addr() 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:

     inline T **make(const T *&other);

     inline void assign(const T *&other) {

         if (!thingp_)

             thingp_ = make(other);

         else

             *thingp_ = other;

     }

   public:

     ScopedRoot()

     { }

     inline ScopedRoot(const T *&thing);

     inline ScopedRoot(const ScopedRoot<T> &other);

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

         assign(*other);

         return *this;

     }

     ScopedRoot &operator =(const T *&other) {

         assign(other);

         return *this;

     }

     T *operator ->() const {

         return operator *();

     }

     T *operator *() const {

         return thing_;

     }

     operator bool () const {

         return !!thing_;

     }

 };

 template <typename T> template <typename S> inline

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

 {

     typeCheck<S>();

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

 }

 // A RootScope is necessary for using ScopedRoot<>.

 class RootScope

 {

     friend class Zone;

     struct Block

     {

         static const size_t kItemsPerBlock = 4096 / sizeof(Object *);

         Object **base;

         Object **ptr;

         Object **end;

         Block *prev;

         Block(Block *prev, Object **base)

           : base(base),

             ptr(base),

             end(base + kItemsPerBlock),

             prev(prev)

         {

         }

     };

   private:

 };

 }

 #endif // _include_jitcraft_rooting_h_