Home | History | Annotate | Download | only in cpp 
      1 /**
      2  * Copied from node_object_wrap.h
      3  * see http://www.nodejs.org/
      4  *
      5  * Node's license follows:
      6  *
      7  * Copyright 2009, 2010 Ryan Lienhart Dahl. All rights reserved.
      8  * Permission is hereby granted, free of charge, to any person obtaining a copy
      9  * of this software and associated documentation files (the "Software"), to
     10  * deal in the Software without restriction, including without limitation the
     11  * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
     12  * sell copies of the Software, and to permit persons to whom the Software is
     13  * furnished to do so, subject to the following conditions:
     14  *
     15  * The above copyright notice and this permission notice shall be included in
     16  * all copies or substantial portions of the Software.
     17  *
     18  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
     19  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
     20  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
     21  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
     22  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
     23  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
     24  * IN THE SOFTWARE.
     25  */
     26 
     27 #ifndef MOCK_RIL_NODE_OBJECT_WRAP_H_
     28 #define MOCK_RIL_NODE_OBJECT_WRAP_H_
     29 
     30 #include <v8.h>
     31 #include <assert.h>
     32 
     33 class ObjectWrap {
     34  public:
     35   ObjectWrap ( ) {
     36     refs_ = 0;
     37   }
     38 
     39   virtual ~ObjectWrap ( ) {
     40     if (!handle_.IsEmpty()) {
     41       assert(handle_.IsNearDeath());
     42       handle_->SetInternalField(0, v8::Undefined());
     43       handle_.Dispose();
     44       handle_.Clear();
     45     }
     46   }
     47 
     48   template <class T>
     49   static inline T* Unwrap (v8::Handle<v8::Object> handle)
     50   {
     51     assert(!handle.IsEmpty());
     52     assert(handle->InternalFieldCount() > 0);
     53     return static_cast<T*>(v8::Handle<v8::External>::Cast(
     54         handle->GetInternalField(0))->Value());
     55   }
     56 
     57   v8::Persistent<v8::Object> handle_; // ro
     58 
     59  protected:
     60   inline void Wrap (v8::Handle<v8::Object> handle)
     61   {
     62     assert(handle_.IsEmpty());
     63     assert(handle->InternalFieldCount() > 0);
     64     handle_ = v8::Persistent<v8::Object>::New(handle);
     65     handle_->SetInternalField(0, v8::External::New(this));
     66     MakeWeak();
     67   }
     68 
     69   inline void MakeWeak (void)
     70   {
     71     handle_.MakeWeak(this, WeakCallback);
     72   }
     73 
     74   /* Ref() marks the object as being attached to an event loop.
     75    * Refed objects will not be garbage collected, even if
     76    * all references are lost.
     77    */
     78   virtual void Ref() {
     79     assert(!handle_.IsEmpty());
     80     refs_++;
     81     handle_.ClearWeak();
     82   }
     83 
     84   /* Unref() marks an object as detached from the event loop.  This is its
     85    * default state.  When an object with a "weak" reference changes from
     86    * attached to detached state it will be freed. Be careful not to access
     87    * the object after making this call as it might be gone!
     88    * (A "weak reference" means an object that only has a
     89    * persistant handle.)
     90    *
     91    * DO NOT CALL THIS FROM DESTRUCTOR
     92    */
     93   virtual void Unref() {
     94     assert(!handle_.IsEmpty());
     95     assert(!handle_.IsWeak());
     96     assert(refs_ > 0);
     97     if (--refs_ == 0) { MakeWeak(); }
     98   }
     99 
    100   int refs_; // ro
    101 
    102  private:
    103   static void WeakCallback (v8::Persistent<v8::Value> value, void *data)
    104   {
    105     ObjectWrap *obj = static_cast<ObjectWrap*>(data);
    106     assert(value == obj->handle_);
    107     assert(!obj->refs_);
    108     if (value.IsNearDeath()) delete obj;
    109   }
    110 };
    111 
    112 #endif // MOCK_RIL_NODE_OBJECT_WRAP_H_
    113