----- interface InvertibleModificationOperation -----
546058
@Override
	public void apply(final App app, final Page sourcePage, final Page newPage) throws FrameworkException {
		existingNode.updateFromNode(newNode);
	}
1012495
public Object invokeOperation(ObjectName name, String operName, String... paramStrings) throws Exception {
		String[] paramTypes = lookupParamTypes(name, operName, paramStrings);
		Object[] paramObjs;
		if (paramStrings.length == 0) {
			paramObjs = null;
		} else {
			paramObjs = new Object[paramStrings.length];
			for (int i = 0; i < paramStrings.length; i++) {
				paramObjs[i] = ClientUtils.stringToParam(paramStrings[i], paramTypes[i]);
			}
		}
		return invokeOperation(name, operName, paramTypes, paramObjs);
	}
727868
function SerializeOperation(MapType) {
		this.first = !serializeMap;

		if(this.first) {
			serializeMap = createSerializeMap(MapType);
		}

		this.map = serializeMap;
		this.result = null;
	}
230646
@SuppressWarnings("unchecked")
	public <T extends RepresentationModel<T>> T invokeProcessorsFor(T value, ResolvableType referenceType) {

		Assert.notNull(value, "Value must not be null!");
		Assert.notNull(referenceType, "Reference type must not be null!");

		// For Resources implementations, process elements first
		if (RepresentationModelProcessorHandlerMethodReturnValueHandler.COLLECTION_MODEL_TYPE
				.isAssignableFrom(referenceType)) {

			CollectionModel<?> collectionModel = (CollectionModel<?>) value;
			Class<?> rawClass = referenceType.getRawClass();

			if (rawClass == null) {
				throw new IllegalArgumentException(String.format("%s does not expose a raw type!", referenceType));
			}

			ResolvableType elementTargetType = ResolvableType.forClass(CollectionModel.class, rawClass).getGeneric(0);
			List<Object> result = new ArrayList<>(collectionModel.getContent().size());

			for (Object element : collectionModel) {

				ResolvableType elementType = ResolvableType.forClass(element.getClass());

				if (!getRawType(elementTargetType).equals(elementType.getRawClass())) {
					elementTargetType = elementType;
				}

				result.add(invokeProcessorsFor(element, elementTargetType));
			}

			if (RepresentationModelProcessorHandlerMethodReturnValueHandler.CONTENT_FIELD != null) {

				ReflectionUtils.setField( //
						RepresentationModelProcessorHandlerMethodReturnValueHandler.CONTENT_FIELD, //
						collectionModel, //
						result //
				);
			}
		}

		return (T) invokeProcessorsFor((Object) value, referenceType);
	}
336903
private void verifyOperation(UpdateOperation operation) {
        if (this.operation == null) {
            this.operation = operation;
        } else if (this.operation != operation) {
            throw new JeppettoException("Can't switch operation type to '" + operation + "'.  '"
                                        + this.operation + "' is already in use.");
        }
    }
1193055
function generateOperationParameters(isInstance, verb) {
    var parameters = [];
    if (isInstance) {
        addOperationSingularParameters(verb, parameters);
    } else {
        addOperationCollectionParameters(verb, parameters);
    }
    return parameters;
}
1271562
static void assertInstantiable(Class<?> c) {
    int modifiers = c.getModifiers();
    if (Modifier.isInterface(modifiers)) {
      throw new UnsupportedOperationException("Interface can't be instantiated! Interface name: " + c.getName());
    }
    if (Modifier.isAbstract(modifiers)) {
      throw new UnsupportedOperationException("Abstract class can't be instantiated! Class name: " + c.getName());
    }
  }
521275
@Override
	public void addOperator(String operator, FunctionDescriptor fd)
    {
        m_operatorMap.put(operator, fd);
    }
1185108
public CompletableFuture<byte[]> invoke(PrimitiveOperation operation) {
    CompletableFuture<byte[]> future = new CompletableFuture<>();
    switch (operation.id().type()) {
      case COMMAND:
        context.execute(() -> invokeCommand(operation, future));
        break;
      case QUERY:
        context.execute(() -> invokeQuery(operation, future));
        break;
      default:
        throw new IllegalArgumentException("Unknown operation type " + operation.id().type());
    }
    return future;
  }
