/// <summary>Creates a new CollectionValuedMap with all of the mappings from cvm.</summary> /// <param name="cvm">The CollectionValueMap to copy as this object.</param> public CollectionValuedMap(Edu.Stanford.Nlp.Util.CollectionValuedMap <K, V> cvm) { this.mf = cvm.mf; this.cf = cvm.cf; this.treatCollectionsAsImmutable = cvm.treatCollectionsAsImmutable; this.emptyValue = cvm.emptyValue; map = Java.Util.Collections.SynchronizedMap(mf.NewMap()); foreach (KeyValuePair <K, ICollection <V> > entry in cvm.map) { K key = entry.Key; ICollection <V> c = entry.Value; foreach (V value in c) { Add(key, value); } } }
/// <exception cref="System.TypeLoadException"/> /// <exception cref="System.MissingMethodException"/> /// <exception cref="System.MemberAccessException"/> /// <exception cref="System.Reflection.TargetInvocationException"/> /// <exception cref="Java.Lang.InstantiationException"/> public static IDictionary <K, V> GetMapFromString <K, V>(string s, MapFactory <K, V> mapFactory) { System.Type keyClass = typeof(K); System.Type valueClass = typeof(V); Constructor <K> keyC = keyClass.GetConstructor(new Type[] { typeof(string) }); Constructor <V> valueC = valueClass.GetConstructor(new Type[] { typeof(string) }); if (s[0] != '{') { throw new Exception(string.Empty); } s = Sharpen.Runtime.Substring(s, 1); // get rid of first brace string[] fields = s.Split("\\s+"); IDictionary <K, V> m = mapFactory.NewMap(); // populate m for (int i = 0; i < fields.Length; i++) { // log.info("Parsing " + fields[i]); fields[i] = Sharpen.Runtime.Substring(fields[i], 0, fields[i].Length - 1); // get rid of // following // comma or // brace string[] a = fields[i].Split("="); K key = keyC.NewInstance(a[0]); V value; if (a.Length > 1) { value = valueC.NewInstance(a[1]); } else { value = valueC.NewInstance(string.Empty); } m[key] = value; } return(m); }
/// <summary>Creates a new CollectionValuedMap.</summary> /// <param name="mf">A MapFactory which will be used to generate the underlying Map</param> /// <param name="cf"> /// A CollectionFactory which will be used to generate the Collections /// in each mapping /// </param> /// <param name="treatCollectionsAsImmutable"> /// If true, forces this Map to create new a Collection every time a /// new value is added to or deleted from the Collection a mapping. /// </param> /// <param name="map"> /// An existing map to use rather than initializing one with mf. If this is non-null it is /// used to initialize the map rather than mf. /// </param> private CollectionValuedMap(MapFactory <K, ICollection <V> > mf, CollectionFactory <V> cf, bool treatCollectionsAsImmutable, IDictionary <K, ICollection <V> > map) { if (cf == null) { throw new ArgumentException(); } if (mf == null && map == null) { throw new ArgumentException(); } this.mf = mf; this.cf = cf; this.treatCollectionsAsImmutable = treatCollectionsAsImmutable; this.emptyValue = cf.NewEmptyCollection(); if (map != null) { this.map = map; } else { this.map = Java.Util.Collections.SynchronizedMap(mf.NewMap()); } }
/// <summary>This is very cheap.</summary> /// <param name="originalMap">will serve as the basis for this DeltaMap</param> public DeltaMap(IDictionary <K, V> originalMap, MapFactory <K, V> mf) { this.originalMap = Java.Util.Collections.UnmodifiableMap(originalMap); // unmodifiable for debugging only this.deltaMap = mf.NewMap(); }
public BinaryHeapPriorityQueue(MapFactory <E, BinaryHeapPriorityQueue.Entry <E> > mapFactory, int initCapacity) { indexToEntry = new List <BinaryHeapPriorityQueue.Entry <E> >(initCapacity); keyToEntry = mapFactory.NewMap(initCapacity); }
public BinaryHeapPriorityQueue(MapFactory <E, BinaryHeapPriorityQueue.Entry <E> > mapFactory) { indexToEntry = new List <BinaryHeapPriorityQueue.Entry <E> >(); keyToEntry = mapFactory.NewMap(); }
public TwoDimensionalMap(MapFactory <K1, IDictionary <K2, V> > mf1, MapFactory <K2, V> mf2) { this.mf1 = mf1; this.mf2 = mf2; this.map = mf1.NewMap(); }