void Table::removeConstraint(unsigned idx)
{
	try
	{
		removeObject(idx,OBJ_CONSTRAINT);
	}
	catch(Exception &e)
	{
		throw Exception(e.getErrorMessage(), e.getErrorType(),__PRETTY_FUNCTION__,__FILE__,__LINE__, &e);
	}
}

void LogicObject::
removeState(State* state)
{
    bool status = removeObject(state);
    if (!status) {
        return;
    }
    assert(state != 0);
    state->deleteLater();
    Base::Utility::ignoreUnused(status);
}

void View::removeObject(const QString &name, ObjectType obj_type)
{
	try
	{
		removeObject(getObjectIndex(name, obj_type), obj_type);
	}
	catch(Exception &e)
	{
		throw Exception(e.getErrorMessage(), e.getErrorType(),__PRETTY_FUNCTION__,__FILE__,__LINE__, &e);
	}
}

void Module::unloadPC() {
	if (!_pc)
		return;

	removeObject(*_pc);

	removePCTokens();

	delete _pc;
	_pc = 0;
}

void Storage::removeObject(GeometryObject* obj) {
  if (obj->isCompound()) {
     printf("Removing compound object.\n");
     const list<GeometryObject*>& objects = ((Compound*)obj)->getObjects();
     for(CompoundIter it = objects.begin(); it != objects.end(); it++) {
        removeObject(*it);
     }
  } else {
     objs.remove(obj); 
  }
}

bool CSVRender::Cell::removeObject (const std::string& id)
{
    std::map<std::string, Object *>::iterator iter =
        mObjects.find (Misc::StringUtils::lowerCase (id));

    if (iter==mObjects.end())
        return false;

    removeObject (iter);
    return true;
}

void Table::removeObject(const QString &name, ObjectType obj_type)
{
	int idx;

	//Gets the object index
	getObject(name,obj_type,idx);

	//Removes the object If it was found (idx >= 0)
	if(idx>=0)
		removeObject(static_cast<unsigned>(idx),obj_type);
}

void Table::removeIndex(unsigned idx)
{
	try
	{
		removeObject(idx,OBJ_INDEX);
	}
	catch(Exception &e)
	{
		throw Exception(e.getErrorMessage(), e.getErrorType(),__PRETTY_FUNCTION__,__FILE__,__LINE__, &e);
	}
}

//
// MetaTable::clearTable
//
// Removes all objects from a metatable.
//
void MetaTable::clearTable()
{
   MetaObject *obj = NULL;

   // iterate on the source table
   while((obj = tableIterator(NULL)))
   {
      removeObject(obj);

      delete obj;
   }
}

GLSLEditorPlugin::~GLSLEditorPlugin()
{
    removeObject(m_editor);
    delete m_actionHandler;
    delete m_glsl_120_frag;
    delete m_glsl_120_vert;
    delete m_glsl_120_common;
    delete m_glsl_es_100_frag;
    delete m_glsl_es_100_vert;
    delete m_glsl_es_100_common;
    m_instance = 0;
}

