//-------------------------------------------------------------------------
/// <summary>
/// Build a new {@code FxMatrix} from the data in the builder.
/// </summary>
/// <returns> a new {@code FxMatrix} </returns>
/// <exception cref="IllegalStateException"> if an attempt was made to add currencies
/// which have no currency in common with other rates </exception>
public virtual FxMatrix build()
{
if (disjointRates.Count > 0)
{
throw new System.InvalidOperationException("Received rates with no currencies in common with other: " + disjointRates);
}
// Trim array down to the correct size - we have to copy the array
// anyway to ensure immutability, so we may as well remove any
// unused rows
return(new FxMatrix(ImmutableMap.copyOf(currencies), DoubleMatrix.ofUnsafe(copyArray(rates, currencies.size()))));
}
public LRUCache(int _size)
{
this._size = _size;
map = new LinkedHashMap <K, V>(_size * 4 / 3 + 1, 0.75f, true, () =>
{
return(map.size() > _size);
});
}
public virtual void addTexture(IRenderingEngine re, Texture texture)
{
int? key = getKey(texture.Addr, texture.ClutAddr, texture.ClutStart, texture.ClutMode);
Texture previousTexture = cache.get(key);
if (previousTexture != null)
{
previousTexture.deleteTexture(re);
//JAVA TO C# CONVERTER TODO TASK: There is no .NET LinkedList equivalent to the Java 'remove' method:
vramTextures.remove(previousTexture);
}
else
{
// Check if the cache is not growing too large
if (cache.size() >= cacheMaxSize)
{
// Remove the LRU cache entry
IEnumerator <KeyValuePair <int, Texture> > it = cache.entrySet().GetEnumerator();
//JAVA TO C# CONVERTER TODO TASK: Java iterators are only converted within the context of 'while' and 'for' loops:
if (it.hasNext())
{
//JAVA TO C# CONVERTER TODO TASK: Java iterators are only converted within the context of 'while' and 'for' loops:
KeyValuePair <int, Texture> entry = it.next();
Texture lruTexture = entry.Value;
lruTexture.deleteTexture(re);
//JAVA TO C# CONVERTER TODO TASK: There is no .NET LinkedList equivalent to the Java 'remove' method:
vramTextures.remove(lruTexture);
//JAVA TO C# CONVERTER TODO TASK: .NET enumerators are read-only:
it.remove();
statistics.entriesRemoved++;
}
}
}
cache.put(key, texture);
if (isVramTexture(texture))
{
vramTextures.AddLast(texture);
}
if (cache.size() > statistics.maxSizeUsed)
{
statistics.maxSizeUsed = cache.size();
}
}
public virtual void addVertex(IRenderingEngine re, VertexInfo vertexInfo, int numberOfVertex, float[][] boneMatrix, int numberOfWeightsForShader)
{
lock (this)
{
int? key = getKey(vertexInfo);
VertexInfo previousVertex = cache.get(key);
if (previousVertex != null)
{
vertexInfo.reuseCachedBuffer(previousVertex);
previousVertex.deleteVertex(re);
}
else
{
// Check if the cache is not growing too large
if (cache.size() >= cacheMaxSize)
{
// Remove the LRU cache entry
IEnumerator <KeyValuePair <int, VertexInfo> > it = cache.entrySet().GetEnumerator();
//JAVA TO C# CONVERTER TODO TASK: Java iterators are only converted within the context of 'while' and 'for' loops:
if (it.hasNext())
{
//JAVA TO C# CONVERTER TODO TASK: Java iterators are only converted within the context of 'while' and 'for' loops:
KeyValuePair <int, VertexInfo> entry = it.next();
entry.Value.deleteVertex(re);
//JAVA TO C# CONVERTER TODO TASK: .NET enumerators are read-only:
it.remove();
statistics.entriesRemoved++;
}
}
}
vertexInfo.prepareForCache(this, numberOfVertex, boneMatrix, numberOfWeightsForShader);
cache.put(key, vertexInfo);
if (cache.size() > statistics.maxSizeUsed)
{
statistics.maxSizeUsed = cache.size();
}
}
}
private static ICollection <Path> HitsToPaths(ICollection <Hit> depthHits, Node start, Node end, bool stopAsap, int maxResultCount)
{
LinkedHashMap <string, Path> paths = new LinkedHashMap <string, Path>();
foreach (Hit hit in depthHits)
{
foreach (Path path in HitToPaths(hit, start, end, stopAsap))
{
paths.put(path.ToString(), path);
if (paths.size() >= maxResultCount)
{
break;
}
}
}
return(paths.values());
}
internal virtual TypeParameter[] TypeParameters()
{
if (TypeParametersConflict == null)
{
return(TypeParameter.NoParameters);
}
else
{
TypeParameter[] result = new TypeParameter[TypeParametersConflict.size()];
int i = 0;
foreach (KeyValuePair <string, TypeReference.Bound> entry in TypeParametersConflict.entrySet())
{
result[i++] = new TypeParameter(entry.Key, entry.Value);
}
return(result);
}
}
/*
* Returns the number of {@code ZipEntries} in this {@code ZipFile}.
*
* @return the number of entries in this file.
* @throws IllegalStateException if this ZIP file has been closed.
*/
public int size()
{
checkNotClosed();
return(mEntries.size());
}
public virtual int size()
{
return(subModelMap.size());
}
internal FxMatrixBuilder(ImmutableMap <Currency, int> currencies, double[][] rates)
{
this.currencies = new LinkedHashMap <Currency, int>(currencies);
// Ensure there is space to add at least one new currency
this.rates = copyArray(rates, size(currencies.size() + 1));
}