1259441
protected <T> T convertIfNecessary(String value, T originalValue) {
        if (originalValue == null) {
            return (T) value;
        }

        return TypeConversionUtils.convertIfNecessary(value, (Class<T>) originalValue.getClass());
    }
426808
Object toSimpleValue(Class<?> genericType, Object element, TypeAdapters typeAdapters) {
        if (element == null) {
            return null;
        }
        log.info("Convert from " + element.getClass().getName() + " to " + genericType.getName());
        if (genericType.isEnum() && (element instanceof String)) {
            @SuppressWarnings({ "unchecked", "rawtypes" })
            Enum<?> enumValue = Enum.valueOf((Class<? extends Enum>) genericType, (String) element);
            return enumValue;
        }
        Converter converter = SIMPLE_VALUE_CONVERTERS.get(genericType.getName());
        if (converter != null) {
            return converter.convert(element);
        }
        if ((element instanceof String) && (typeAdapters != null)) {
            TypeAdapter<?> adapter = typeAdapters.getTypeAdapter(genericType);
            if (adapter != null) {
                return adapter.deserialize((String) element);
            }
        }
        return element;
    }
861520
public String processInterfaceOperationType(TDefinitions descriptionType, String interfaceName, TOperation interfaceOperationType, boolean addAddress)
    {
        String name = interfaceOperationType.getName();
        TParam messageIn = null;
        TParam messageOut = null;
        TParam messageFault = null;
        
        for (Object nextElement : interfaceOperationType.getRest())
        {
            Object inputOrOutputType = null;
            if (nextElement instanceof JAXBElement)
                inputOrOutputType = ((JAXBElement)nextElement).getValue();
            if (inputOrOutputType instanceof TParam)
            {
                String strName = ((JAXBElement)nextElement).getName().getLocalPart();
                if ("Input".equalsIgnoreCase(strName))
                    messageIn = (TParam)inputOrOutputType;
                else if ("Output".equalsIgnoreCase(strName))
                    messageOut = (TParam)inputOrOutputType;
                else
                    messageFault = (TParam)inputOrOutputType;
            }
        }
        
        TBinding binding = this.getBindingFromInterfaceName(descriptionType, interfaceName);
        
        String address = this.getServiceEndpointFromInterfaceNBinding(descriptionType, name, binding);
        boolean bIsSafe = true;
        // Note: Here I should probably go through the types and find the type, but I just do the quick and dirty
        String element = this.getElementNameFromMessageName(descriptionType, messageIn);
        String elementOut = this.getElementNameFromMessageName(descriptionType, messageOut);
        
        this.updateMessageProcessInfo(element, elementOut, null, bIsSafe, addAddress ? address : null);
        
        return address;
    }
