/// <summary>
/// {@inheritDoc}
///
/// @implSpec
/// This implementation iterates over <tt>entrySet()</tt> searching
/// for an entry with the specified key. If such an entry is found,
/// the entry's value is returned. If the iteration terminates without
/// finding such an entry, <tt>null</tt> is returned. Note that this
/// implementation requires linear time in the size of the map; many
/// implementations will override this method.
/// </summary>
/// <exception cref="ClassCastException"> {@inheritDoc} </exception>
/// <exception cref="NullPointerException"> {@inheritDoc} </exception>
public virtual V Get(Object key)
{
Iterator <Map_Entry <K, V> > i = EntrySet().Iterator();
if (key == Map_Fields.Null)
{
while (i.HasNext())
{
Map_Entry <K, V> e = i.Next();
if (e.Key == Map_Fields.Null)
{
return(e.Value);
}
}
}
else
{
while (i.HasNext())
{
Map_Entry <K, V> e = i.Next();
if (key.Equals(e.Key))
{
return(e.Value);
}
}
}
return(Map_Fields.Null);
}
/// <summary>
/// Returns a string representation of this map. The string representation
/// consists of a list of key-value mappings in the order returned by the
/// map's <tt>entrySet</tt> view's iterator, enclosed in braces
/// (<tt>"{}"</tt>). Adjacent mappings are separated by the characters
/// <tt>", "</tt> (comma and space). Each key-value mapping is rendered as
/// the key followed by an equals sign (<tt>"="</tt>) followed by the
/// associated value. Keys and values are converted to strings as by
/// <seealso cref="String#valueOf(Object)"/>.
/// </summary>
/// <returns> a string representation of this map </returns>
public override String ToString()
{
Iterator <Map_Entry <K, V> > i = EntrySet().Iterator();
if (!i.HasNext())
{
return("{}");
}
StringBuilder sb = new StringBuilder();
sb.Append('{');
for (;;)
{
Map_Entry <K, V> e = i.Next();
K key = e.Key;
V value = e.Value;
sb.Append(key == this ? "(this Map)" : key);
sb.Append('=');
sb.Append(value == this ? "(this Map)" : value);
if (!i.HasNext())
{
return(sb.Append('}').ToString());
}
sb.Append(',').Append(' ');
}
}
private void CrossCheck(TemporalAccessor target)
{
for (IEnumerator <Map_Entry <TemporalField, Long> > it = FieldValues.GetEnumerator(); it.MoveNext();)
{
Map_Entry <TemporalField, Long> entry = it.Current;
TemporalField field = entry.Key;
if (target.IsSupported(field))
{
long val1;
try
{
val1 = target.GetLong(field);
}
catch (RuntimeException)
{
continue;
}
long val2 = entry.Value;
if (val1 != val2)
{
throw new DateTimeException("Conflict found: Field " + field + " " + val1 + " differs from " + field + " " + val2 + " derived from " + target);
}
it.remove();
}
}
}
/// <summary>
/// {@inheritDoc}
///
/// @implSpec
/// This implementation iterates over <tt>entrySet()</tt> searching
/// for an entry with the specified value. If such an entry is found,
/// <tt>true</tt> is returned. If the iteration terminates without
/// finding such an entry, <tt>false</tt> is returned. Note that this
/// implementation requires linear time in the size of the map.
/// </summary>
/// <exception cref="ClassCastException"> {@inheritDoc} </exception>
/// <exception cref="NullPointerException"> {@inheritDoc} </exception>
public virtual bool ContainsValue(Object value)
{
Iterator <Map_Entry <K, V> > i = EntrySet().Iterator();
if (value == Map_Fields.Null)
{
while (i.HasNext())
{
Map_Entry <K, V> e = i.Next();
if (e.Value == Map_Fields.Null)
{
return(Map_Fields.True);
}
}
}
else
{
while (i.HasNext())
{
Map_Entry <K, V> e = i.Next();
if (value.Equals(e.Value))
{
return(Map_Fields.True);
}
}
}
return(Map_Fields.False);
}
internal static Map_Entry <String, String> CheckedEntry(Object o)
{
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @SuppressWarnings("unchecked") Map_Entry<String,String> e = (Map_Entry<String,String>) o;
Map_Entry <String, String> e = (Map_Entry <String, String>)o;
NonNullString(e.Key);
NonNullString(e.Value);
return(e);
}
// Comparison and hashing
/// <summary>
/// Compares the specified object with this map for equality. Returns
/// <tt>true</tt> if the given object is also a map and the two maps
/// represent the same mappings. More formally, two maps <tt>m1</tt> and
/// <tt>m2</tt> represent the same mappings if
/// <tt>m1.entrySet().equals(m2.entrySet())</tt>. This ensures that the
/// <tt>equals</tt> method works properly across different implementations
/// of the <tt>Map</tt> interface.
///
/// @implSpec
/// This implementation first checks if the specified object is this map;
/// if so it returns <tt>true</tt>. Then, it checks if the specified
/// object is a map whose size is identical to the size of this map; if
/// not, it returns <tt>false</tt>. If so, it iterates over this map's
/// <tt>entrySet</tt> collection, and checks that the specified map
/// contains each mapping that this map contains. If the specified map
/// fails to contain such a mapping, <tt>false</tt> is returned. If the
/// iteration completes, <tt>true</tt> is returned.
/// </summary>
/// <param name="o"> object to be compared for equality with this map </param>
/// <returns> <tt>true</tt> if the specified object is equal to this map </returns>
public override bool Equals(Object o)
{
if (o == this)
{
return(Map_Fields.True);
}
if (!(o is Map))
{
return(Map_Fields.False);
}
//JAVA TO C# CONVERTER TODO TASK: Java wildcard generics are not converted to .NET:
//ORIGINAL LINE: Map<?,?> m = (Map<?,?>) o;
Map <?, ?> m = (Map <?, ?>)o;
if (m.Size() != Size())
{
return(Map_Fields.False);
}
try
{
Iterator <Map_Entry <K, V> > i = EntrySet().Iterator();
while (i.HasNext())
{
Map_Entry <K, V> e = i.Next();
K key = e.Key;
V value = e.Value;
if (value == Map_Fields.Null)
{
if (!(m.Get(key) == Map_Fields.Null && m.ContainsKey(key)))
{
return(Map_Fields.False);
}
}
else
{
if (!value.Equals(m.Get(key)))
{
return(Map_Fields.False);
}
}
}
}
catch (ClassCastException)
{
return(Map_Fields.False);
}
catch (NullPointerException)
{
return(Map_Fields.False);
}
return(Map_Fields.True);
}
private Object FindStore(TemporalField field, Locale locale)
{
Map_Entry <TemporalField, Locale> key = CreateEntry(field, locale);
Object store = CACHE[key];
if (store == null)
{
store = CreateStore(field, locale);
CACHE.PutIfAbsent(key, store);
store = CACHE[key];
}
return(store);
}
/// <summary>
/// Export the specified Map<String,String> to a map document on
/// the specified OutputStream as per the prefs DTD. This is used
/// as the internal (undocumented) format for FileSystemPrefs.
/// </summary>
/// <exception cref="IOException"> if writing to the specified output stream
/// results in an <tt>IOException</tt>. </exception>
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: static void exportMap(OutputStream os, Map<String, String> map) throws IOException
internal static void ExportMap(OutputStream os, Map <String, String> map)
{
Document doc = CreatePrefsDoc("map");
Element xmlMap = doc.DocumentElement;
xmlMap.setAttribute("MAP_XML_VERSION", MAP_XML_VERSION);
for (Iterator <Map_Entry <String, String> > i = map.EntrySet().Iterator(); i.HasNext();)
{
Map_Entry <String, String> e = i.Next();
Element xe = (Element)xmlMap.appendChild(doc.createElement("entry"));
xe.setAttribute("key", e.Key);
xe.setAttribute("value", e.Value);
}
WriteDoc(doc, os);
}
public virtual bool HasMoreElements()
{
if (name != null)
{
return(true);
}
while (Itor.HasNext())
{
Map_Entry <String, CodeSigner[]> e = Itor.Next();
if (SignersReq.Contains(e.Value))
{
name = e.Key;
return(true);
}
}
while (Enum2.MoveNext())
{
name = Enum2.Current;
return(true);
}
return(false);
}
/// <summary>
/// {@inheritDoc}
///
/// @implSpec
/// This implementation iterates over <tt>entrySet()</tt> searching for an
/// entry with the specified key. If such an entry is found, its value is
/// obtained with its <tt>getValue</tt> operation, the entry is removed
/// from the collection (and the backing map) with the iterator's
/// <tt>remove</tt> operation, and the saved value is returned. If the
/// iteration terminates without finding such an entry, <tt>null</tt> is
/// returned. Note that this implementation requires linear time in the
/// size of the map; many implementations will override this method.
///
/// <para>Note that this implementation throws an
/// <tt>UnsupportedOperationException</tt> if the <tt>entrySet</tt>
/// iterator does not support the <tt>remove</tt> method and this map
/// contains a mapping for the specified key.
///
/// </para>
/// </summary>
/// <exception cref="UnsupportedOperationException"> {@inheritDoc} </exception>
/// <exception cref="ClassCastException"> {@inheritDoc} </exception>
/// <exception cref="NullPointerException"> {@inheritDoc} </exception>
public virtual V Remove(Object key)
{
Iterator <Map_Entry <K, V> > i = EntrySet().Iterator();
Map_Entry <K, V> correctEntry = Map_Fields.Null;
if (key == Map_Fields.Null)
{
while (correctEntry == Map_Fields.Null && i.HasNext())
{
Map_Entry <K, V> e = i.Next();
if (e.Key == Map_Fields.Null)
{
correctEntry = e;
}
}
}
else
{
while (correctEntry == Map_Fields.Null && i.HasNext())
{
Map_Entry <K, V> e = i.Next();
if (key.Equals(e.Key))
{
correctEntry = e;
}
}
}
V Map_Fields.OldValue = Map_Fields.Null;
if (correctEntry != Map_Fields.Null)
{
Map_Fields.OldValue = correctEntry.Value;
i.remove();
}
return(Map_Fields.OldValue);
}
[FromJava] public SimpleEntry(Map_Entry entry)
{
}
public CheckedEntry(Map_Entry <String, String> e)
{
this.e = e;
}
public SimpleImmutableEntry(Map_Entry <K, V> prm1)
{
}
public SimpleEntry(Map_Entry <K, V> prm1)
{
}
public int Compare(Map_Entry <String, String> e1, Map_Entry <String, String> e2)
{
return(NameComparator.Compare(e1.Key, e2.Key));
}
public virtual int Compare(Map_Entry <String, Long> obj1, Map_Entry <String, Long> obj2)
{
return(obj2.Key.Length() - obj1.Key.Length()); // longest to shortest
}
protected virtual bool removeEldestEntry(Map_Entry <K, V> prm1)
{
return(default(bool));
}
