List of available engine types and versions.

@param brokerEngineTypes
List of available engine types and versions.
490692
public void setBrokerEngineTypes(java.util.Collection<BrokerEngineType> brokerEngineTypes) {
        if (brokerEngineTypes == null) {
            this.brokerEngineTypes = null;
            return;
        }

        this.brokerEngineTypes = new java.util.ArrayList<BrokerEngineType>(brokerEngineTypes);
    }
1064061
public void setOptionGroupOptionVersions(java.util.Collection<OptionVersion> optionGroupOptionVersions) {
        if (optionGroupOptionVersions == null) {
            this.optionGroupOptionVersions = null;
            return;
        }

        this.optionGroupOptionVersions = new com.amazonaws.internal.SdkInternalList<OptionVersion>(optionGroupOptionVersions);
    }
512123
public void dbSchemaCheckVersion() {
    try {
      String dbVersion = getDbVersion();
      if (!ProcessEngine.VERSION.equals(dbVersion)) {
        throw LOG.wrongDbVersionException(ProcessEngine.VERSION, dbVersion);
      }

      List<String> missingComponents = new ArrayList<>();
      if (!isEngineTablePresent()) {
        missingComponents.add("engine");
      }
      if (dbSqlSessionFactory.isDbHistoryUsed() && !isHistoryTablePresent()) {
        missingComponents.add("history");
      }
      if (dbSqlSessionFactory.isDbIdentityUsed() && !isIdentityTablePresent()) {
        missingComponents.add("identity");
      }
      if (dbSqlSessionFactory.isCmmnEnabled() && !isCmmnTablePresent()) {
        missingComponents.add("case.engine");
      }
      if (dbSqlSessionFactory.isDmnEnabled() && !isDmnTablePresent()) {
        missingComponents.add("decision.engine");
      }

      if (!missingComponents.isEmpty()) {
        throw LOG.missingTableException(missingComponents);
      }

    } catch (Exception e) {
      if (isMissingTablesException(e)) {
        throw LOG.missingActivitiTablesException();
      } else {
        if (e instanceof RuntimeException) {
          throw (RuntimeException) e;
        } else {
          throw LOG.unableToFetchDbSchemaVersion(e);
        }
      }
    }
  }
1293420
private void addJavaScriptEngine(List<String> factoryCandidates) {
        // Add default script engine manager
        factoryCandidates.add(OSGiScriptEngineFactory.class.getName());

        // Rhino is available in java < 8, Nashorn is available in java >= 8
        if (ClassLoaderUtil.isClassDefined(RHINO_SCRIPT_ENGINE_FACTORY)) {
            factoryCandidates.add(RHINO_SCRIPT_ENGINE_FACTORY);
        } else if (ClassLoaderUtil.isClassDefined(NASHORN_SCRIPT_ENGINE_FACTORY)) {
            factoryCandidates.add(NASHORN_SCRIPT_ENGINE_FACTORY);
        } else {
            logger.warning("No built-in JavaScript ScriptEngineFactory found.");
        }
    }
78446
public void setExportableLogTypes(java.util.Collection<String> exportableLogTypes) {
        if (exportableLogTypes == null) {
            this.exportableLogTypes = null;
            return;
        }

        this.exportableLogTypes = new java.util.ArrayList<String>(exportableLogTypes);
    }
86576
def engine_versions
      info     = console_command('version engines')
      versions = []
      engines  = info.sub('VERSION INFORMATION\n', '').split(/\n\n/)
      engines.each do |eng|
        engdata = {}
        eng.split(/\n/).each do |kv|
          key, value = kv.split(/:\s*/)
          key = key.sub('Local Engine  ', '').sub('Remote Engine ', '')
          engdata[key] = value
        end
        versions << engdata
      end
      versions
    end
1361017
public void messagingEngineReloaded(final JsMessagingEngine engine) {

        final String methodName = "messagingEngineReloaded";
        if (TraceComponent.isAnyTracingEnabled() && TRACE.isEntryEnabled()) {
            SibTr.entry(this, TRACE, methodName, engine);
        }

        boolean engineStarted = false;
        // Get all the active ME's that are on the same bus as the reloaded ME
        JsMessagingEngine[] engines = SibRaEngineComponent.getActiveMessagingEngines(engine.getBusName());

        for (int i = 0; i < engines.length; i++)
        {
          // Now check if the reloaded ME is part of the active ME's (i.e. a started ME
          if (engines[i].equals(engine))
          {
            //It is active so lets mark the engine as started
            engineStarted = true;
            break;
          }
        }

        // Only do this logic on a started engine. If the engine isn't started then when
        // the start is called we will do the same logic of trying to create a listener,
        // so there is no need to wait here till it starts.
        if (engineStarted)
        {
          try
          {

            /*
             * If there is not already a connection to the messaging engine and
             * a listener is still required given the new configuration, create
             * one now
             */

            if (!_connections.containsKey(engine.getUuid().toString())
                    && isListenerRequired(engine)) {

                createListener(engine);

            }

          }
          catch (final ResourceException exception)
          {

            // No FFDC code needed

            if (TraceComponent.isAnyTracingEnabled() && TRACE.isEventEnabled()) {
                SibTr.exception(this, TRACE, exception);
            }

            SibTr.error(TRACE, "RELOAD_FAILED_CWSIV0773", new Object[] {
                    exception, engine.getName(), engine.getBusName(), this });

          }
        } // end of if(engineStarted)

        if (TraceComponent.isAnyTracingEnabled() && TRACE.isEntryEnabled()) {
            SibTr.exit(this, TRACE, methodName);
        }

    }
