internal virtual FxMatrixBuilder merge(FxMatrixBuilder other) { // Find the common currencies Optional <Currency> common = currencies.Keys.Where(other.currencies.containsKey).First(); Currency commonCurrency = common.orElseThrow(() => new System.ArgumentException("There are no currencies in common between " + currencies.Keys + " and " + other.currencies.Keys)); // Add in all currencies that we don't already have MapStream.of(other.currencies).filterKeys(ccy => !ccy.Equals(commonCurrency) && !currencies.containsKey(ccy)).forEach((ccy, idx) => addCurrencyPair(commonCurrency, ccy, other.getRate(commonCurrency, ccy))); return(this); }
//[MethodImpl(MethodImplOptions.Synchronized)] public boolean containsKey(K key) { lock (this) { return(map.containsKey(key)); } }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET: //ORIGINAL LINE: public void add(String subModelName, String featureSpec) throws org.maltparser.core.exception.MaltChainedException public virtual void add(string subModelName, string featureSpec) { if (ReferenceEquals(subModelName, null) || subModelName.Length < 1 || subModelName.ToUpper().Equals("MAIN")) { if (!subModelMap.containsKey("MAIN")) { subModelMap.put("MAIN", new SpecificationSubModel("MAIN")); } subModelMap.get("MAIN").add(featureSpec); } else { if (!subModelMap.containsKey(subModelName.ToUpper())) { subModelMap.put(subModelName.ToUpper(), new SpecificationSubModel(subModelName.ToUpper())); } subModelMap.get(subModelName.ToUpper()).add(featureSpec); } }
public virtual Builder ParameterizedWith(string name, TypeReference.Bound bound) { if (TypeParametersConflict == null) { TypeParametersConflict = new LinkedHashMap <string, TypeReference.Bound>(); } else if (TypeParametersConflict.containsKey(name)) { throw new System.ArgumentException(name + " defined twice"); } TypeParametersConflict.put(name, bound); return(this); }
/// <summary> /// Reloads the internal SPI list from the given <seealso cref="ClassLoader"/>. /// Changes to the service list are visible after the method ends, all /// iterators (e.g., from <seealso cref="#availableServices()"/>,...) stay consistent. /// /// <para><b>NOTE:</b> Only new service providers are added, existing ones are /// never removed or replaced. /// /// </para> /// <para><em>This method is expensive and should only be called for discovery /// of new service providers on the given classpath/classloader!</em> /// </para> /// </summary> public void reload(ClassLoader classloader) { lock (this) { //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final java.util.LinkedHashMap<String,Class> services = new java.util.LinkedHashMap<>(this.services); LinkedHashMap <string, Type> services = new LinkedHashMap <string, Type>(this.services); //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final org.apache.lucene.util.SPIClassIterator<S> loader = org.apache.lucene.util.SPIClassIterator.get(clazz, classloader); SPIClassIterator <S> loader = SPIClassIterator.get(clazz, classloader); while (loader.hasNext()) { //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final Class service = loader.next(); Type service = loader.next(); //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final String clazzName = service.getSimpleName(); string clazzName = service.SimpleName; string name = null; foreach (string suffix in suffixes) { if (clazzName.EndsWith(suffix, StringComparison.Ordinal)) { name = clazzName.Substring(0, clazzName.Length - suffix.Length).ToLower(Locale.ROOT); break; } } if (name == null) { throw new ServiceConfigurationError("The class name " + service.Name + " has wrong suffix, allowed are: " + Arrays.ToString(suffixes)); } // only add the first one for each name, later services will be ignored // this allows to place services before others in classpath to make // them used instead of others // // TODO: Should we disallow duplicate names here? // Allowing it may get confusing on collisions, as different packages // could contain same factory class, which is a naming bug! // When changing this be careful to allow reload()! if (!services.containsKey(name)) { services.put(name, service); } } this.services = Collections.unmodifiableMap(services); } }
public virtual bool hasVertex(VertexInfo vertexInfo) { return(cache.containsKey(getKey(vertexInfo))); }
public virtual bool hasTexture(int addr, int clutAddr, int clutStart, int clutMode) { return(cache.containsKey(getKey(addr, clutAddr, clutStart, clutMode))); }
public boolean containsKey(K key) { return(map.containsKey(key)); }