void LuaScriptInstance::ApplyAttributes()
{
    WeakPtr<LuaFunction> function = scriptObjectMethods_[LSOM_APPLYATTRIBUTES];
    if (function && function->BeginCall(this))
    {
        function->EndCall();
    }
}

		/*=============================================================================
		-- Adds the object to the inventory. Effectively "picking up" the object.
		=============================================================================*/
		void Actor::HoldObject(WeakPtr<Object> object)
		{
			if (!object.expired())
			{
				mInventory->AddObject(object);
				object.lock()->SetHost( GetManager()->GetEntity(GetId()) );
			}
		}

void PushWeakObject(duk_context* ctx, Object* object)
{
    if (!object)
    {
        duk_push_null(ctx);
        return;
    }

    duk_push_heap_stash(ctx);

    // Check if the wrapper for the object already exists in stash
    // This is required so that comparisons of object references (e.g. against the me property) work properly
    if (duk_has_prop_index(ctx, -1, (size_t)object))
    {
        duk_get_prop_index(ctx, -1, (size_t)object);
        WeakPtr<Object>* oldPtr = GetWeakPtr(ctx, -1);
        if (oldPtr && oldPtr->Get() == object)
        {
            duk_remove(ctx, -2); // Remove stash
            return;
        }
        else
            duk_pop(ctx); // Valid existing wrapper not found
    }

    duk_push_object(ctx);
    WeakPtr<Object>* ptr = new WeakPtr<Object>(object);
    duk_push_pointer(ctx, ptr);
    duk_put_prop_string(ctx, -2, "\xff""weak");
    duk_push_c_function(ctx, WeakPtr_Finalizer, 1);
    duk_set_finalizer(ctx, -2);

    // Set prototype. If not found, use base class prototype (e.g. IComponent)
    duk_get_global_string(ctx, object->GetTypeName().CString());
    if (!duk_is_object(ctx, -1))
    {
        duk_pop(ctx);
        duk_get_global_string(ctx, object->GetTypeInfo()->GetBaseTypeInfo()->GetTypeName().CString());
    }
    duk_get_prop_string(ctx, -1, "prototype");
    duk_set_prototype(ctx, -3);
    duk_pop(ctx);

    // Proxied property access handling for scene, entity & component
    if (object->GetType() == Scene::GetTypeStatic())
        SetupProxy(ctx, SceneProxyFunctions);
    if (object->GetType() == Entity::GetTypeStatic())
        SetupProxy(ctx, EntityProxyFunctions);
    else if (dynamic_cast<IComponent*>(object))
        SetupProxy(ctx, ComponentProxyFunctions);

    // Store to stash
    duk_dup(ctx, -1);
    duk_put_prop_index(ctx, -3, (size_t)object);
    duk_remove(ctx, -2); // Remove stash
}

void LuaScriptInstance::HandleEvent(StringHash eventType, VariantMap& eventData)
{
    WeakPtr<LuaFunction> function = eventTypeToFunctionMap_[eventType];
    if (function && function->BeginCall(this))
    {
        function->PushUserType(eventType, "StringHash");
        function->PushUserType(eventData, "VariantMap");
        function->EndCall();
    }
}

void LuaScriptInstance::HandleObjectEvent(StringHash eventType, VariantMap& eventData)
{
    Object* object = GetEventSender();
    WeakPtr<LuaFunction> function = objectToEventTypeToFunctionMap_[object][eventType];
    if (function && function->BeginCall(this))
    {
        function->PushUserType(eventType, "StringHash");
        function->PushUserType(eventData, "VariantMap");
        function->EndCall();
    }
}

void LuaScriptInstance::HandlePostFixedUpdate(StringHash eventType, VariantMap& eventData)
{
    using namespace PhysicsPostStep;
    float timeStep = eventData[P_TIMESTEP].GetFloat();

    WeakPtr<LuaFunction> function = scriptObjectMethods_[LSOM_FIXEDPOSTUPDATE];
    if (function && function->BeginCall(this))
    {
        function->PushFloat(timeStep);
        function->EndCall();
    }
}

RawPtr<Node> NodeIntersectionObserverData::createWeakPtr(Node* node)
{
#if ENABLE(OILPAN)
    return node;
#else
    if (!m_weakPointerFactory)
        m_weakPointerFactory = new WeakPtrFactory<Node>(node);
    WeakPtr<Node> result = m_weakPointerFactory->createWeakPtr();
    ASSERT(result.get() == node);
    return result;
#endif
}

		/*=============================================================================
		-- Drops the object with the id in the inventory if it exists.
		=============================================================================*/
		void Actor::DropObject(int id)
		{
			//place the object on the ground behind the Actor so it does not walk over it right away.
			WeakPtr<Object> object = mInventory->GetObject(id);

			if (!object.expired())
			{
				object.lock()->SetHeld(false);
				object.lock()->SetPos(Vector3D<double>(GetPos().x+32.0, GetPos().y+32.0, GetPos().z+2.0));
				mInventory->RemoveObject(id);
			}
		}

		/*=============================================================================
		-- Special actions for colliding with certain enity types.
		=============================================================================*/
		void Actor::ReactToCollision(WeakPtr<Entity> entity)
		{
			if (entity.expired())
				return;

			if (entity.lock()->GetType() == OBJECT)
			{
				WeakPtr<Object> object = WeakPtr<Object>(DynamicPtrCast<Object>(entity.lock()));

				if (object.lock()->GetObtainable())
					HoldObject( object );
			}
		}

