----- interface InvertibleModificationOperation -----
551652
@Override
	public void apply(final App app, final Page sourcePage, final Page newPage) throws FrameworkException {

		// do not delete synced nodes (nodes that are shared between multiple pages)
		if (!existingNode.isSynced()) {

			// remove node from parent, do not simply delete it
			final Node parent = existingNode.getParentNode();
			if (parent != null) {

				parent.removeChild(existingNode);
			}

			app.delete(existingNode);
		}
	}
215518
private ImmutableNode toNode(final Builder builder, final Object obj) {
        assert !(obj instanceof List);

        if (obj instanceof Map) {
            return mapToNode(builder, (Map<String, Object>) obj);
        } else {
            return valueToNode(builder, obj);
        }
    }
727868
function SerializeOperation(MapType) {
		this.first = !serializeMap;

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

		this.map = serializeMap;
		this.result = null;
	}
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.");
        }
    }
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());
    }
  }
512189
private <T> T orIfIgnoringFieldAbsence(
      @NullableDecl T input, @NullableDecl T defaultValue, boolean ignoreFieldAbsence) {
    return (input == null && ignoreFieldAbsence) ? defaultValue : input;
  }
842398
public void invokeOperator(PdfLiteral operator, ArrayList operands) {
		ContentOperator op = operators.get(operator.toString());
		if (op == null) {
			// skipping unssupported operator
			return;
		}
		op.invoke(this, operator, operands);
	}
293775
@SuppressWarnings("unchecked")
   public static <T> T convert(Object object, @NonNull Class<T> desiredType) {
      if (object == null) {
         if (desiredType != null && desiredType.isPrimitive()) {
            return Defaults.defaultValue(desiredType);
         }
         return null;
      }


      if (object instanceof Val) {
         return convert(Cast.as(object, Val.class).get(), desiredType);
      }

      //Handle Enums
      if (Enum.class.isAssignableFrom(desiredType)) {
         Class<? extends Enum> enumClass = Cast.as(desiredType);
         return Cast.as(new EnumConverter(enumClass).apply(object));
      }

      //Handle Object arrays
      if (desiredType.isArray() && !desiredType.getComponentType().isPrimitive()) {
         Class<?> componentType = desiredType.getComponentType();
         return Cast.as(new ArrayConverter<>(componentType).apply(object));
      }

      if (converters.containsKey(desiredType)) {
         Object output = converters.get(desiredType).apply(object);
         if (output == null && desiredType.isPrimitive()) {
            return Defaults.defaultValue(desiredType);
         }
         return Cast.as(output);
      }

      if (Map.class.isAssignableFrom(desiredType)) {
         return Cast.as(convert(object, desiredType, Object.class, Object.class));
      }


      T result = new NewObjectConverter<>(desiredType).apply(object);
      if (result != null) {
         return result;
      }

      if (desiredType.isAssignableFrom(object.getClass())) {
         return Cast.as(object);
      }

      log.fine("Unable to convert object of type {0} to desired type of {1}", object.getClass(), desiredType);
      return null;
   }
521275
@Override
	public void addOperator(String operator, FunctionDescriptor fd)
    {
        m_operatorMap.put(operator, fd);
    }
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);
	}
152375
@SuppressWarnings("unchecked")
  public <T extends CoreExecution> void performOperation(CoreAtomicOperation<T> operation) {
    LOG.debugPerformingAtomicOperation(operation, this);
    operation.execute((T) this);
  }
621599
private <IN1, IN2, OUT> Collection<Integer> transformTwoInputTransform(TwoInputTransformation<IN1, IN2, OUT> transform) {

		Collection<Integer> inputIds1 = transform(transform.getInput1());
		Collection<Integer> inputIds2 = transform(transform.getInput2());

		// the recursive call might have already transformed this
		if (alreadyTransformed.containsKey(transform)) {
			return alreadyTransformed.get(transform);
		}

		List<Integer> allInputIds = new ArrayList<>();
		allInputIds.addAll(inputIds1);
		allInputIds.addAll(inputIds2);

		String slotSharingGroup = determineSlotSharingGroup(transform.getSlotSharingGroup(), allInputIds);

		streamGraph.addCoOperator(
				transform.getId(),
				slotSharingGroup,
				transform.getCoLocationGroupKey(),
				transform.getOperator(),
				transform.getInputType1(),
				transform.getInputType2(),
				transform.getOutputType(),
				transform.getName());

		if (transform.getStateKeySelector1() != null || transform.getStateKeySelector2() != null) {
			TypeSerializer<?> keySerializer = transform.getStateKeyType().createSerializer(env.getConfig());
			streamGraph.setTwoInputStateKey(transform.getId(), transform.getStateKeySelector1(), transform.getStateKeySelector2(), keySerializer);
		}

		streamGraph.setParallelism(transform.getId(), transform.getParallelism());
		streamGraph.setMaxParallelism(transform.getId(), transform.getMaxParallelism());

		for (Integer inputId: inputIds1) {
			streamGraph.addEdge(inputId,
					transform.getId(),
					1
			);
		}

		for (Integer inputId: inputIds2) {
			streamGraph.addEdge(inputId,
					transform.getId(),
					2
			);
		}

		return Collections.singleton(transform.getId());
	}