238114
public void addInterfaceOperationType(String strVersion, InterfaceType interfaceType, MessageProcessInfo recMessageProcessInfo)
    {
        InterfaceOperationType interfaceOperationType = wsdlFactory.createInterfaceOperationType();
        interfaceType.getOperationOrFaultOrFeature().add(wsdlFactory.createInterfaceTypeOperation(interfaceOperationType));
        String name = this.fixName(recMessageProcessInfo.getField(MessageProcessInfo.DESCRIPTION).toString());
        interfaceOperationType.setName(name);
        String pattern = this.getURIProperty(MESSAGE_PATTERN_URI);
        interfaceOperationType.setPattern(pattern);
        boolean safe = SAFE_DEFAULT;
        String safeValue = ((PropertiesField)recMessageProcessInfo.getField(MessageProcessInfo.PROPERTIES)).getProperty(MessageProcessInfo.SAFE);
        if (safeValue != null)
            safe = Boolean.parseBoolean(safeValue);
        interfaceOperationType.setSafe(safe);
        String style = ((PropertiesField)recMessageProcessInfo.getField(MessageProcessInfo.PROPERTIES)).getProperty(MESSAGE_STYLE_URI);
        if (style == null)
            style = this.getURIProperty(MESSAGE_STYLE_URI);
        interfaceOperationType.setStyle(style);
        MessageInfo recMessageInfo = this.getMessageIn(recMessageProcessInfo);
        if (recMessageInfo != null)
        {
            MessageRefType messageRefType = wsdlFactory.createMessageRefType();
            JAXBElement<MessageRefType> interfaceOperationTypeInput = wsdlFactory.createInterfaceOperationTypeInput(messageRefType);
            interfaceOperationType.getInputOrOutputOrInfault().add(interfaceOperationTypeInput);
            name = this.fixName(recMessageInfo.getField(MessageInfo.DESCRIPTION).toString());
            String code = recMessageInfo.getField(MessageInfo.CODE).toString();
            if (code == null)
                code = name;
            String element = ((PropertiesField)recMessageInfo.getField(MessageInfo.MESSAGE_PROPERTIES)).getProperty(MessageInfo.ELEMENT);
            if (element == null)
                if (code != null)
                    element = code;
            String messageLabel = "In";
            messageRefType.setElement(element);
            messageRefType.setMessageLabel(messageLabel);
            messageRefType = wsdlFactory.createMessageRefType();
        }
        recMessageInfo = this.getMessageOut(recMessageProcessInfo);
        if (recMessageInfo != null)
        {
            MessageRefType messageRefType = wsdlFactory.createMessageRefType();
            JAXBElement<MessageRefType> interfaceOperationTypeOutput = wsdlFactory.createInterfaceOperationTypeOutput(messageRefType);
            interfaceOperationType.getInputOrOutputOrInfault().add(interfaceOperationTypeOutput);
            name = this.fixName(recMessageInfo.getField(MessageInfo.DESCRIPTION).toString());
            String code = recMessageInfo.getField(MessageInfo.CODE).toString();
            if (code == null)
                code = name;
            String element = ((PropertiesField)recMessageInfo.getField(MessageInfo.MESSAGE_PROPERTIES)).getProperty(MessageInfo.ELEMENT);
            if (element == null)
                if (code != null)
                    element = code;
            String messageLabel = "Out";
            messageRefType.setElement(element);
            messageRefType.setMessageLabel(messageLabel);
        }
    }
458306
public Object invokeOperation(Map<String, String[]> parameterMap) throws JMException {
        MBeanParameterInfo[] parameterInfoArray = operationInfo.getSignature();

        Object[] values = new Object[parameterInfoArray.length];
        String[] types = new String[parameterInfoArray.length];

        MBeanValueConverter valueConverter = createMBeanValueConverter(parameterMap);

        for (int parameterNum = 0; parameterNum < parameterInfoArray.length; parameterNum++) {
            MBeanParameterInfo parameterInfo = parameterInfoArray[parameterNum];
            String type = parameterInfo.getType();
            types[parameterNum] = type;
            values[parameterNum] = valueConverter.convertParameterValue(parameterInfo.getName(), type);
        }

        return mBeanServer.invoke(objectName, operationInfo.getName(), values, types);
    }
1310310
public static <T> Operation<T> operation(Class<? extends T> type, Operator operator,
                                             Expression<?>... args) {
        return operation(type, operator, ImmutableList.copyOf(args));
    }
422070
public void setVertexInput(Operator<Record> c) {
		this.iteration.setInitialSolutionSet(c);
		this.iteration.setInitialWorkset(c);
	}
257301
@Override
  @Nonnull
  @OverridingMethodsMustInvokeSuper
  protected IMicroNode internalConvertToMicroNode (@Nonnull final IHCConversionSettingsToNode aConversionSettings)
  {
    // Create the element
    final IMicroElement ret = createMicroElement (aConversionSettings);
    if (ret == null)
      throw new IllegalStateException ("Created a null element!");

    // Set all HTML attributes etc.
    fillMicroElement (ret, aConversionSettings);

    // Optional callback after everything was done (implementation dependent)
    finishMicroElement (ret, aConversionSettings);
    return ret;
  }