Append the guard evaluators.

@param container the container type.
509624
protected void appendEventGuardEvaluators(JvmGenericType container) {
		final GenerationContext context = getContext(container);
		if (context != null) {
			final Collection<Pair<SarlBehaviorUnit, Collection<Procedure1<? super ITreeAppendable>>>> allEvaluators
					= context.getGuardEvaluationCodes();
			if (allEvaluators == null || allEvaluators.isEmpty()) {
				return;
			}

			final JvmTypeReference voidType = this._typeReferenceBuilder.typeRef(Void.TYPE);
			final JvmTypeReference runnableType = this._typeReferenceBuilder.typeRef(Runnable.class);
			final JvmTypeReference collectionType = this._typeReferenceBuilder.typeRef(Collection.class, runnableType);
			for (final Pair<SarlBehaviorUnit, Collection<Procedure1<? super ITreeAppendable>>> evaluators : allEvaluators) {
				final SarlBehaviorUnit source = evaluators.getKey();
				// Determine the name of the operation for the behavior output
				final String behName = Utils.createNameForHiddenGuardGeneralEvaluatorMethod(source.getName().getSimpleName());

				// Create the main function
				final JvmOperation operation = this.typesFactory.createJvmOperation();

				// Annotation for the event bus

				appendGeneratedAnnotation(operation, context);
				addAnnotationSafe(operation, PerceptGuardEvaluator.class);

				// Guard evaluator unit parameters
				// - Event occurrence
				JvmFormalParameter jvmParam = this.typesFactory.createJvmFormalParameter();
				jvmParam.setName(this.grammarKeywordAccess.getOccurrenceKeyword());
				jvmParam.setParameterType(this.typeBuilder.cloneWithProxies(source.getName()));
				this.associator.associate(source, jvmParam);
				operation.getParameters().add(jvmParam);
				// - List of runnables
				jvmParam = this.typesFactory.createJvmFormalParameter();
				jvmParam.setName(RUNNABLE_COLLECTION);
				jvmParam.setParameterType(this.typeBuilder.cloneWithProxies(collectionType));
				operation.getParameters().add(jvmParam);

				operation.setAbstract(false);
				operation.setNative(false);
				operation.setSynchronized(false);
				operation.setStrictFloatingPoint(false);
				operation.setFinal(false);
				operation.setVisibility(JvmVisibility.PRIVATE);
				operation.setStatic(false);
				operation.setSimpleName(behName);
				operation.setReturnType(this.typeBuilder.cloneWithProxies(voidType));
				container.getMembers().add(operation);

				setBody(operation, it -> {
					it.append("assert "); //$NON-NLS-1$
					it.append(this.grammarKeywordAccess.getOccurrenceKeyword());
					it.append(" != null;"); //$NON-NLS-1$
					it.newLine();
					it.append("assert "); //$NON-NLS-1$
					it.append(RUNNABLE_COLLECTION);
					it.append(" != null;"); //$NON-NLS-1$
					for (final Procedure1<? super ITreeAppendable> code : evaluators.getValue()) {
						it.newLine();
						code.apply(it);
					}
				});

				this.associator.associatePrimary(source, operation);
				this.typeBuilder.copyDocumentationTo(source, operation);
			}
		}
	}
31523
public void addImplicitHydrogens(IAtomContainer container) throws CDKException {
        for (IAtom atom : container.atoms()) {
            if (!(atom instanceof IPseudoAtom)) {
                addImplicitHydrogens(container, atom);
            }
        }
    }
253369
def add_to(self, container):
        '''
        
        '''
        if self.container:
            self.remove_from(self.container)
        container.add(self)
588382
public function process(ContainerBuilder $container): void
    {
        $container->setParameter('service_bus.logger.echo.log_level', $this->logLevel);

        $container->addDefinitions(
            [
                StdOutHandler::class => (new Definition(StdOutHandler::class))->setArguments(['%service_bus.logger.echo.log_level%']),
            ]
        );

        (new LoggerCompilerPass())->process($container);

        $loggerDefinition = $container->getDefinition('service_bus.logger');

        $loggerDefinition->addMethodCall(
            'pushHandler',
            [new Reference(StdOutHandler::class)]
        );
    }
655002
public function process(ContainerBuilder $container)
    {
        if (!$container->hasDefinition($this->collectionServiceId)) {
            return;
        }

        $collection = $this->getCollection($container);

        foreach ($container->findTaggedServiceIds($this->serviceTag) as $id => $attributes) {
            $this->addServiceToCollection($collection, $id);
        }
    }