//
// MetaTable::clearTable
//
// Removes all objects from a metatable.
//
void MetaTable::clearTable()
{
   MetaObject *obj = NULL;

   // iterate on the source table
   while((obj = tableIterator(obj)))
   {
      removeObject(obj);
      delete obj;
      obj = NULL; // restart from the beginning
   }
}

    void PhysicsSystem::scaleObject (const std::string& handle, float scale)
    {
        if(handleToMesh.find(handle) != handleToMesh.end())
        {
            btTransform transform = mEngine->getRigidBody(handle)->getWorldTransform();
            removeObject(handle);

            Ogre::Quaternion quat = Ogre::Quaternion(transform.getRotation().getW(), transform.getRotation().getX(), transform.getRotation().getY(), transform.getRotation().getZ());
            Ogre::Vector3 vec = Ogre::Vector3(transform.getOrigin().getX(), transform.getOrigin().getY(), transform.getOrigin().getZ());
            addObject(handle, handleToMesh[handle], quat, scale, vec);
        }
    }

    void testNodeRemovalAlongCut() {
        addObject(ObjID(1), ObjID(0), true);
        addObject(ObjID(2), ObjID(1), true);
        addObject(ObjID(3), ObjID(1), true);
        addObject(ObjID(4), ObjID(1), true);
        refineToBottom();
        verifyTreesMatch();

#ifdef LIBPROX_LIFT_CUTS
        removeObject(ObjID(4));
        // When lifting, this'll force lifting up to the next node, in this case
        // the root
        TS_ASSERT_EQUALS(replicated_handler->numNodes(), 1);
        // Removing the other two children should leave us in the same place
        removeObject(ObjID(3));
        TS_ASSERT_EQUALS(replicated_handler->numNodes(), 1);
        removeObject(ObjID(2));
        TS_ASSERT_EQUALS(replicated_handler->numNodes(), 1);
#else
        removeObject(ObjID(4));
        // Removing one of the nodes, node 4, should leave the cut through the
        // other two nodes, 2 and 3, intact.
        TS_ASSERT_EQUALS(replicated_handler->numNodes(), 3);
        verifyTreesMatch();
        // We should be able to do the same with node 3
        removeObject(ObjID(3));
        TS_ASSERT_EQUALS(replicated_handler->numNodes(), 2);
        verifyTreesMatch();
        // And finally drop back to only the root
        removeObject(ObjID(2));
        TS_ASSERT_EQUALS(replicated_handler->numNodes(), 1);
        verifyTreesMatch();
#endif
    }

 static void initialize()
 {
   commentOnlyObjectName();
   commentOnlyObjectText();
   version();
   header();
   commentOnlyLine();
   contentAndCommentLine();
   group();
   includeFile();
   removeObject();
   line();
   memoProperty();
   noteProperty();
   objectNoFields();
   objectAndFields();
   uniqueProperty();
   requiredObjectProperty();
   obsoleteProperty();
   hasurlProperty();
   extensibleProperty();
   formatProperty();
   minFieldsProperty();
   maxFieldsProperty();
   field();
   closingField();
   lastField();
   name();
   nameProperty();
   requiredFieldProperty();
   autosizableProperty();
   autocalculatableProperty();
   retaincaseProperty();
   unitsProperty();
   ipUnitsProperty();
   minExclusiveProperty();
   minInclusiveProperty();
   maxExclusiveProperty();
   maxInclusiveProperty();
   deprecatedProperty();
   defaultProperty();
   automaticDefault();
   typeProperty();
   keyProperty();
   objectListProperty();
   externalListProperty();
   referenceProperty();
   beginExtensible();
   beginExtensibleProperty();
   metaDataComment();
   versionObjectName();
 }

    void PhysicsSystem::scaleObject (const Ptr& ptr)
    {
        Ogre::SceneNode* node = ptr.getRefData().getBaseNode();
        std::string handle = node->getName();
        if(handleToMesh.find(handle) != handleToMesh.end())
        {
            removeObject(handle);
            addObject(ptr);
        }

        if (OEngine::Physic::PhysicActor* act = mEngine->getCharacter(handle))
            act->setScale(node->getScale().x);
    }

// Same as above, but takes a Set instead of a Vector.  Should only be called during teardown.
void PhysicsEngine::deleteObjects(SetOfMotionStates& objects) {
    for (auto object : objects) {
        btRigidBody* body = object->getRigidBody();
        removeObject(object);

        // NOTE: setRigidBody() modifies body->m_userPointer so we should clear the MotionState's body BEFORE deleting it.
        object->setRigidBody(nullptr);
        body->setMotionState(nullptr);
        delete body;
        object->releaseShape();
        delete object;
    }
}