450312
@Override
    public LinkedEngine[] getEngines(ReqMethod method) {
        if (method == null) {
            return emptyEngines;
        }
        if (method == ReqMethod.ALL) {
            throw new IllegalArgumentException("method");
        }
        return engines[method.ordinal()];
    }
768890
public static void registerBuiltInAnalysisEngines(IAnalysisCache analysisCache) {
        new edu.umd.cs.findbugs.classfile.engine.EngineRegistrar().registerAnalysisEngines(analysisCache);
        new edu.umd.cs.findbugs.classfile.engine.asm.EngineRegistrar().registerAnalysisEngines(analysisCache);
        new edu.umd.cs.findbugs.classfile.engine.bcel.EngineRegistrar().registerAnalysisEngines(analysisCache);
    }
1279878
private void setIndicesAndTypes() {
        request.setIndices(query.getIndexArr());

        String[] typeArr = query.getTypeArr();
        if (typeArr != null) {
            request.setTypes(typeArr);
        }
    }
1160176
protected static io.grpc.netty.shaded.io.grpc.netty.NegotiationType of(final NegotiationType negotiationType) {
        switch (negotiationType) {
            case PLAINTEXT:
                return io.grpc.netty.shaded.io.grpc.netty.NegotiationType.PLAINTEXT;
            case PLAINTEXT_UPGRADE:
                return io.grpc.netty.shaded.io.grpc.netty.NegotiationType.PLAINTEXT_UPGRADE;
            case TLS:
                return io.grpc.netty.shaded.io.grpc.netty.NegotiationType.TLS;
            default:
                throw new IllegalArgumentException("Unsupported NegotiationType: " + negotiationType);
        }
    }
494039
@Override
  public final ImmutableSet<String> getSupportedAnnotationTypes() {
    ImmutableSet.Builder<String> builder = ImmutableSet.builder();
    for (Class<? extends Annotation> annotationClass : getSupportedAnnotationClasses()) {
      builder.add(annotationClass.getCanonicalName());
    }
    return builder.build();
  }
1149338
private static boolean includeTypeParameterInformation(final Class<?> containerClass,
      final Integer typeArgumentIndex) {
    if (containerClass == null || typeArgumentIndex == null) {
      return false;
    }

    // if (containerClass.getTypeParameters().length < 2) {
    // return false;
    // }
    // return !(Map.class.isAssignableFrom(containerClass) && typeArgumentIndex == 1);
    throw new UnsupportedOperationException("GWT does not support getTypeArgumentIndex().");
  }
662201
def getEngineChangelist(self):
		
		
		# Newer versions of the engine use the key "CompatibleChangelist", older ones use "Changelist"
		version = self._getEngineVersionDetails()
		if 'CompatibleChangelist' in version:
			return int(version['CompatibleChangelist'])
		else:
			return int(version['Changelist'])
771128
@Override
    public void registerAnalysisEngines(IAnalysisCache analysisCache) {
        for (IClassAnalysisEngine<?> engine : classAnalysisEngineList) {
            engine.registerWith(analysisCache);
        }

        for (IMethodAnalysisEngine<?> engine : methodAnalysisEngineList) {
            engine.registerWith(analysisCache);
        }

        for (IDatabaseFactory<?> databaseFactory : databaseFactoryList) {
            databaseFactory.registerWith(analysisCache);
        }

        // if (!Subtypes.DO_NOT_USE) {
        // new
        // ReflectionDatabaseFactory<Subtypes>(Subtypes.class).registerWith(analysisCache);
        // }
    }
1063807
public void addTypeType(String version, TTypes TTypes, MessageProcessInfo recMessageProcessInfo)
    {
        // Create the types (import the OTA specs)
        MessageInfo recMessageInfo = this.getMessageIn(recMessageProcessInfo);
        if (recMessageInfo != null)
        {
            String name = this.fixName(recMessageInfo.getField(MessageInfo.DESCRIPTION).toString());
            if (this.isNewType(name))
            {
                this.addSchema(version, TTypes, recMessageInfo);
            }
        }
        recMessageInfo = this.getMessageOut(recMessageProcessInfo);
        if (recMessageInfo != null)
        {
            String name = this.fixName(recMessageInfo.getField(MessageInfo.DESCRIPTION).toString());
            if (this.isNewType(name))
            {
                this.addSchema(version, TTypes, recMessageInfo);
            }
        }
    }
17276
public java.util.List<? extends com.google.appengine.v1.VersionOrBuilder> 
      getVersionsOrBuilderList() {
    return versions_;
  }