21883
function (container) {
                if (container[parProp]) {
                    // back references already present, nothing to do
                    return;
                }
                // back references are not present yet
                container[parProp] = [];
                for (var childName in container) {
                    if (container.hasOwnProperty(childName) && __includePropForBackRef(childName)) {
                        var childValue = container[childName];
                        if (__isValidContainer(childValue)) {
                            this.__checkBackRefs(childValue);
                            // Add the container reference and property name to the child 'aria:parent' array
                            childValue[parProp].push({
                                parent : container,
                                property : childName
                            });
                            this.$raiseEvent({
                                name : 'aria-parent-metadata-added',
                                child: childValue,
                                parent: container,
                                property: childName
                            });
                        }
                    }
                }
            }
804625
public void createContainer(String container) {

        ContainerController controller = this.platformContainers.get(container);
        if (controller == null) {

            // TODO make this configurable
            Profile p = new ProfileImpl();
            p.setParameter(Profile.PLATFORM_ID, PLATFORM_ID);
            p.setParameter(Profile.MAIN_HOST, MAIN_HOST);
            p.setParameter(Profile.MAIN_PORT, MAIN_PORT);
            p.setParameter(Profile.LOCAL_HOST, MAIN_HOST);
            int port = Integer.parseInt(MAIN_PORT);
            port = port + 1 + this.platformContainers.size();
            p.setParameter(Profile.LOCAL_PORT, Integer.toString(port));
            p.setParameter(Profile.CONTAINER_NAME, container);
            logger.fine("Creating container " + container + "...");
            ContainerController agentContainer = this.runtime
                    .createAgentContainer(p);
            this.platformContainers.put(container, agentContainer);
            logger.fine("Container " + container + " created successfully.");
        } else {
            logger.fine("Container " + container + " is already created.");
        }

    }
294727
public void setContainers(java.util.Collection<ContainerStateChange> containers) {
        if (containers == null) {
            this.containers = null;
            return;
        }

        this.containers = new com.amazonaws.internal.SdkInternalList<ContainerStateChange>(containers);
    }
620331
void addGuardParameters( Map<String, Expression> parameters, boolean isDefault ) {
        isGuard = true;
        wasDefaultFunction = false;
        guardDefault = isDefault;
        if( parameters != null ) {
            addMixin( null, parameters, null );
        }
    }
63734
public function process(ContainerBuilder $container)
    {
        $manager = $container->findDefinition(self::MANAGER_ID);

        $serviceIds = $container->findTaggedServiceIds(self::WORKER_RUNNER_TAG);
        foreach ($serviceIds as $serviceId => $tags) {
            $this->addManagerCalls($container, $manager, $serviceId, $tags);
        }
    }
297828
public void append(final T event) {

		// make sure we can append the log message

		if (backgroundService == null) {
			return;
		}

		if (!backgroundService.isRunning()) {
			return;
		}

		// skip internal logging
		
		if (!allowComDotStackify) {
			String className = eventAdapter.getClassName(event);
			
			if (className != null) {
				if (className.startsWith(COM_DOT_STACKIFY)) {
					return;
				}
			}
		}
		
		// build the log message and queue it to be sent to Stackify

		Throwable exception = eventAdapter.getThrowable(event);

		StackifyError error = null;

		if ((exception != null) || (eventAdapter.isErrorLevel(event))) {
			StackifyError e = eventAdapter.getStackifyError(event, exception);

			if (errorGovernor.errorShouldBeSent(e)) {
				error = e;
			}
		}

		LogMsg logMsg = eventAdapter.getLogMsg(event, error);

		collector.addLogMsg(logMsg);
	}
653685
public function prepend(ContainerBuilder $container)
    {
        $configs = $container->getExtensionConfig($this->getAlias());
        $config = $this->processConfiguration(new Configuration(), $configs);

        $bundles = $container->getParameter('kernel.bundles');

        // Publish assetic assets if desired
        if ($config['assets']['publish'] && isset($bundles['AsseticBundle'])) {
            $container->prependExtensionConfig('assetic', array('assets' => $this->getAssets($config)));
        }
    }
1267800
public void append(final List<Event> events) {
        if (events != null && events.size() > 0) {
            this.events.addAll(events);
        }
    }
225507
protected void append(Env env) {
        addAllWithFilter(this.envVars, env.envVars, filter.getPatternFilter());
        addAllWithFilter(this.sysVars, env.sysVars, filter.getPatternFilter());
    }
140330
protected void addToAtomContainer(IAtomContainer ac, IChemObject item) {
        if (item instanceof IAtomContainer) {
            ac.add((IAtomContainer) item);
        } else if (item instanceof IAtom) {
            ac.addAtom((IAtom) item);
        } else if (item instanceof IBond) {
            ac.addBond((IBond) item);
        }
    }
609216
public function prepend(ContainerBuilder $container)
    {
        $this->declareReportAsCustomizable($container);
        $this->declareRouting($container);
        $this->prependRoleHierarchy($container);
    }
82267
public function process(ContainerBuilder $container)
    {
        $this->registerStateExtractors($container);
        $this->registerStateElements($container);
        $this->registerResultModifications($container);
    }