{@link Specification} for retrieving {@link SoftwareModule}s by "like
name or like version".

@param type
to be filtered on
@return the {@link SoftwareModule} {@link Specification}
428495
public static Specification<JpaSoftwareModule> equalType(final Long type) {
        return (targetRoot, query, cb) -> cb.equal(
                targetRoot.<JpaSoftwareModuleType> get(JpaSoftwareModule_.type).get(JpaSoftwareModuleType_.id), type);
    }
576525
public JvmParameterizedTypeReference newTypeRef(Notifier context, String typeName) {
		JvmTypeReference typeReference;
		try {
			typeReference = findType(context, typeName);
			getImportManager().addImportFor(typeReference.getType());
			return (JvmParameterizedTypeReference) typeReference;
		} catch (TypeNotPresentException exception) {
		}
		final JvmParameterizedTypeReference pref = ExpressionBuilderImpl.parseType(context, typeName, this);
		final JvmTypeReference baseType = findType(context, pref.getType().getIdentifier());
		final int len = pref.getArguments().size();
		final JvmTypeReference[] args = new JvmTypeReference[len];
		for (int i = 0; i < len; ++i) {
			final JvmTypeReference original = pref.getArguments().get(i);
			if (original instanceof JvmAnyTypeReference) {
				args[i] = EcoreUtil.copy(original);
			} else if (original instanceof JvmWildcardTypeReference) {
				final JvmWildcardTypeReference wc = EcoreUtil.copy((JvmWildcardTypeReference) original);
				for (final JvmTypeConstraint c : wc.getConstraints()) {
					c.setTypeReference(newTypeRef(context, c.getTypeReference().getIdentifier()));
				}
				args[i] = wc;
			} else {
				args[i] = newTypeRef(context, original.getIdentifier());
			}
		}
		final TypeReferences typeRefs = getTypeReferences();
		return typeRefs.createTypeRef(baseType.getType(), args);
	}
655810
def _get_bundles_by_type(self, type):
        
        bundles = {}
        bundle_definitions = self.config.get(type)
        if bundle_definitions is None:
            return bundles
        # bundle name: common
        for bundle_name, paths in bundle_definitions.items():
            bundle_files = []
            # path: static/js/vendor/*.js
            for path in paths:
                # pattern: /tmp/static/js/vendor/*.js
                pattern = abspath = os.path.join(self.basedir, path)
                # assetdir: /tmp/static/js/vendor
                # assetdir contents:
                #  - /tmp/static/js/vendor/t1.js
                #  - /tmp/static/js/vendor/t2.js
                #  - /tmp/static/js/vendor/index.html
                assetdir = os.path.dirname(abspath)
                # expanded_fnames after filtering using the pattern:
                #  - /tmp/static/js/vendor/t1.js
                #  - /tmp/static/js/vendor/t2.js
                fnames = [os.path.join(assetdir, fname)
                          for fname in os.listdir(assetdir)]
                expanded_fnames = fnmatch.filter(fnames, pattern)
                bundle_files.extend(sorted(expanded_fnames))
            bundles[bundle_name] = bundle_files

        return bundles
182985
@Nullable
    public ModuleSpec getModuleSpec(ModuleIdentifier revisionId) {
        Objects.requireNonNull(revisionId, "revisionId");
        return moduleSpecs.get(revisionId);
    }
234945
def _get_dependency_specification(dep_spec: typing.List[tuple]) -> str:
    """"""
    return ",".join(dep_range[0] + dep_range[1] for dep_range in dep_spec)
705720
@Override
  @Nullable
  CompilerInput.ModuleType getModuleTypeByName(String moduleName) {
    return moduleTypesByName.get(moduleName);
  }
830188
private Content getTreeForClassHelper(Type type) {
        Content li = new HtmlTree(HtmlTag.LI);
        if (type.equals(classDoc)) {
            Content typeParameters = getTypeParameterLinks(
                    new LinkInfoImpl(configuration, LinkInfoImpl.Kind.TREE,
                    classDoc));
            if (configuration.shouldExcludeQualifier(
                    classDoc.containingPackage().name())) {
                li.addContent(type.asClassDoc().name());
                li.addContent(typeParameters);
            } else {
                li.addContent(type.asClassDoc().qualifiedName());
                li.addContent(typeParameters);
            }
        } else {
            Content link = getLink(new LinkInfoImpl(configuration,
                    LinkInfoImpl.Kind.CLASS_TREE_PARENT, type)
                    .label(configuration.getClassName(type.asClassDoc())));
            li.addContent(link);
        }
        return li;
    }
608629
public String convert(String type) {
		if (isImplicitSarlTypes() && type.startsWith(IMPLICIT_PACKAGE)) {
			return type;
		}
		if (this.mapping == null) {
			this.mapping = initMapping();
		}
		final String map = this.mapping.get(type);
		if (map != null) {
			if (map.isEmpty() && !isImplicitJvmTypes()) {
				return null;
			}
			return map;
		}
		if (isImplicitJvmTypes()) {
			return type;
		}
		return null;
	}
