public virtual void testAddAll()
{
JDFAttributeMap m1 = new JDFAttributeMap("a1", "v1");
m1.put("a2", "v2");
JDFAttributeMap m2 = new JDFAttributeMap(m1);
m2.put("a2", "v3");
JDFAttributeMap m3 = new JDFAttributeMap(m1);
m3.put("a2", "v3");
VJDFAttributeMap v = new VJDFAttributeMap();
v.Add(m1);
v.Add(m2);
VJDFAttributeMap v2 = new VJDFAttributeMap();
v2.Add(m2);
v2.Add(m3);
v.addAll(v2);
Assert.AreEqual(4, v.Count);
Assert.IsTrue(v.Contains(m1));
Assert.IsTrue(v.Contains(m2));
Assert.IsTrue(v.Contains(m3));
}
///
/// <summary> * entrySet - Returns a Set view of the entries contained in this Hashtable. Each element in this collection is a
/// * Map.Entry. The Set is backed by the Hashtable, so changes to the Hashtable are reflected in the Set, and
/// * vice-versa. The Set supports element removal (which removes the corresponding entry from the Hashtable), but not
/// * element addition.
/// * </summary>
/// * <returns> Set - the set view of the entries contained in this hashtable </returns>
///
// TODO: Just Delete this?
// public virtual Set entrySet()
// {
////JAVA TO VB & C# CONVERTER TODO TASK: There is no .NET Dictionary equivalent to the Java 'entrySet' method:
// return m_hashTable.entrySet();
// }
///
/// <summary> * subMap - returns true if map contains subMap, all keys of submap must be in this hashtable and they must have the
/// * same value<br>
/// *
/// * if subMap is null, the function returns true if subMap contains any wildcards, then the existance of the key in
/// * this defines a match
/// * </summary>
/// * <param name="subMap"> the map to compare
/// * </param>
/// * <returns> boolean - true if this map contains subMap </returns>
///
public virtual bool subMap(JDFAttributeMap subMap)
{
if (subMap == null) // the null map is a subset of everything
{
return(true);
}
ICollection <string> mapSet = this.Keys;
ICollection <string> subMapSet = subMap.Keys;
if (!this.containsAll(subMapSet))
{
return(false);
}
IEnumerator <string> it = subMapSet.GetEnumerator();
while (it.MoveNext())
{
string key = it.Current;
string subVal = subMap[key];
if (!KElement.isWildCard(subVal))
{
string val = this[key];
if (!val.Equals(subVal))
{
return(false);
}
}
}
return(true);
}
///
/// <summary> * equals - Compares two maps, returns true if content equal, otherwise false.<br> If input is not of type
/// * JDFAttributeMap, the result of the superclasses' equals method is returned.
/// * </summary>
/// * <param name="obj"> JDFAttributeMap to compare with <code>this</code>
/// * </param>
/// * <returns> boolean - true if the maps are equal, otherwise false </returns>
///
public override bool Equals(object other)
{
if (this == other)
{
return(true);
}
if (other == null || !(other is JDFAttributeMap))
{
return(false);
}
JDFAttributeMap otherMap = (JDFAttributeMap)other;
if (this.Count != otherMap.Count)
{
return(false);
}
foreach (string key in this.Keys)
{
if (!otherMap.ContainsKey(key))
{
return(false);
}
if (this[key] != otherMap[key])
{
return(false);
}
}
return(true);
}
public virtual void testOverlapMap()
{
JDFAttributeMap m1 = new JDFAttributeMap("a1", "v1");
m1.put("a2", "v2");
Assert.IsTrue(m1.overlapMap((JDFAttributeMap)null));
JDFAttributeMap m2 = new JDFAttributeMap("a1", "v1");
Assert.IsTrue(m1.overlapMap(m2));
m2.put("a2", "v2");
Assert.IsTrue(m1.overlapMap(m2));
m2.put("a2", "v3");
Assert.IsFalse(m1.overlapMap(m2));
m2.put("a2", "v2");
Assert.IsTrue(m1.overlapMap(m2));
m2.put("a2", "*");
Assert.IsTrue(m1.overlapMap(m2));
m2.put("a3", "v3");
Assert.IsTrue(m1.overlapMap(m2));
m2.put("a4", null);
Assert.IsTrue(m1.overlapMap(m2));
m2.put("a4", null);
Assert.IsTrue(m1.overlapMap(m2));
m1.put("a4", null);
Assert.IsTrue(m1.overlapMap(m2));
Assert.IsTrue(m1.overlapMap((JDFAttributeMap)null));
}
///
/// <summary> * orMap - put all key/value pairs which are not in this map to this map. Clear this, if both maps have the same
/// * keys with different values.
/// * </summary>
/// * <param name="subMap"> the map to compare with <code>this</this> </param>
///
public virtual JDFAttributeMap orMap(JDFAttributeMap subMap)
{
IEnumerator <string> subMapEnum = subMap.getKeyIterator();
while (subMapEnum.MoveNext())
{
string subMapKey = subMapEnum.Current;
string subMapVal = subMap[subMapKey];
string hashTableVal = this[subMapKey];
if (hashTableVal != null)
{
if (!hashTableVal.Equals(subMapVal))
{
this.Clear();
break;
}
}
else
{
this.put(subMapKey, subMapVal);
}
}
return(this);
}
///
/// <summary> * overlapMap - identical keys must have the same values in both maps i.e submap is either a superset or a subset of
/// * this
/// * </summary>
/// * <param name="subMap"> the map to compare with <code>this</this>
/// * </param>
/// * <returns> boolean - true if identical keys have the same values in both maps </returns>
///
public virtual bool overlapMap(JDFAttributeMap subMap)
{
if (subMap == null || subMap.Count == 0)
{
return(true);
}
IEnumerator <string> subMapEnum = subMap.getKeyIterator();
while (subMapEnum.MoveNext())
{
string subMapKey = subMapEnum.Current;
string subMapVal = subMap[subMapKey];
if (KElement.isWildCard(subMapVal))
{
continue;
}
string val = this[subMapKey];
if (val != null && !subMapVal.Equals(val))
{
return(false);
}
}
return(true);
}
///
/// <summary> * Method JDFAttributeMap clone the content of the input map
/// * </summary>
/// * <param name="inputMap"> map to clone </param>
///
public JDFAttributeMap(JDFAttributeMap inputMap)
{
if (inputMap != null)
{
m_hashTable = new Dictionary <string, string>(inputMap.m_hashTable);
}
}
public virtual void testGet()
{
JDFAttributeMap m1 = new JDFAttributeMap(EnumPartIDKey.SignatureName, "v1");
Assert.AreEqual("v1", m1.get("SignatureName"));
m1.put(EnumPartIDKey.SheetName, "s1");
Assert.AreEqual("v1", m1.get(EnumPartIDKey.SignatureName));
}
///
/// <summary> * Method overlapMap.
/// * </summary>
/// * <param name="map"> the map to check against </param>
///
public virtual void overlapMap(JDFAttributeMap map)
{
for (int i = this.Count - 1; i >= 0; i--)
{
if (!this[i].overlapMap(map))
{
this.RemoveAt(i);
}
}
}
public virtual void testCopy()
{
JDFAttributeMap m1 = new JDFAttributeMap("a1", "v1");
VJDFAttributeMap v2 = new VJDFAttributeMap();
v2.Add(new JDFAttributeMap(m1));
VJDFAttributeMap v3 = new VJDFAttributeMap(v2);
Assert.AreEqual(v3, v2);
}
public virtual void testShowKeys()
{
JDFAttributeMap m1 = new JDFAttributeMap("a1", "v1");
Assert.AreEqual("(a1 = v1)", m1.showKeys(" "));
m1.put("b1", "v2");
Assert.AreEqual("(a1 = v1) (b1 = v2)", m1.showKeys(" "));
Assert.AreEqual("(a1 = v1)\n(b1 = v2)", m1.showKeys("\n"));
Assert.AreEqual("(a1 = v1)(b1 = v2)", m1.showKeys(null));
}
///
/// <summary> * Method subMap.
/// * </summary>
/// * <param name="map"> the submap to check against </param>
/// * <returns> true if this has at least one entry that subMap is a submap of </returns>
///
public virtual bool subMap(JDFAttributeMap map)
{
for (int i = this.Count - 1; i >= 0; i--)
{
if (this[i].subMap(map))
{
return(true);
}
}
return(false);
}
///
/// <summary> * Method overlapMap.
/// * </summary>
/// * <param name="map"> the map to check against </param>
///
public virtual bool overlapsMap(JDFAttributeMap map)
{
for (int i = Count - 1; i >= 0; i--)
{
if (this[i].overlapMap(map))
{
return(true);
}
}
return(false);
}
public virtual void testReduceMapSet()
{
JDFAttributeMap m1 = new JDFAttributeMap("a1", "v1");
m1.put("a2", "v2");
JDFAttributeMap m2 = new JDFAttributeMap("a1", "v1");
SupportClass.HashSetSupport <string> keys = new SupportClass.HashSetSupport <string>();
keys.Add("a1");
m1.reduceMap(keys);
Assert.AreEqual(m1, m2);
}
public virtual void testPut()
{
JDFAttributeMap m1 = new JDFAttributeMap(EnumPartIDKey.SignatureName, "v1");
Assert.AreEqual("v1", m1.get("SignatureName"));
m1.put(EnumPartIDKey.SheetName, "s1");
Assert.AreEqual("s1", m1.get("SheetName"));
m1.put(EnumPartIDKey.Side, EnumSide.Front);
Assert.AreEqual("Front", m1.get("Side"));
m1.put("Usage", EnumUsage.Input);
Assert.AreEqual("Input", m1.get("Usage"));
}
public virtual void testReduceMap()
{
JDFAttributeMap m1 = new JDFAttributeMap("a1", "v1");
m1.put("a2", "v2");
JDFAttributeMap m2 = new JDFAttributeMap("a1", "v1");
VString keys = new VString();
keys.Add("a1");
m1.reduceMap(keys);
Assert.AreEqual(m1, m2);
}
///
/// <summary> * </summary>
/// * <param name="map"> map to append </param>
///
public virtual void appendUnique(JDFAttributeMap map)
{
for (int i = 0; i < m_vec.Count; i++)
{
if ((m_vec[i]).Equals(map))
{
return;
}
}
m_vec.Add(map);
}
public virtual bool hasEntryWithEqualKeyValuePairs(JDFAttributeMap attmap)
{
bool bEquals = false;
for (int i = 0; i < Count; i++)
{
// if its the same object...ne further action needed
if (attmap == this[i])
{
return(true);
}
// reset for every entry
bEquals = false;
JDFAttributeMap map = this[i];
// only check if both have the same size
if (map.Count == attmap.Count)
{
// now that we found a entry with same entry counter set
// this to true. A single wrong entry will set it to false and
// break. If bEquals is still true after all checks, we found
// the map
bEquals = true;
IEnumerator <string> it = map.getKeyIterator();
while (it.MoveNext())
{
string key = it.Current;
if (!attmap.ContainsKey(key))
{
bEquals = false;
break;
}
string value1 = map.get(key);
string value2 = attmap.get(key);
if (!value1.Equals(value2))
{
bEquals = false;
break;
}
}
// if bEquals is still true we found a matching map
if (bEquals)
{
return(bEquals);
}
}
}
return(bEquals);
}
public virtual void testCloneNull()
{
JDFAttributeMap m1 = new JDFAttributeMap(null);
m1.put("a2", "v2");
JDFAttributeMap m2 = new JDFAttributeMap(m1);
Assert.AreEqual(m1, m2);
m2.put("a2", "v3");
Assert.AreNotEqual(m1, m2);
Assert.AreEqual("v2", m1.get("a2"));
Assert.AreEqual("v3", m2.get("a2"));
}
public virtual void testOverlapsMap()
{
JDFAttributeMap m1 = new JDFAttributeMap("a1", "v1");
m1.put("a2", "v2");
JDFAttributeMap m2 = new JDFAttributeMap(m1);
m2.put("a2", "v3");
VJDFAttributeMap v = new VJDFAttributeMap();
v.Add(m1);
v.Add(m2);
Assert.IsTrue(v.overlapsMap(m1));
Assert.IsFalse(v.overlapsMap(new JDFAttributeMap("a2", "v4")));
}
public virtual void testShowKeys()
{
JDFAttributeMap m1 = new JDFAttributeMap();
m1.put("a2", "v2");
JDFAttributeMap m2 = new JDFAttributeMap(m1);
m2.put("a2", "v3");
m2.put("a3", "v3");
VJDFAttributeMap v = new VJDFAttributeMap();
v.Add(m1);
v.Add(m2);
Assert.AreEqual("[0](a2 = v2)-[1](a2 = v3) (a3 = v3)", v.showKeys("-", " "));
}
///
/// <summary> * returns the index of a given JDFAttributeMap, -1 if not present
/// * </summary>
/// * <param name="map"> the given JDFAttributeMap </param>
///
public virtual int IndexOf(JDFAttributeMap map)
{
int index = -1;
int size = this.Count;
for (int i = 0; i < size; i++)
{
if (this[i].Equals(map))
{
index = i;
break;
}
}
return(index);
}
///
/// * <param name="sepMap"> the separator between maps </param>
/// * <param name="sepEntry"> the saparator between map entries </param>
/// * <returns> the string representation </returns>
///
public virtual string showKeys(string sepMap, string sepEntry)
{
StringBuilder sb = new StringBuilder();
int nPartMaps = this.Count;
for (int i = 0; i < nPartMaps; i++)
{
JDFAttributeMap amParts = this[i];
sb.Append("[").Append(i).Append("]").Append(amParts.showKeys(sepEntry));
if (i + 1 < nPartMaps)
{
sb.Append(sepMap);
}
}
return(sb.ToString());
}
public virtual void testEquals()
{
JDFAttributeMap m1 = new JDFAttributeMap("a1", "v1");
m1.put("a2", "v2");
JDFAttributeMap m2 = new JDFAttributeMap("a1", "v1");
Assert.AreNotEqual(m1, m2);
m2.put("a2", "v2");
Assert.AreEqual(m1, m2);
m1.put("a2", null);
Assert.AreNotEqual(m1, m2);
m2.put("a2", null);
Assert.AreEqual(m1, m2);
Assert.AreNotEqual(null, m1);
}
public virtual void testPut()
{
JDFAttributeMap m1 = new JDFAttributeMap("a1", "v1");
VJDFAttributeMap v2 = new VJDFAttributeMap();
v2.Add(m1);
VJDFAttributeMap v3 = new VJDFAttributeMap(v2);
Assert.AreEqual(v3, v2);
v3.put("a2", "b");
m1.put("a2", "b");
Assert.AreEqual(v2, v3);
VJDFAttributeMap v4 = new VJDFAttributeMap((VJDFAttributeMap)null);
v4.put("a1", "b1");
Assert.AreEqual(1, v4.Count);
}
public virtual void reduceKey(ICollection <string> vKeys)
{
VJDFAttributeMap v = new VJDFAttributeMap();
for (int i = 0; i < m_vec.Count; i++)
{
JDFAttributeMap map = m_vec[i];
map.reduceMap(vKeys);
if (!map.IsEmpty())
{
v.appendUnique(map);
}
}
m_vec = v.getVector();
}
///
/// <summary> * reduce each JDFAttributeMap in <code>this</code> by keySet
/// * </summary>
/// * <param name="keySet"> </param>
///
public virtual void reduceMap(ICollection <string> keySet)
{
VJDFAttributeMap v = new VJDFAttributeMap();
for (int i = 0; i < m_vec.Count; i++)
{
JDFAttributeMap map = m_vec[i];
bool bNullMap = map.IsEmpty();
map.reduceMap(keySet);
if (bNullMap || !map.IsEmpty())
{
v.appendUnique(map);
}
}
m_vec = v.getVector();
}
public virtual void testClone()
{
JDFAttributeMap m1 = new JDFAttributeMap("a1", "v1");
m1.put("a2", "v2");
JDFAttributeMap m2 = new JDFAttributeMap(m1);
m2.put("a2", "v3");
VJDFAttributeMap v = new VJDFAttributeMap((VJDFAttributeMap)null);
v.Add(m1);
v.Add(m2);
VJDFAttributeMap v2 = new VJDFAttributeMap(v);
Assert.AreEqual(v2, v);
m1.put("a3", "a4");
Assert.AreNotEqual(v2, v, "modification did not migrate!");
}
public virtual void testReduceMap()
{
JDFAttributeMap m1 = new JDFAttributeMap("a1", "v1");
VJDFAttributeMap v2 = new VJDFAttributeMap();
v2.Add(new JDFAttributeMap(m1));
m1.put("a2", "v2");
JDFAttributeMap m2 = new JDFAttributeMap(m1);
m2.put("a2", "v3");
VJDFAttributeMap v = new VJDFAttributeMap();
v.Add(m1);
v.Add(m2);
VString vs = new VString("a1", " ");
v.reduceMap(vs.getSet());
Assert.AreEqual(v2, v);
}
public virtual void testEquals()
{
JDFAttributeMap m1 = new JDFAttributeMap("a1", "v1");
m1.put("a2", "v2");
JDFAttributeMap m2 = new JDFAttributeMap(m1);
m2.put("a2", "v3");
VJDFAttributeMap v = new VJDFAttributeMap();
v.Add(m1);
v.Add(m2);
VJDFAttributeMap v2 = new VJDFAttributeMap();
v2.Add(m2);
v2.Add(m1);
Assert.AreEqual(v2, v, "mixed ordering");
v2.Add(m1);
Assert.AreNotEqual(v2, v, "mixed ordering -other cardinality ");
}
