C++ Persistent::MakeWeak方法代码示例

 void ScriptSystem::AddToComponentMap(dtEntity::ComponentType ct, dtEntity::EntityId eid, v8::Handle<v8::Object> obj)
 {
    HandleScope scope;
    Persistent<Object> pobj = Persistent<Object>::New(obj);
    pobj.MakeWeak(this, &ComponentWrapperDestructor);
    V8::AdjustAmountOfExternalAllocatedMemory(sizeof(dtEntity::Component));
    mComponentMap[std::make_pair(ct, eid)] = pobj;
 }

Handle<Value> rr_v8_external_create(VALUE value) {
  rb_hash_aset(references, rb_obj_id(value), value);
  Local<Value> external(External::New((void *)value));
  Persistent<Value> record = Persistent<Value>::New(external);
  // V8::AdjustAmountOfExternalAllocatedMemory(100000000);
  record.MakeWeak(NULL, GCWeakReferenceCallback);
  return external;
}

int Conv::BindToJavaObject(JNIEnv *jniEnv, jobject jLocal, Handle<Object> val, jobject *jGlobal) {
  int result = OK;
  Persistent<Object> pVal = Persistent<Object>::New(val);
  jobject ob = jniEnv->NewGlobalRef(jLocal);
  pVal.MakeWeak(ob, releaseJavaRef);
  val->SetPointerInInternalField(0, ob);
  jniEnv->SetLongField(jLocal, instHandle, asLong(pVal));
  *jGlobal = ob;
  return result;
}

Handle<Value> JsEngine::AnyToV8(jsvalue v, int32_t contextId)
{
	if (v.type == JSVALUE_TYPE_EMPTY) {
		return Handle<Value>();
	}
	if (v.type == JSVALUE_TYPE_NULL) {
        return Null();
    }
    if (v.type == JSVALUE_TYPE_BOOLEAN) {
        return Boolean::New(v.value.i32);
    }
    if (v.type == JSVALUE_TYPE_INTEGER) {
        return Int32::New(v.value.i32);
    }
    if (v.type == JSVALUE_TYPE_NUMBER) {
        return Number::New(v.value.num);
    }
    if (v.type == JSVALUE_TYPE_STRING) {
        return String::New(v.value.str);
    }
    if (v.type == JSVALUE_TYPE_DATE) {
        return Date::New(v.value.num);
    }
	
    // Arrays are converted to JS native arrays.
    
    if (v.type == JSVALUE_TYPE_ARRAY) {
        Local<Array> a = Array::New(v.length);
        for(int i = 0; i < v.length; i++) {
            a->Set(i, AnyToV8(v.value.arr[i], contextId));
        }
        return a;        
    }
        
    // This is an ID to a managed object that lives inside the JsContext keep-alive
    // cache. We just wrap it and the pointer to the engine inside an External. A
    // managed error is still a CLR object so it is wrapped exactly as a normal
    // managed object.
    if (v.type == JSVALUE_TYPE_MANAGED || v.type == JSVALUE_TYPE_MANAGED_ERROR) {
		ManagedRef* ref = new ManagedRef(this, contextId, v.length);
		Local<Object> object = (*(managed_template_))->InstanceTemplate()->NewInstance();
		if (object.IsEmpty()) {
			return Null();
		}
		
		Persistent<Object> persistent = Persistent<Object>::New(object);
		persistent->SetInternalField(0, External::New(ref));
		persistent.MakeWeak(NULL, managed_destroy);
        return persistent;
    }

    return Null();
}

void Shape::New(const v8::FunctionCallbackInfo<Value>& args)
{
  HandleScope scope;
  Handle<Object> self = args.Holder();
  Shape *shape;

  if (args[0]->IsExternal())
  {
    Local<External> ext = Local<External>::Cast(args[0]);
    void *ptr = ext->Value();
    shape = static_cast<Shape*>(ptr);
    shape->Wrap(args.Holder());
  }
  else
  {
    shapeObj *s = (shapeObj *)msSmallMalloc(sizeof(shapeObj));

    msInitShape(s);
    if(args.Length() >= 1) {
      s->type = args[0]->Int32Value();
    }
    else {
      s->type = MS_SHAPE_NULL;
    }

    shape = new Shape(s);
    shape->Wrap(self);
  }

  /* create the attribute template. should use ObjectWrap in future */
  Handle<ObjectTemplate> attributes_templ = ObjectTemplate::New();
  attributes_templ->SetInternalFieldCount(2);
  attributes_templ->SetNamedPropertyHandler(attributeGetValue,
                                            attributeSetValue);
  Handle<Object> attributes = attributes_templ->NewInstance();
  map<string, int> *attributes_map = new map<string, int>();
  attributes->SetInternalField(0, External::New(attributes_map));
  attributes->SetInternalField(1, External::New(shape->get()->values));  
  attributes->SetHiddenValue(String::New("__parent__"), self);

  if (shape->layer) {
    for (int i=0; i<shape->layer->numitems; ++i) {
      (*attributes_map)[string(shape->layer->items[i])] = i;
    }
  }

  Persistent<Object> pattributes;
  pattributes.Reset(Isolate::GetCurrent(), attributes);
  pattributes.MakeWeak(attributes_map, attributeWeakCallback);
  pattributes.MarkIndependent();

  self->Set(String::New("attributes"), attributes);
}

Handle<Value> def_timestep_image_map_constructor(const Arguments &args) {
	int arg_length = args.Length();
	Handle<Object> thiz = Handle<Object>::Cast(args.This());

	timestep_image_map *map = timestep_image_map_init();
	Local<External> m = External::New(map);
	thiz->SetInternalField(0, m);
	
	map->x = args[1]->NumberValue();
	map->y = args[2]->NumberValue();
	map->width = args[3]->NumberValue();
	map->height = args[4]->NumberValue();

	// to support both marcus-spritemaps (TM) as well as 
	// normal old style image maps (those that don't have explicit margins),
	// check the argument length.  If there are only 6 arguments, there are not
	// specified margins.  Set them to 0.
	Handle<Value> url_val;
	if (arg_length == 6) {
		url_val = args[5];
		map->margin_top = 0;
		map->margin_right = 0;
		map->margin_bottom = 0;
		map->margin_left = 0;
	} else {
		url_val = args[9];
		map->margin_top = args[5]->NumberValue();
		map->margin_right = args[6]->NumberValue();
		map->margin_bottom = args[7]->NumberValue();
		map->margin_left = args[8]->NumberValue();
	}
	
	// WARNING: must not forget to free this at some point
	String::Utf8Value str(url_val);
	map->url = strdup(ToCString(str));

	Persistent<Object> ref = Persistent<Object>::New(thiz);
	ref.MakeWeak(map, image_map_finalize);
	
	return thiz;
}

// コンストラクタ
TJSObject::TJSObject(Handle<Object> obj, const tTJSVariant &variant) : TJSBase(variant)
{
	wrap(obj);
	Persistent<Object> ref = Persistent<Object>::New(obj);
	ref.MakeWeak(this, release);
}

extern "C" void test(WeakReferenceCallback* cleanup) {
    Persistent<Context> c = createContext();
    HandleScope handle_scope;
    Persistent<Object> o = Persistent<Object>::New(Object::New());
    o.MakeWeak(cleanup, disposeHandle);
}

extern "C" void makeWeak(Persistent<Value> prst, CALLBACK* cleanup) {
    prst.MakeWeak(cleanup, disposeHandle);
//    cout << "Hello from makeWeak c++" << endl;
}