156819
private static RubyModule getExtensionsModule(Ruby rubyRuntime) {
        RubyModule asciidoctorModule = rubyRuntime.getModule("Asciidoctor");
        return asciidoctorModule.defineOrGetModuleUnder("Extensions");
    }
1358259
private static Method searchForMatch(Class<?> type, Method bridgeMethod) {
		return ReflectionUtils.findMethod(type, bridgeMethod.getName(), bridgeMethod.getParameterTypes());
	}
164992
@Bean
    @ConditionalOnMissingBean
    SoftwareModuleManagement softwareModuleManagement(final EntityManager entityManager,
            final DistributionSetRepository distributionSetRepository,
            final SoftwareModuleRepository softwareModuleRepository,
            final SoftwareModuleMetadataRepository softwareModuleMetadataRepository,
            final SoftwareModuleTypeRepository softwareModuleTypeRepository,
            final NoCountPagingRepository criteriaNoCountDao, final AuditorAware<String> auditorProvider,
            final ArtifactManagement artifactManagement, final QuotaManagement quotaManagement,
            final VirtualPropertyReplacer virtualPropertyReplacer, final JpaProperties properties) {
        return new JpaSoftwareModuleManagement(entityManager, distributionSetRepository, softwareModuleRepository,
                softwareModuleMetadataRepository, softwareModuleTypeRepository, criteriaNoCountDao, auditorProvider,
                artifactManagement, quotaManagement, virtualPropertyReplacer, properties.getDatabase());
    }
787701
public static Specification<JpaDistributionSet> byType(final DistributionSetType type) {
        return (targetRoot, query, cb) -> cb.equal(targetRoot.<JpaDistributionSetType> get(JpaDistributionSet_.type),
                type);

    }
645503
public static String describePlatform() {
      String desc = "Java " + SPECIFICATION_VERSION + " ("
              + "VM vendor name=\"" + VENDOR + "\", "
              + "VM vendor version=" + VENDOR_VERSION + ", "
              + "JVM name=\"" + JVM_NAME + "\", "
              + "JVM version=" + VM_VERSION + ", "
              + "JVM info=" + VM_INFO;

      // Add the API level if it's an Android platform
      if(ANDROID_VERSION != 0) {
         desc += ", API level=" + ANDROID_VERSION;
      }
      desc += ")";

      return desc;
   }
804305
protected MatchType getMatchType(TypeName m) {
    return match(m)
        .when(typeOf(ParameterizedTypeName.class)).get(
            t -> {
              if (isDecomposableBuilder(t.rawType)) {
                return MatchType.DECOMPOSE;
              } else if (t.rawType.equals(MATCH_ANY)) {
                return MatchType.ANY;
              } else if (t.rawType.equals(MATCH_EXACT)) {
                return MatchType.EXACT;
              } else {
                return MatchType.EXACT;
              }
            })
        .when(typeOf(TypeVariableName.class)).get(t -> MatchType.EXACT)
        .orElse(MatchType.ANY)
        .getMatch();
  }
499454
function evaluateModule(id, input, type) {
		if (/javascript/.test(type)) {
			var fn = new Function("module", "exports", input);
			var moduleExports = {};
			var moduleObject = { exports: moduleExports };
			fn(moduleObject, moduleExports);
			return moduleObject.exports;
		}
		/* @if jsonLoader  */
		if (/json/.test(type)) {
			return JSON.parse(input);
		}
		/* @end */

		return input;
	}
1044626
def scheme_specification(cls):
		
		return WSchemeSpecification(
			'file',
			WURIComponentVerifier(WURI.Component.path, WURIComponentVerifier.Requirement.optional)
		)
737355
@GetMapping("/modules")
  @ResponseBody
  public ModulesConfigResponse getModules(@RequestParam("entity") String entityTypeId) {
    EntityType entityType = dataService.getEntityType(entityTypeId);
    List<Module> modules = dataExplorerService.getModules(entityType);

    ModulesConfigResponse modulesConfigResponse = new ModulesConfigResponse();
    modules.forEach(
        module -> {
          String id;
          String label;
          String icon;

          switch (module) {
            case DATA:
              id = MOD_DATA;
              label = "Data";
              icon = "grid-icon.png";
              break;
            case AGGREGATION:
              id = "aggregates";
              label =
                  messageSource.getMessage(
                      "dataexplorer_aggregates_title", new Object[] {}, getLocale());
              icon = "aggregate-icon.png";
              break;
            case REPORT:
              id = MOD_ENTITIESREPORT;
              label = dataExplorerSettings.getEntityReport(entityTypeId);
              icon = "report-icon.png";
              break;
            default:
              throw new UnexpectedEnumException(module);
          }

          modulesConfigResponse.add(new ModuleConfig(id, label, icon));
        }