Removes an activity from the list of activities with routing constraints.
@param activity The name of the activity to remove.
@throws ParameterException if the activity name is invalid.
351778
private void removeActivityWithConstraints(String activity) {
		Validate.notNull(activity);
		Validate.notEmpty(activity);
		Set<String> currentActivities = getActivitiesWithRoutingConstraints();
		currentActivities.remove(activity);
		setProperty(ConstraintContextProperty.ACTIVITIES_WITH_CONSTRAINTS, ArrayUtils.toString(currentActivities.toArray()));
	}
676631
function removeAction(action, ctrl) {
      if (this.actionExists(action, ctrl)) {
        this.removeActionIcon(action, ctrl);
        delete ctrl.actionListService.actionsToIndex[action.name];
        delete ctrl.actionListService.onToggle[action.name];
        var i = ctrl.actionListService.actionsToDisplay.indexOf(action.name);
        ctrl.actionListService.actionsToDisplay.splice(i, 1);
        i = ctrl.actionListService.requiredActionsList.indexOf(action.name);
        ctrl.actionListService.requiredActionsList.splice(i, 1);
      }
    }
184835
private void removeActivityFromStack(Activity activity){

		Iterator<WeakReference<Activity>> activityStackIterator = activityStack.iterator();
		while(activityStackIterator.hasNext()){
			Activity activityFromWeakReference = activityStackIterator.next().get();

			if(activityFromWeakReference == null){
				activityStackIterator.remove();
			}

			if(activity != null && activityFromWeakReference != null && activityFromWeakReference.equals(activity)){
				activityStackIterator.remove();
			}
		}
	}
1320671
@Nonnull
  public URLParameterList remove (@Nullable final String sName)
  {
    removeIf (aParam -> aParam.hasName (sName));
    return this;
  }
655972
public function removePrimaryResource(Activity $activity)
    {
        $activity->setPrimaryResource();
        $this->om->persist($activity);
        $this->om->flush();
    }
1275024
public void removePath(int pathId) {
        PreparedStatement statement = null;

        try (Connection sqlConnection = sqlService.getConnection()) {
            // remove any enabled overrides with this path
            statement = sqlConnection.prepareStatement(
                "DELETE FROM " + Constants.DB_TABLE_ENABLED_OVERRIDE +
                    " WHERE " + Constants.ENABLED_OVERRIDES_PATH_ID + " = ?"
            );
            statement.setInt(1, pathId);
            statement.executeUpdate();
            statement.close();

            // remove path
            statement = sqlConnection.prepareStatement(
                "DELETE FROM " + Constants.DB_TABLE_PATH
                    + " WHERE " + Constants.GENERIC_ID + " = ?"
            );
            statement.setInt(1, pathId);
            statement.executeUpdate();
            statement.close();

            //remove path from responseRequest
            statement = sqlConnection.prepareStatement(
                "DELETE FROM " + Constants.DB_TABLE_REQUEST_RESPONSE
                    + " WHERE " + Constants.REQUEST_RESPONSE_PATH_ID + " = ?"
            );
            statement.setInt(1, pathId);
            statement.executeUpdate();
            statement.close();
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            try {
                if (statement != null) {
                    statement.close();
                }
            } catch (Exception e) {
            }
        }
    }
1290838
private void doRemoveMapping() throws PageException {
	admin.removeMapping(getString("admin", action, "virtual"));
	store();
	adminSync.broadcast(attributes, config);
    }
901310
public void removeApplication(Application app) {
        this.appNameApplicationMap.remove(app.getName().toUpperCase(Locale.ROOT));
        this.applications.remove(app);
    }
1188826
@Override
  public void removeProject(final Project project, final String user)
      throws ProjectManagerException {

    final long updateTime = System.currentTimeMillis();
    final String UPDATE_INACTIVE_PROJECT =
        "UPDATE projects SET active=false,modified_time=?,last_modified_by=? WHERE id=?";
    try {
      this.dbOperator.update(UPDATE_INACTIVE_PROJECT, updateTime, user, project.getId());
    } catch (final SQLException e) {
      logger.error("error remove project " + project.getName(), e);
      throw new ProjectManagerException("Error remove project " + project.getName(), e);
    }
  }