791433
public static Iterator<ImmutableRoaringBitmap> convertToImmutable(
      final Iterator<MutableRoaringBitmap> i) {
    return new Iterator<ImmutableRoaringBitmap>() {

      @Override
      public boolean hasNext() {
        return i.hasNext();
      }

      @Override
      public ImmutableRoaringBitmap next() {
        return i.next();
      }

      @Override
      public void remove() {};

    };

  }
261956
public void eInit(EObject context, Procedure1<? super XExpression> setter, IJvmTypeProvider typeContext) {
		setTypeResolutionContext(typeContext);
		this.context = context;
		this.setter = setter;
		this.expr = null;
	}
247396
public static <T, IV, P> IV injectIntoWith(
            IV injectValue,
            Iterable<T> iterable,
            Function3<? super IV, ? super T, ? super P, ? extends IV> function,
            P parameter)
    {
        if (iterable instanceof MutableCollection)
        {
            return ((MutableCollection<T>) iterable).injectIntoWith(injectValue, function, parameter);
        }
        if (iterable instanceof ArrayList)
        {
            return ArrayListIterate.injectIntoWith(injectValue, (ArrayList<T>) iterable, function, parameter);
        }
        if (iterable instanceof RandomAccess)
        {
            return RandomAccessListIterate.injectIntoWith(injectValue, (List<T>) iterable, function, parameter);
        }
        if (iterable != null)
        {
            return IterableIterate.injectIntoWith(injectValue, iterable, function, parameter);
        }
        throw new IllegalArgumentException("Cannot perform an injectIntoWith on null");
    }
108375
public static void decodeSingle(final byte[] input, final int inoff,
                                    final byte[] output, final int outoff) {

        if (output == null) {
            throw new NullPointerException("output");
        }

        if (outoff < 0) {
            throw new IllegalArgumentException("outoff(" + outoff + ") < 0");
        }

        if (outoff >= output.length) {
            throw new IllegalArgumentException(
                "outoff(" + outoff + ") >= output.length(" + output.length
                + ")");
        }

        output[outoff] = (byte) decodeSingle(input, inoff);
    }
409078
function convertActionBinding(localResolver, implicitReceiver, action, bindingId) {
    if (!localResolver) {
        localResolver = new DefaultLocalResolver();
    }
    var /** @type {?} */ actionWithoutBuiltins = convertPropertyBindingBuiltins({
        createLiteralArrayConverter: function (argCount) {
            // Note: no caching for literal arrays in actions.
            return function (args) { return literalArr(args); };
        },
        createLiteralMapConverter: function (keys) {
            // Note: no caching for literal maps in actions.
            return function (args) { return literalMap(/** @type {?} */ (keys.map(function (key, i) { return [key, args[i]]; }))); };
        },
        createPipeConverter: function (name) {
            throw new Error("Illegal State: Actions are not allowed to contain pipes. Pipe: " + name);
        }
    }, action);
    var /** @type {?} */ visitor = new _AstToIrVisitor(localResolver, implicitReceiver, bindingId);
    var /** @type {?} */ actionStmts = [];
    flattenStatements(actionWithoutBuiltins.visit(visitor, _Mode.Statement), actionStmts);
    prependTemporaryDecls(visitor.temporaryCount, bindingId, actionStmts);
    var /** @type {?} */ lastIndex = actionStmts.length - 1;
    var /** @type {?} */ preventDefaultVar = null;
    if (lastIndex >= 0) {
        var /** @type {?} */ lastStatement = actionStmts[lastIndex];
        var /** @type {?} */ returnExpr = convertStmtIntoExpression(lastStatement);
        if (returnExpr) {
            // Note: We need to cast the result of the method call to dynamic,
            // as it might be a void method!
            preventDefaultVar = createPreventDefaultVar(bindingId);
            actionStmts[lastIndex] =
                preventDefaultVar.set(returnExpr.cast(DYNAMIC_TYPE).notIdentical(literal(false)))
                    .toDeclStmt(null, [StmtModifier.Final]);
        }
    }
    return new ConvertActionBindingResult(actionStmts, preventDefaultVar);
}