@Override
        public <S> S fromState(Class<S> type, Object state) {
            if (!type.isAssignableFrom(PUBLIC_TYPE)) {
                return null;
            }
            // TODO - should preserve the property type (which may be different to the provider type)
            ProviderInternal<S> provider = Cast.uncheckedNonnullCast(state);
            return type.cast(propertyOf(provider.getType(), provider));
        }

    private final multiply = new CppMultiply()
    private final main = new CppMain(greeter, sum)

    final List<IncrementalElement.Transform> incrementalChanges = [
        preserve(greeter),
        rename(sum),
        delete(multiply),
        preserve(main)
    ]
    final String expectedOutput = main.expectedOutput
    final String expectedAlternateOutput = main.expectedOutput

					if m.GetResourceVersion() != "102030" {
						t.Errorf("%v (%v) did not preserve resource version", gv.WithKind(kind), knownType)
						continue
					}
					labels := map[string]string{"a": "b"}
					m.SetLabels(labels)
					if !reflect.DeepEqual(m.GetLabels(), labels) {
						t.Errorf("%v (%v) did not preserve labels", gv.WithKind(kind), knownType)
						continue
					}
				default:

    private final multiply = new SwiftMultiply()
    private final main = new SwiftMain(greeter, sum)

    final List<IncrementalElement.Transform> incrementalChanges = [
        preserve(greeter),
        rename(sum),
        delete(multiply),
        preserve(main)
    ]
    final String expectedOutput = main.expectedOutput
    final String expectedAlternateOutput = main.expectedOutput
    final String moduleName = "App"

  }

  std::vector<string> output_tensor_names;
  output_tensor_names.reserve(fetch_outputs.size());
  for (auto const& output : fetch_outputs) {
    output_tensor_names.push_back(output.name());
  }
  std::vector<string> target_node_names;
  target_node_names.reserve(run_outputs.size());
  for (auto const& output : run_outputs) {
    target_node_names.push_back(output.node()->name());

    private final main = new SwiftMain(greeter, sum)
    private final alternateMain = new SwiftAlternateMain(greeter)

    final List<IncrementalElement.Transform> incrementalChanges = [
        preserve(greeter), preserve(sum), modify(main, alternateMain)]
    final String expectedOutput = main.expectedOutput
    final String expectedAlternateOutput = alternateMain.expectedOutput
    final String moduleName = "App"

		{[]string{"fullObject"}, nil},
		{[]string{"spanning", "embedded"}, nil},
		{[]string{"preserve-fields"}, map[string]interface{}{"metadata": map[string]interface{}{}}},
		{[]string{"preserve-fullMetadata"}, map[string]interface{}{}},
		{[]string{"preserve-fullObject"}, nil},
		{[]string{"preserve-spanning", "embedded"}, nil},
	}

	returnedFoo := &unstructured.Unstructured{}

        final greeter = new SwiftGreeter()
        final sum = new SwiftSum()

        final String moduleName = "Greeter"
        final List<IncrementalElement.Transform> incrementalChanges = [preserve(greeter), preserve(sum)]
    }

    class IncrementalSwiftAppWithDep extends IncrementalSwiftElement implements AppElement {
        final SwiftMain main

        IncrementalSwiftAppWithDep(IncrementalSwiftLib library) {

        if (ranges.isEmpty()) this
        else ProgramText(text.erase(ranges))

    fun preserve(vararg ranges: IntRange): ProgramText =
        erase(complementOf(ranges))

    internal
    fun preserve(ranges: List<IntRange>): ProgramText =
        preserve(*ranges.toTypedArray())

    fun subText(range: IntRange): ProgramText =
        ProgramText(text.substring(range))

    internal

rootProject.name = 'preserve-order'...