Sets the {@code PublicRootActor} instances as a {@code Stoppable}. (INTERNAL ONLY)
@param privateRoot the {@code Stoppable} protocol backed by the {@code PrivateRootActor}
503377
synchronized void setPublicRoot(final Stoppable publicRoot) {
    if (publicRoot != null && this.publicRoot != null) {
      throw new IllegalStateException("The public root already exists.");
    }

    this.publicRoot = publicRoot;
  }
230491
public void setAuthorizationRules(java.util.Collection<AuthorizationRule> authorizationRules) {
        if (authorizationRules == null) {
            this.authorizationRules = null;
            return;
        }

        this.authorizationRules = new com.amazonaws.internal.SdkInternalList<AuthorizationRule>(authorizationRules);
    }
539592
public synchronized boolean disableNode(final String jvmRoute) {
        final Node node = nodes.get(jvmRoute);
        if (node != null) {
            for (final Context context : node.getContexts()) {
                context.disable();
            }
            return true;
        }
        return false;
    }
890121
@Override
    public synchronized BeanContext stop() {
        if (terminating.compareAndSet(false, true)) {
            if (LOG.isDebugEnabled()) {
                LOG.debug("Stopping BeanContext");
            }
            publishEvent(new ShutdownEvent(this));

            // need to sort registered singletons so that beans with that require other beans appear first
            List<BeanRegistration> objects = topologicalSort(singletonObjects.values());

            Set<Integer> processed = new HashSet<>();
            for (BeanRegistration beanRegistration : objects) {
                BeanDefinition def = beanRegistration.beanDefinition;
                Object bean = beanRegistration.bean;
                int sysId = System.identityHashCode(bean);
                if (processed.contains(sysId)) {
                    continue;
                }

                if (LOG_LIFECYCLE.isDebugEnabled()) {
                    LOG_LIFECYCLE.debug("Destroying bean [{}] with identifier [{}]", bean, beanRegistration.identifier);
                }

                processed.add(sysId);
                if (def instanceof DisposableBeanDefinition) {
                    try {
                        //noinspection unchecked
                        ((DisposableBeanDefinition) def).dispose(this, bean);
                    } catch (Throwable e) {
                        if (LOG.isErrorEnabled()) {
                            LOG.error("Error disposing of bean registration [" + def.getName() + "]: " + e.getMessage(), e);
                        }
                    }
                }
                if (def instanceof Closeable) {
                    try {
                        ((Closeable) def).close();
                    } catch (Throwable e) {
                        if (LOG.isErrorEnabled()) {
                            LOG.error("Error disposing of bean registration [" + def.getName() + "]: " + e.getMessage(), e);
                        }
                    }
                }
                if (bean instanceof LifeCycle) {
                    ((LifeCycle) bean).stop();
                }
            }

            terminating.set(false);
            running.set(false);
            ClassLoadingReporter.finish();
        }
        return this;
    }
1236578
public void setRootNode(TreeElement rootNode)
    {
        _rootNode = rootNode;
        if (rootNode.getName() == null) {
            rootNode.setName("0");
        }
    }
1082147
public void setStoppingInstances(java.util.Collection<InstanceStateChange> stoppingInstances) {
        if (stoppingInstances == null) {
            this.stoppingInstances = null;
            return;
        }

        this.stoppingInstances = new com.amazonaws.internal.SdkInternalList<InstanceStateChange>(stoppingInstances);
    }
109284
public final void setItsRole(final String pItsRole) {
    this.itsRole = pItsRole;
    if (this.itsId == null) {
      this.itsId = new IdUserRoleTomcat();
    }
    this.itsId.setItsRole(this.itsRole);
  }
694913
public static void setPrivateField(final Object obj, final String name, final Object value) {
        try {
            final Field field = obj.getClass().getDeclaredField(name);
            field.setAccessible(true);
            field.set(obj, value);
        } catch (final Exception ex) {
            throw new RuntimeException("Couldn't set field '" + name + "' in class '" + obj.getClass() + "'", ex);
        }
    }
252888
public void setPublicIps(java.util.Collection<String> publicIps) {
        if (publicIps == null) {
            this.publicIps = null;
            return;
        }

        this.publicIps = new com.amazonaws.internal.SdkInternalList<String>(publicIps);
    }