1273215
public synchronized void removeSession(Endpoint ep, SessionExt sess) {
        Class<?> cl = ep.getClass();

        if (cl.equals(AnnotatedEndpoint.class)) {
            AnnotatedEndpoint ae = (AnnotatedEndpoint) ep;
            cl = ae.getServerEndpointClass();
        }

        // Always try to remove http session if we can.
        String id = sess.getSessionImpl().getHttpSessionID();
        if (id != null) {
            httpSessionMap.remove(id);
        }

        // find the session array for the given endpoint
        ArrayList<Session> sa = endpointSessionMap.get(cl);

        // nothing to remove if we don't have a session
        if (sa == null) {
            return;
        }

        // remove the new session from the list for this endpoint
        sa.remove(sess);

        // put the updated list back into the Map
        endpointSessionMap.put(cl, sa);

        if (tc.isDebugEnabled()) {
            Tr.debug(tc, "removed session of: " + sess.getId() + "  from endpoint class of: " + cl.getName() + " in endpointmanager of: " + this.hashCode());
        }
    }
726179
public void removeParameter( String name )
    {
        if (_parameters == null || !_parameters.hasParameters())
            return;

        _parameters.removeParameter(name);
    }
794755
private void removeLayoutParamsRule(RelativeLayout.LayoutParams layoutParams) {
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN_MR1) {
            layoutParams.removeRule(RelativeLayout.ALIGN_PARENT_RIGHT);
            layoutParams.removeRule(RelativeLayout.ALIGN_PARENT_END);
            layoutParams.removeRule(RelativeLayout.ALIGN_PARENT_LEFT);
            layoutParams.removeRule(RelativeLayout.ALIGN_PARENT_START);
        } else {
            layoutParams.addRule(RelativeLayout.ALIGN_PARENT_RIGHT, 0);
            layoutParams.addRule(RelativeLayout.ALIGN_PARENT_LEFT, 0);
        }
    }
652599
public void removeCallbacks(Runnable r) {
        assert handler != null;
        if (!sanityCheck("removeCallbacks " + r)) {
            return;
        }
        handler.removeCallbacks(r);
    }
712788
public void delete(String statement,
                       Object parameter,
                       Class<? extends Entity> entityClass) {
        if (!bulkDeleteOperations.containsKey(entityClass)) {
            bulkDeleteOperations.put(entityClass,
                                     new ArrayList<BulkDeleteOperation>(1));
        }
        bulkDeleteOperations.get(entityClass).add(new BulkDeleteOperation(dbSqlSessionFactory.mapStatement(statement),
                                                                          parameter));
    }
1051243
public void removeHttpSession(final HttpSession session) {
		if (View.isInitialised() && !EventQueue.isDispatchThread()) {
			EventQueue.invokeLater(new Runnable() {

				@Override
				public void run() {
					removeHttpSession(session);
				}
			});

			return;
		}

		int index = sessions.indexOf(session);
		sessions.remove(index);
		fireTableRowsDeleted(index, index);
	}
321566
public void removeFolderParam(String key) {

        if (m_searchObject.getFolders().contains(key)) {
            m_handler.onClearFolders(Collections.singletonList(key));
            m_searchObject.removeFolder(key);
            updateResultsTab(false);
            ValueChangeEvent.fire(this, m_searchObject);
        }
    }
1119807
public void removeErrorPage(PageException pe) {
	// exception
	ErrorPage ep = getErrorPage(pe, ErrorPage.TYPE_EXCEPTION);
	if (ep != null) {
	    pages.remove(ep);
	    hasChanged = true;
	}
	// request
	ep = getErrorPage(pe, ErrorPage.TYPE_REQUEST);
	if (ep != null) {
	    pages.remove(ep);
	    hasChanged = true;
	}
	// validation
	ep = getErrorPage(pe, ErrorPage.TYPE_VALIDATION);
	if (ep != null) {
	    pages.remove(ep);
	    hasChanged = true;
	}

    }