void LuaScriptInstance::SetScriptNetworkDataAttr(PODVector<unsigned char> data)
{
    if (scriptObjectRef_ == LUA_REFNIL)
        return;

    WeakPtr<LuaFunction> function = scriptObjectMethods_[LSOM_READNETWORKUPDATE];
    if (function && function->BeginCall(this))
    {
        MemoryBuffer buf(data);
        function->PushUserType((Deserializer&)buf, "Deserializer");
        function->EndCall();
    }
}

void LuaScript::HandleEvent(StringHash eventType, VariantMap& eventData)
{
    LuaFunctionVector& functions = eventHandleFunctions_[eventType];
    for (unsigned i = 0; i < functions.Size(); ++i)
    {
        WeakPtr<LuaFunction> function = functions[i];
        if (function && function->BeginCall())
        {
            function->PushUserType(eventType, "StringHash");
            function->PushUserType(eventData, "VariantMap");
            function->EndCall();
        }
    }
}

void GenericEventQueue::sharedTimerFired()
{
    ASSERT(!sharedTimer().isActive());
    ASSERT(!pendingQueues().isEmpty());

    while (!pendingQueues().isEmpty()) {
        WeakPtr<GenericEventQueue> queue = pendingQueues().takeFirst();
        if (!queue)
            continue;
        queue->dispatchOneEvent();
    }

    if (sharedTimer().isActive())
        sharedTimer().stop();
}

    WeakPtr(const WeakPtr<S>& src)
    {
        if (src.isValid()) {
            ptr = src.getRawPtr();
#ifdef WEAK_PTR_HAS_EXTRA_PTR_TO_COUNTERS
            heapObjectCounters = HeapObjectRefManipulator::getHeapObjectCounters(ptr);
#endif
            HeapObjectRefManipulator::incWeakCounter(getHeapObjectCounters());
        } else {
            ptr = NULL;
#ifdef WEAK_PTR_HAS_EXTRA_PTR_TO_COUNTERS
            heapObjectCounters = NULL;
#endif
        }
    }

InProcessWorkerObjectProxy::InProcessWorkerObjectProxy(
    const WeakPtr<InProcessWorkerMessagingProxy>& messagingProxy)
    : m_messagingProxy(messagingProxy.get()),
      m_messagingProxyWeakPtr(messagingProxy),
      m_defaultIntervalInSec(kDefaultIntervalInSec),
      m_nextIntervalInSec(kDefaultIntervalInSec),
      m_maxIntervalInSec(kMaxIntervalInSec) {}

void LuaScriptInstance::OnMarkedDirty(Node* node)
{
    // Script functions are not safe from worker threads
    Scene* scene = GetScene();
    if (scene && scene->IsThreadedUpdate())
    {
        scene->DelayedMarkedDirty(this);
        return;
    }

    WeakPtr<LuaFunction> function = scriptObjectMethods_[LSOM_TRANSFORMCHANGED];
    if (function && function->BeginCall(this))
    {
        function->EndCall();
    }
}

PODVector<unsigned char> LuaScriptInstance::GetScriptNetworkDataAttr() const
{
    if (scriptObjectRef_ == LUA_REFNIL)
        return PODVector<unsigned char>();

    VectorBuffer buf;

    WeakPtr<LuaFunction> function = scriptObjectMethods_[LSOM_WRITENETWORKUPDATE];
    if (function && function->BeginCall(this))
    {
        function->PushUserType((Serializer&)buf, "Serializer");
        function->EndCall();
    }

    return buf.GetBuffer();
}

SimpleReaderNode::Ptr SimpleReaderNode::create(const QString &name, WeakPtr parent)
{
    Ptr newNode(new SimpleReaderNode(name, parent));
    newNode->m_weakThis = newNode;
    if (parent)
        parent.data()->m_children.append(newNode);
    return newNode;
}

void LuaScriptInstance::ReleaseObject()
{
    if (scriptObjectRef_ == LUA_REFNIL)
        return;

    if (IsEnabledEffective())
        UnsubscribeFromScriptMethodEvents();

    // Unref script object
    luaL_unref(luaState_, LUA_REGISTRYINDEX, scriptObjectRef_);
    scriptObjectRef_ = LUA_REFNIL;

    WeakPtr<LuaFunction> function = luaScript_->GetFunction("DestroyScriptObjectInstance");
    if (function && function->BeginCall())
    {
        function->PushUserType((void*)this, "LuaScriptInstance");
        function->EndCall();
    }
}

ImageDataCache::Ptr ImageDataCachePrivate::lookup(ImageDataMetadata::Ptr metadata)
{
    if (cache.contains(metadata)) {
        WeakPtr weakPtr = cache[metadata];
        ImageDataCache::Ptr ptr = weakPtr.toStrongRef();

        if (ptr.isNull()) {
            cache.remove(metadata);
        } else {
            return ptr;
        }
    }

    ImageDataCache::Ptr ptr(new ImageDataCache::CacheEntry());

    cache.insert(metadata, ptr.toWeakRef());

    return ptr;
}

const SymbolPath SymbolNode::getSymPath() const
{
	SymbolPath path;
	const SymbolNode* curNode = this;
	for (WeakPtr wpParent = m_parent; !wpParent.isNull();)
	{
		Ptr pParent = wpParent.toStrongRef();
		for (ConstChildIterator pChild = pParent->childConstBegin();
			pChild != pParent->childConstEnd(); ++pChild)
		{
			if (pChild.value().data() == curNode)
			{
				path.addParentSymbol(pChild.key());
				break;
			}
		}
		wpParent = pParent->m_parent;
	}
	return path;
}