Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
   /*
    * OfficeFloor - http://www.officefloor.net
    * Copyright (C) 2005-2011 Daniel Sagenschneider
    *
    * This program is free software: you can redistribute it and/or modify
    * it under the terms of the GNU General Public License as published by
    * the Free Software Foundation, either version 3 of the License, or
    * (at your option) any later version.
    *
   * This program is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   * GNU General Public License for more details.
   *
   * You should have received a copy of the GNU General Public License
   * along with this program.  If not, see <http://www.gnu.org/licenses/>.
   */
  
  package net.officefloor.model.impl.officefloor;
  
  import java.util.Arrays;
  import java.util.HashMap;
  import java.util.HashSet;
  import java.util.List;
  import java.util.Map;
  import java.util.Set;
  
net.officefloor.model.officefloor.OfficeFloorChanges implementation.

Author(s):
Daniel Sagenschneider
  
  public class OfficeFloorChangesImpl implements OfficeFloorChanges {

  
  	private final OfficeFloorModel officeFloor;

Initiate.

  
  	public OfficeFloorChangesImpl(OfficeFloorModel officeFloor) {
  		this. = officeFloor;
  	}

 
 	public static String getManagedObjectScope(ManagedObjectScope scope) {
 
 		// Ensure have scope
 		if (scope == null) {
 			return null;
 		}
 
 		// Return the text of the scope
 		switch (scope) {
 		case :
 		case :
 		case :
 		default:
 			throw new IllegalStateException("Unknown scope " + scope);
 		}
 	}
 
 	/*
 	 * ================= OfficeFloorChanges ==============================
 	 */
 
 			String officeSourceClassNameString officeLocation,
 			PropertyList propertyListOfficeType officeType) {
 
 		// TODO test this method (addDeployedOffice)
 
 		// Create the deployed office
 		final DeployedOfficeModel office = new DeployedOfficeModel(officeName,
 				officeSourceClassNameofficeLocation);
 		for (Property property : propertyList) {
 			office.addProperty(new PropertyModel(property.getName(), property
 					.getValue()));
 		}
 
 		// Add the inputs for the office
 		for (OfficeInputType input : officeType.getOfficeInputTypes()) {
 					input.getParameterType()));
 		}
 
 		// Add the teams for the office
 		for (OfficeTeamType team : officeType.getOfficeTeamTypes()) {
 		}
 
 		// Add the objects for the office
 		for (OfficeManagedObjectType managedObject : officeType
 					managedObject.getOfficeManagedObjectName(), managedObject
 		}
 
 		// Return the change to add the office
 		return new AbstractChange<DeployedOfficeModel>(office"Add office") {
 			public void apply() {
 			}
 
 			public void revert() {
 			}
 		};
 	}
 
 			final DeployedOfficeModel deployedOffice) {
 
 		// TODO test this method (removeDeployedOffice)
 
 		// Return change to remove the office
 		return new AbstractChange<DeployedOfficeModel>(deployedOffice,
 				"Remove office") {
 			public void apply() {
 						.removeDeployedOffice(deployedOffice);
 			}
 
 			public void revert() {
 						.addDeployedOffice(deployedOffice);
 			}
 		};
 	}
 
 			final DeployedOfficeModel deployedOffice,
 			final String newDeployedOfficeName) {
 
 		// TODO test this method (renameDeployedOffice)
 
 		// Obtain the old name
 		final String oldDeployedOfficeName = deployedOffice
 
 		// Return change to rename the office
 		return new AbstractChange<DeployedOfficeModel>(deployedOffice,
 				"Rename office to " + newDeployedOfficeName) {
 			public void apply() {
 				deployedOffice.setDeployedOfficeName(newDeployedOfficeName);
 			}
 
 			public void revert() {
 				deployedOffice.setDeployedOfficeName(oldDeployedOfficeName);
 			}
 		};
 	}
 
 			final DeployedOfficeModel officefinal String officeName,
 			final String officeSourceClassNamefinal String officeLocation,
 			PropertyList propertiesOfficeType officeType,
 			Map<StringStringobjectNameMapping,
 			Map<StringStringinputNameMapping,
 			Map<StringStringteamNameMapping) {
 
 		// Create the list to contain all refactor changes
 		final List<Change<?>> refactor = new LinkedList<Change<?>>();
 
 		// ------------ Details of DeployedOfficeModel -----------------
 
 		// Add change for office details
 		final String existingOfficeName = office.getDeployedOfficeName();
 		final String existingOfficeSourceClassName = office
 		final String existingOfficeLocation = office.getOfficeLocation();
 		refactor.add(new AbstractChange<DeployedOfficeModel>(office,
 				"Change office details") {
 			public void apply() {
 				office.setDeployedOfficeName(officeName);
 				office.setOfficeSourceClassName(officeSourceClassName);
 				office.setOfficeLocation(officeLocation);
 			}
 
 			public void revert() {
 				office.setDeployedOfficeName(existingOfficeName);
 				office.setOfficeSourceClassName(existingOfficeSourceClassName);
 				office.setOfficeLocation(existingOfficeLocation);
 			}
 		});
 
 		// Add change to the properties
 		final List<PropertyModelexistingProperties = new ArrayList<PropertyModel>(
 				office.getProperties());
 		final List<PropertyModelnewProperties = new LinkedList<PropertyModel>();
 		for (Property property : properties) {
 			newProperties.add(new PropertyModel(property.getName(), property
 					.getValue()));
 		}
 		refactor.add(new AbstractChange<DeployedOfficeModel>(office,
 				"Change office properties") {
 			public void apply() {
 				for (PropertyModel property : existingProperties) {
 					office.removeProperty(property);
 				}
 				for (PropertyModel property : newProperties) {
 					office.addProperty(property);
 				}
 			}
 
 			public void revert() {
 				for (PropertyModel property : newProperties) {
 					office.removeProperty(property);
 				}
 				for (PropertyModel property : existingProperties) {
 					office.addProperty(property);
 				}
 			}
 		});
 
 		// ------------------- OfficeSectionObjects ---------------------------
 
 		// Create the map of existing objects to their names
 		for (DeployedOfficeObjectModel object : office
 			existingObjectMapping.put(object.getDeployedOfficeObjectName(),
 					object);
 		}
 
 		// Create the listing of target objects
 		OfficeManagedObjectType[] objectTypes = officeType
 		final DeployedOfficeObjectModel[] targetObjects = new DeployedOfficeObjectModel[objectTypes.length];
 		for (int o = 0; o < targetObjects.lengtho++) {
 			OfficeManagedObjectType objectType = objectTypes[o];
 
 			// Obtain the details of the object
 			final String objectName = objectType.getOfficeManagedObjectName();
 			final String objectTypeName = objectType.getObjectType();
 			// TODO refactor extension interfaces
 
 			// Obtain the object for object type (may need to create)
 					objectNameobjectNameMappingexistingObjectMapping);
 			final DeployedOfficeObjectModel object = (findObject != null ? findObject
 					: new DeployedOfficeObjectModel(objectNameobjectTypeName));
 			targetObjects[o] = object;
 
 			// Refactor details of object
 			final String existingObjectName = object
 			final String existingObjectTypeName = object.getObjectType();
 					"Refactor office object") {
 				public void apply() {
 					object.setDeployedOfficeObjectName(objectName);
 					object.setObjectType(objectTypeName);
 				}
 
 				public void revert() {
 					object.setDeployedOfficeObjectName(existingObjectName);
 					object.setObjectType(existingObjectTypeName);
 				}
 			});
 		}
 
 		// Ensure target objects sorted by name
 		Arrays.sort(targetObjectsnew Comparator<DeployedOfficeObjectModel>() {
 			}
 		});
 
 		// Obtain the existing objects
 		final DeployedOfficeObjectModel[] existingObjects = office
 
 		// Add changes to disconnect existing objects to be removed
 				Arrays.asList(targetObjects));
 		for (DeployedOfficeObjectModel existingObject : existingObjects) {
 			if (!(targetObjectSet.contains(existingObject))) {
 				// Add change to disconnect object
 				final DeployedOfficeObjectModel object = existingObject;
 						existingObject) {
 					protected void populateRemovedConnections(
 							List<ConnectionModelconnList) {
 						if (conn != null) {
 							conn.remove();
 							connList.add(conn);
 						}
 					}
 				});
 			}
 		}
 
 		// Add change to refactor objects
 		refactor.add(new AbstractChange<DeployedOfficeModel>(office,
 				"Refactor objects of office") {
 			public void apply() {
 				// Remove existing objects, add target objects
 				for (DeployedOfficeObjectModel object : existingObjects) {
 				}
 				for (DeployedOfficeObjectModel object : targetObjects) {
 					office.addDeployedOfficeObject(object);
 				}
 			}
 
 			public void revert() {
 				// Remove the target objects, add back existing
 				for (DeployedOfficeObjectModel object : targetObjects) {
 				}
 				for (DeployedOfficeObjectModel object : existingObjects) {
 					office.addDeployedOfficeObject(object);
 				}
 			}
 		});
 
 		// ------------------- OfficeSectionInputs ---------------------------
 
 		// Create the map of existing inputs to their names
 		for (DeployedOfficeInputModel input : office.getDeployedOfficeInputs()) {
 			String sectionInputName = input.getSectionName()
 			existingInputMapping.put(sectionInputNameinput);
 		}
 
 		// Create the listing of target inputs
 		OfficeInputType[] inputTypes = officeType.getOfficeInputTypes();
 		final DeployedOfficeInputModel[] targetInputs = new DeployedOfficeInputModel[inputTypes.length];
 		for (int i = 0; i < targetInputs.lengthi++) {
 			OfficeInputType inputType = inputTypes[i];
 
 			// Obtain the details of the input
 			final String sectionName = inputType.getOfficeSectionName();
 			final String inputName = inputType.getOfficeSectionInputName();
 			final String sectionInputName = sectionName
 					+  + inputName;
 			final String parameterTypeName = inputType.getParameterType();
 
 			// Obtain the input for input type (may need to create)
 					sectionInputNameinputNameMappingexistingInputMapping);
 			final DeployedOfficeInputModel input = (findInput != null ? findInput
 					: new DeployedOfficeInputModel(sectionNameinputName,
 							parameterTypeName));
 			targetInputs[i] = input;
 
 			// Refactor details of input
 			final String existingSectionName = input.getSectionName();
 			final String existingInputName = input.getSectionInputName();
 			final String existingParmeterTypeName = input.getParameterType();
 					"Refactor office input") {
 				public void apply() {
 					input.setSectionName(sectionName);
 					input.setSectionInputName(inputName);
 					input.setParameterType(parameterTypeName);
 				}
 
 				public void revert() {
 					input.setSectionName(existingSectionName);
 					input.setSectionInputName(existingInputName);
 					input.setParameterType(existingParmeterTypeName);
 				}
 			});
 		}
 
 		// Ensure target inputs sorted by name
 		Arrays.sort(targetInputsnew Comparator<DeployedOfficeInputModel>() {
 				return (a.getSectionName() +  + a
 			}
 		});
 
 		// Obtain the existing inputs
 		final DeployedOfficeInputModel[] existingInputs = office
 
 		// Add changes to disconnect existing inputs to be removed
 				Arrays.asList(targetInputs));
 		for (DeployedOfficeInputModel existingInput : existingInputs) {
 			if (!(targetInputSet.contains(existingInput))) {
 				// Add change to disconnect input
 				final DeployedOfficeInputModel input = existingInput;
 						existingInput) {
 					protected void populateRemovedConnections(
 							List<ConnectionModelconnList) {
 							conn.remove();
 							connList.add(conn);
 						}
 					}
 				});
 			}
 		}
 
 		// Add change to refactor inputs
 		refactor.add(new AbstractChange<DeployedOfficeModel>(office,
 				"Refactor inputs of office") {
 			public void apply() {
 				// Remove existing inputs, add target inputs
 				for (DeployedOfficeInputModel input : existingInputs) {
 				}
 				for (DeployedOfficeInputModel input : targetInputs) {
 					office.addDeployedOfficeInput(input);
 				}
 			}
 
 			public void revert() {
 				// Remove the target inputs, add back existing
 				for (DeployedOfficeInputModel input : targetInputs) {
 				}
 				for (DeployedOfficeInputModel input : existingInputs) {
 					office.addDeployedOfficeInput(input);
 				}
 			}
 		});
 
 		// ------------------- OfficeSectionTeams ---------------------------
 
 		// Create the map of existing teams to their names
 		for (DeployedOfficeTeamModel team : office.getDeployedOfficeTeams()) {
 			existingTeamMapping.put(team.getDeployedOfficeTeamName(), team);
 		}
 
 		// Create the listing of target teams
 		OfficeTeamType[] teamTypes = officeType.getOfficeTeamTypes();
 		final DeployedOfficeTeamModel[] targetTeams = new DeployedOfficeTeamModel[teamTypes.length];
 		for (int i = 0; i < targetTeams.lengthi++) {
 			OfficeTeamType teamType = teamTypes[i];
 
 			// Obtain the details of the team
 			final String teamName = teamType.getOfficeTeamName();
 
 			// Obtain the team for team type (may need to create)
 			DeployedOfficeTeamModel findTeam = this.getExistingItem(teamName,
 					teamNameMappingexistingTeamMapping);
 			final DeployedOfficeTeamModel team = (findTeam != null ? findTeam
 					: new DeployedOfficeTeamModel(teamName));
 			targetTeams[i] = team;
 
 			// Refactor details of team
 			final String existingTeamName = team.getDeployedOfficeTeamName();
 					"Refactor office team") {
 				public void apply() {
 					team.setDeployedOfficeTeamName(teamName);
 				}
 
 				public void revert() {
 					team.setDeployedOfficeTeamName(existingTeamName);
 				}
 			});
 		}
 
 		// Ensure target teams sorted by name
 		Arrays.sort(targetTeamsnew Comparator<DeployedOfficeTeamModel>() {
 			}
 		});
 
 		// Obtain the existing teams
 		final DeployedOfficeTeamModel[] existingTeams = office
 
 		// Add changes to disconnect existing teams to be removed
 				Arrays.asList(targetTeams));
 		for (DeployedOfficeTeamModel existingTeam : existingTeams) {
 			if (!(targetTeamSet.contains(existingTeam))) {
 				// Add change to disconnect team
 				final DeployedOfficeTeamModel team = existingTeam;
 						existingTeam) {
 					protected void populateRemovedConnections(
 							List<ConnectionModelconnList) {
 						if (conn != null) {
 							conn.remove();
 							connList.add(conn);
 						}
 					}
 				});
 			}
 		}
 
 		// Add change to refactor teams
 		refactor.add(new AbstractChange<DeployedOfficeModel>(office,
 				"Refactor teams of office") {
 			public void apply() {
 				// Remove existing teams, add target teams
 				for (DeployedOfficeTeamModel team : existingTeams) {
 				}
 				for (DeployedOfficeTeamModel team : targetTeams) {
 					office.addDeployedOfficeTeam(team);
 				}
 			}
 
 			public void revert() {
 				// Remove the target teams, add back existing
 				for (DeployedOfficeTeamModel team : targetTeams) {
 				}
 				for (DeployedOfficeTeamModel team : existingTeams) {
 					office.addDeployedOfficeTeam(team);
 				}
 			}
 		});
 
 		// ----------------- Refactoring -------------------------------
 
 		// Return change to do all the refactoring
 		return new AbstractChange<DeployedOfficeModel>(office,
 				"Refactor deployed office") {
 			public void apply() {
 				for (Change<?> change : refactor) {
 					change.apply();
 				}
 			}
 
 			public void revert() {
 				// Revert changes in reverse order as applied
 				for (int i = (refactor.size() - 1); i >= 0; i--) {
 					Change<?> change = refactor.get(i);
 					change.revert();
 				}
 			}
 		};
 	}