void Simulator::tick_work(Time last_time, Duration elapsed) {
    SimulatorBase::tick_work(last_time, elapsed);

    if (mForceRebuild || (mForceInitialRebuild && last_time == Time::null())) {
        mHandler->rebuild();
        // For the tests run in the simulator, we want to perform rebuilds
        // synchronously
        mHandler->waitForRebuild();
    }
    else {

        // Object Churn...
        for(int i = 0; !mObjects.empty() && i < mChurn; i++) {
            Object* obj = mObjects.begin()->second;
            removeObject(obj);
        }
        for(int i = 0; !(mRemovedDynamicObjects.empty() && mRemovedStaticObjects.empty()) && i < mChurn; i++) {
            Object* obj = (!mRemovedDynamicObjects.empty() ? mRemovedDynamicObjects.begin()->second : mRemovedStaticObjects.begin()->second);
            addObject(obj);
        }
    }

    // Give all queries a chance to update
    for(QueryList::iterator it = mQueries.begin(); it != mQueries.end(); it++)
        (*it)->tick(mTime);

    // Tick the handler
    if (mForceRebuild || last_time == Time::null()) {
        // To simplify stats collection with rebuilds, we allow for
        // double-ticking.  We use the same timestep and just.  This just lets
        // us get valid "checks" counts when we're rebuilding every frame.
        // We also do this always on the first tick to avoid reporting the
        // initial cost of pushing down a cut.
        mHandler->tick(mTime, false);
        mHandler->tick(mTime, true);
    }
    else {
        // normal ticking
        mHandler->tick(mTime);
    }

    mItsSinceRateApprox++;
    if (mItsSinceRateApprox >= RATE_APPROX_ITERATIONS) {
        float its_per_sec = float(RATE_APPROX_ITERATIONS) * queriesSize() / (elapsed - mRateApproxStart).seconds();
        if (mReportRate)
            printf("{ \"rate\" : %f }\n", its_per_sec);
        // Reset for next round
        mItsSinceRateApprox = 0;
        mRateApproxStart = elapsed;
    }
}

void PhysicsSim::shootTestSphere()
{
	removeObject(testSphere);

	testSphere = loadSceneObject("lemon.dae");
	testSphere->setPosition(fpscam->getPosition());
	testSphere->setScale(Vector3D(2,2,2));
	PhysicalObject* phyObj = applyPhysics(testSphere, shSphere, 20);

	vector3df dir = fpscam->getTarget() - fpscam->getPosition();
	dir = 250*dir.normalize();
	phyObj->getRigidBody()->applyCentralImpulse(btVector3(dir.X, dir.Y, dir.Z));

}

bool PluginManager::unloadPlugin(PluginFile *plugin)
{
    bool derivedPlugin = qobject_cast<Plugin*>(plugin->instance) != nullptr;

    if (plugin->loader->unload()) {
        if (!derivedPlugin)
            removeObject(plugin->instance);

        plugin->instance = nullptr;
        return true;
    } else {
        return false;
    }
}

//-----------------------------------------------------------------------------
// addObject()
//-----------------------------------------------------------------------------
BOOL LLViewerJointAttachment::addObject(LLViewerObject* object)
{
	object->extractAttachmentItemID();

	if (isObjectAttached(object))
	{
		llinfos << "(same object re-attached)" << llendl;
		removeObject(object);
		// Pass through anyway to let setupDrawable()
		// re-connect object to the joint correctly
	}
	
	// Two instances of the same inventory item attached --
	// Request detach, and kill the object in the meantime.
	if (getAttachedObject(object->getAttachmentItemID()))
	{
		llinfos << "(same object re-attached)" << llendl;
		object->markDead();

		// If this happens to be attached to self, then detach.
		LLVOAvatar::detachAttachmentIntoInventory(object->getAttachmentItemID());
		return FALSE;
	}

	mAttachedObjects.push_back(object);
	setupDrawable(object);
	
	if (mIsHUDAttachment)
	{
		if (object->mText.notNull())
		{
			object->mText->setOnHUDAttachment(TRUE);
		}
		LLViewerObject::const_child_list_t& child_list = object->getChildren();
		for (LLViewerObject::child_list_t::const_iterator iter = child_list.begin();
			 iter != child_list.end(); ++iter)
		{
			LLViewerObject* childp = *iter;
			if (childp && childp->mText.notNull())
			{
				childp->mText->setOnHUDAttachment(TRUE);
			}
		}
	}
	calcLOD();
	mUpdateXform = TRUE;

	return TRUE;
}