1009398
public void markUsedElements(CodeReferenceMap publicRootSet) {
    if (publicRootSet == null) {
      markUsedElements();
      return;
    }
    //Add all public methods in publicRootClasses to root set
    for (String clazz : publicRootSet.getReferencedClasses()) {
      ClassReferenceNode classNode = (ClassReferenceNode) elementReferenceMap
          .get(ElementReferenceMapper.stitchClassIdentifier(clazz));
      assert(classNode != null);
      Iterable<ExecutableElement> methods = ElementUtil.getMethods(classNode.classElement);
      for (ExecutableElement method : methods) {
        if (ElementUtil.isPublic(method)) {
          rootSet.add(ElementReferenceMapper.stitchMethodIdentifier(method, env.typeUtil(),
              env.elementUtil()));
        }
      }
    }

    //Add input root methods to static set
    for (Table.Cell<String, String, ImmutableSet<String>> cell : publicRootSet
        .getReferencedMethods().cellSet()) {
      String clazzName  = cell.getRowKey();
      String methodName  = cell.getColumnKey();
      for (String signature : cell.getValue()) {
        rootSet.add(ElementReferenceMapper
            .stitchMethodIdentifier(clazzName, methodName, signature));
      }
    }

    markUsedElements(staticSet);
    markUsedElements(rootSet);
  }
815550
public static MutableBoolean stop(boolean forceJvmToStop) {
		if (stop != null) {
			new Exception("LCCore already stopped", stop).printStackTrace(System.err);
			return new MutableBoolean(true);
		}
		stop = new Exception("LCCore stop requested here");
		MutableBoolean stopped = new MutableBoolean(false);
		new Thread("Stopping LCCore") {
			@Override
			public void run() {
				synchronized (toDoInMainThread) {
					toDoInMainThread.notify();
				}
				if (instance != null) instance.stop();
				if (forceJvmToStop) {
					System.out.println("Stop JVM.");
					System.exit(0);
				}
				synchronized (stopped) {
					stopped.set(true);
					stopped.notifyAll();
				}
			}
		}.start();
		return stopped;
	}
1321774
public void setRootMethodAdapter(JavaRootMethodAdapter rootMethodAdapter) {
        if (rootMethodAdapter == null) {
            throw new NullPointerException();
        }
        if (acceptableTestFramework == null) {
            throw new IllegalStateException("acceptableTestFramework is not set");
        }
        if (acceptableTestFramework.equals(rootMethodAdapter.getName())) {
            this.rootMethodAdapter = rootMethodAdapter;
        }
    }
505891
public HDFSDistributor setFileRoot(String fileRoot) {
        this.hdfsFileRoot = fileRoot;
        this.mapperInputFilePath = new Path(hdfsFileRoot + "/input.dat");
        if (mapperOutputFileName != null) {
            this.mapperOutputFilePath = new Path(hdfsFileRoot + "/" + mapperOutputFileName);
        }
        return this;
    }
1037701
public void setEnclosedAnnot(Annotation v) {
    if (Keep_Type.featOkTst && ((Keep_Type)jcasType).casFeat_enclosedAnnot == null)
      jcasType.jcas.throwFeatMissing("enclosedAnnot", "ch.epfl.bbp.uima.types.Keep");
    jcasType.ll_cas.ll_setRefValue(addr, ((Keep_Type)jcasType).casFeatCode_enclosedAnnot, jcasType.ll_cas.ll_getFSRef(v));}
128570
@javax.annotation.Nonnull
  public com.simiacryptus.util.io.HtmlNotebookOutput setSourceRoot(final String sourceRoot) {
    this.sourceRoot = sourceRoot;
    return this;
  }
1273064
public void setInstancesToTerminate(java.util.Collection<String> instancesToTerminate) {
        if (instancesToTerminate == null) {
            this.instancesToTerminate = null;
            return;
        }

        this.instancesToTerminate = new com.amazonaws.internal.SdkInternalList<String>(instancesToTerminate);
    }
372827
public void setErrorRootCauses(java.util.Collection<ErrorRootCause> errorRootCauses) {
        if (errorRootCauses == null) {
            this.errorRootCauses = null;
            return;
        }

        this.errorRootCauses = new java.util.ArrayList<ErrorRootCause>(errorRootCauses);
    }