Obtains the existing item for the target name.

Parameters:
targetItemName Target item name.
targetToExistingName Mapping of target item name to existing item name.
existingNameToItem Mapping of existing item name to the existing item.
 
 	private <T> T getExistingItem(String targetItemName,
 			Map<StringStringtargetToExistingName,
 			Map<String, T> existingNameToItem) {
 
 		// Obtain the existing item name
 		String existingItemName = targetToExistingName.get(targetItemName);
 		if (existingItemName != null) {
 			// Have existing name, so return existing item by name
 			return existingNameToItem.get(existingItemName);
 		} else {
 			// No existing name, so no existing item
 			return null;
 		}
 	}
 
 			String managedObjectNameManagedObjectScope managedObjectScope,
 			ManagedObjectType<?> managedObjectType) {
 
 		// TODO test this method (addOfficeFloorManagedObject)
 
 		// Create the managed object
 				managedObjectNamegetManagedObjectScope(managedObjectScope));
 
 		// Add the dependencies for the managed object
 		for (ManagedObjectDependencyType<?> dependency : managedObjectType
 			managedObject
 							dependency.getDependencyName(), dependency
 		}
 
 		// Create connection to the managed object source
 		conn.setOfficeFloorManagedObject(managedObject);
 		conn.setOfficeFloorManagedObjectSource(managedObjectSource);
 
 		// Return change to add the managed object
 		return new AbstractChange<OfficeFloorManagedObjectModel>(managedObject,
 				"Add managed object") {
 			public void apply() {
 						.addOfficeFloorManagedObject(managedObject);
 				conn.connect();
 			}
 
 			public void revert() {
 				conn.remove();
 			}
 		};
 	}
 
 			final OfficeFloorManagedObjectModel managedObject) {
 
 		// TODO test this method (removeOfficeFloorManagedObject)
 
 		// Obtain the connection to managed object source
 
 		// Return change to remove the managed object
 		return new AbstractChange<OfficeFloorManagedObjectModel>(managedObject,
 				"Remove managed object") {
 			public void apply() {
 				if (conn != null) {
 					conn.remove();
 				}
 			}
 
 			public void revert() {
 						.addOfficeFloorManagedObject(managedObject);
 				if (conn != null) {
 					conn.connect();
 				}
 			}
 		};
 	}
 
 			final OfficeFloorManagedObjectModel managedObject,
 			final String newManagedObjectName) {
 
 		// TODO test this method (renameOfficeFloorManagedObject)
 
 		// Obtain the old managed object name
 		final String oldManagedObjectName = managedObject
 
 		// Return change to rename the managed object
 		return new AbstractChange<OfficeFloorManagedObjectModel>(managedObject,
 				"Rename managed object to " + newManagedObjectName) {
 			public void apply() {
 				managedObject
 						.setOfficeFloorManagedObjectName(newManagedObjectName);
 			}
 
 			public void revert() {
 				managedObject
 						.setOfficeFloorManagedObjectName(oldManagedObjectName);
 			}
 		};
 	}
 
 			final OfficeFloorManagedObjectModel managedObject,
 			ManagedObjectScope newManagedObjectScope) {
 
 		// TODO test this method (scopeOfficeFloorManagedObject)
 
 		// Obtain the new scope text
 		final String newScope = getManagedObjectScope(newManagedObjectScope);
 
 		// OBtain the old managed object scope
 		final String oldScope = managedObject.getManagedObjectScope();
 
 		// Return change to re-scope the managed object
 		return new AbstractChange<OfficeFloorManagedObjectModel>(managedObject,
 				"Rescope managed object to " + newScope) {
 			public void apply() {
 				managedObject.setManagedObjectScope(newScope);
 			}
 
 			public void revert() {
 				managedObject.setManagedObjectScope(oldScope);
 			}
 		};
 	}
 
 			String managedObjectSourceName,
 			String managedObjectSourceClassNamePropertyList properties,
 			long timeoutManagedObjectType<?> managedObjectType) {
 
 		// TODO test this method (addOfficeFloorManagedObjectSource)
 
 		// Create the managed object source
 				managedObjectSourceNamemanagedObjectSourceClassName,
 				managedObjectType.getObjectClass().getName(), String
 						.valueOf(timeout));
 		for (Property property : properties) {
 			managedObjectSource.addProperty(new PropertyModel(property
 					.getName(), property.getValue()));
 		}
 
 		// Add the flows for the managed object source
 		for (ManagedObjectFlowType<?> flow : managedObjectType.getFlowTypes()) {
 			managedObjectSource
 							flow.getFlowName(), flow.getArgumentType()
 									.getName()));
 		}
 
 		// Add the teams for the managed object source
 		for (ManagedObjectTeamType team : managedObjectType.getTeamTypes()) {
 			managedObjectSource
 							team.getTeamName()));
 		}
 
 		// Return the change to add the managed object source
 				managedObjectSource"Add managed object source") {
 			public void apply() {
 						.addOfficeFloorManagedObjectSource(managedObjectSource);
 			}
 
 			public void revert() {
 						.removeOfficeFloorManagedObjectSource(managedObjectSource);
 			}
 		};
 	}
 
 			final OfficeFloorManagedObjectSourceModel managedObjectSource) {
 
 		// TODO test this method (removeOfficeFloorManagedObjectSource)
 
 		// Return change to remove the managed object source
 				managedObjectSource"Remove managed object source") {
 			public void apply() {
 						.removeOfficeFloorManagedObjectSource(managedObjectSource);
 			}
 
 			public void revert() {
 						.addOfficeFloorManagedObjectSource(managedObjectSource);
 			}
 		};
 	}
 
 			final OfficeFloorManagedObjectSourceModel managedObjectSource,
 			final String newManagedObjectSourceName) {
 
 		// TODO test this method (renameOfficeFloorManagedObjectSource)
 
 		// Obtain the old managed object source name
 		final String oldManagedObjectSourceName = managedObjectSource
 
 		// Return change to rename the managed object source
 				managedObjectSource"Rename managed object source to "
 						+ newManagedObjectSourceName) {
 			public void apply() {
 				managedObjectSource
 						.setOfficeFloorManagedObjectSourceName(newManagedObjectSourceName);
 			}
 
 			public void revert() {
 				managedObjectSource
 						.setOfficeFloorManagedObjectSourceName(oldManagedObjectSourceName);
 			}
 		};
 	}
 
 			String teamSourceClassNamePropertyList properties,
 			TeamType teamType) {
 
 		// TODO test this method (addOfficeFloorTeam)
 
 		// Create the office floor team
 		final OfficeFloorTeamModel team = new OfficeFloorTeamModel(teamName,
 				teamSourceClassName);
 		for (Property property : properties) {
 			team.addProperty(new PropertyModel(property.getName(), property
 					.getValue()));
 		}
 
 		// Return change to add the office floor team
 		return new AbstractChange<OfficeFloorTeamModel>(team"Add team") {
 			public void apply() {
 			}
 
 			public void revert() {
 			}
 		};
 	}
 
 			final OfficeFloorTeamModel officeFloorTeam) {
 
 		// TODO test this method (removeOfficeFloorTeam)
 
 		// Return change to remove the office floor team
 		return new AbstractChange<OfficeFloorTeamModel>(officeFloorTeam,
 				"Remove team") {
 			public void apply() {
 						.removeOfficeFloorTeam(officeFloorTeam);
 			}
 
 			public void revert() {
 						.addOfficeFloorTeam(officeFloorTeam);
 			}
 		};
 	}
 
 			final OfficeFloorTeamModel officeFloorTeam,
 			final String newOfficeFloorTeamName) {
 
 		// TODO test this method (renameOfficeFloorTeam)
 
 		// Obtain the old office floor team name
 		final String oldOfficeFloorTeamName = officeFloorTeam
 
 		// Return the change to rename the office floor team
 		return new AbstractChange<OfficeFloorTeamModel>(officeFloorTeam,
 				"Rename team to " + newOfficeFloorTeamName) {
 			public void apply() {
 				officeFloorTeam.setOfficeFloorTeamName(newOfficeFloorTeamName);
 			}
 
 			public void revert() {
 				officeFloorTeam.setOfficeFloorTeamName(oldOfficeFloorTeamName);
 			}
 		};
 	}
 
 			DeployedOfficeObjectModel deployedOfficeObject,
 			OfficeFloorManagedObjectModel officeFloorManagedObject) {
 
 		// TODO test (linkDeployedOfficeObjectToOfficeFloorManagedObject)
 
 		// Create the connection
		conn.setDeployedOfficeObject(deployedOfficeObject);
		conn.setOfficeFloorManagedObject(officeFloorManagedObject);
		// Create change to add the connection
				conn"Connect") {
			public void apply() {
				conn.connect();
			public void revert() {
				conn.remove();
		};
			final DeployedOfficeObjectToOfficeFloorManagedObjectModel deployedOfficeObjectToOfficeFloorManagedObject) {
		// TODO test (removeDeployedOfficeObjectToOfficeFloorManagedObject)
		// Return change to remove the connection
				deployedOfficeObjectToOfficeFloorManagedObject"Remove") {
			public void apply() {
				deployedOfficeObjectToOfficeFloorManagedObject.remove();
			public void revert() {
				deployedOfficeObjectToOfficeFloorManagedObject.connect();
		};
			DeployedOfficeObjectModel deployedOfficeObject,
		// TODO test (linkDeployedOfficeObjectToOfficeFloorInputManagedObject)
		// Create the connection
		conn.setDeployedOfficeObject(deployedOfficeObject);
		conn.setOfficeFloorInputManagedObject(inputManagedObject);
		// Return change to add the connection
				conn"Connect") {
			public void apply() {
				conn.connect();
			public void revert() {
				conn.remove();
		};
			final DeployedOfficeObjectToOfficeFloorInputManagedObjectModel deployedOfficeObjectToInputManagedObject) {
		// TODO test (removeDeployedOfficeObjectToOfficeFloorInputManagedObject)
		// Return change to remove the connection
				deployedOfficeObjectToInputManagedObject"Remove") {
			public void apply() {
				deployedOfficeObjectToInputManagedObject.remove();
			public void revert() {
				deployedOfficeObjectToInputManagedObject.connect();
		};
			DeployedOfficeTeamModel deployedOfficeTeam,
			OfficeFloorTeamModel officeFloorTeam) {
		// TODO test (linkDeployedOfficeTeamToOfficeFloorTeam)
		// Create the connection
		conn.setDeployedOfficeTeam(deployedOfficeTeam);
		conn.setOfficeFloorTeam(officeFloorTeam);
		// Return the change to add connection
				conn"Connect") {
			public void apply() {
				conn.connect();
			public void revert() {
				conn.remove();
		};
			final DeployedOfficeTeamToOfficeFloorTeamModel deployedOfficeTeamToOfficeFloorTeam) {
		// TODO test (removeDeployedOfficeTeamToOfficeFloorTeam)
		// Return the change to remove the connection