-#if NET_2_0
-/*\r
- Copyright (c) 2003-2006 Niels Kokholm and Peter Sestoft\r
- Permission is hereby granted, free of charge, to any person obtaining a copy\r
- of this software and associated documentation files (the "Software"), to deal\r
- in the Software without restriction, including without limitation the rights\r
- to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\r
- copies of the Software, and to permit persons to whom the Software is\r
- furnished to do so, subject to the following conditions:\r
- \r
- The above copyright notice and this permission notice shall be included in\r
- all copies or substantial portions of the Software.\r
- \r
- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\r
- IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\r
- FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\r
- AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\r
- LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\r
- OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\r
- SOFTWARE.\r
-*/\r
-\r
-using System;\r
-using System.Diagnostics;\r
-using SCG = System.Collections.Generic;\r
-namespace C5\r
-{\r
- abstract class MappedDirectedCollectionValue<T, V> : DirectedCollectionValueBase<V>, IDirectedCollectionValue<V>\r
- {\r
- IDirectedCollectionValue<T> directedcollectionvalue;\r
-\r
- abstract public V Map(T item);\r
-\r
- public MappedDirectedCollectionValue(IDirectedCollectionValue<T> directedcollectionvalue)\r
- {\r
- this.directedcollectionvalue = directedcollectionvalue;\r
- }\r
-\r
- public override V Choose() { return Map(directedcollectionvalue.Choose()); }\r
-\r
- public override bool IsEmpty { get { return directedcollectionvalue.IsEmpty; } }\r
-\r
- public override int Count { get { return directedcollectionvalue.Count; } }\r
-\r
- public override Speed CountSpeed { get { return directedcollectionvalue.CountSpeed; } }\r
-\r
- public override IDirectedCollectionValue<V> Backwards()\r
- {\r
- MappedDirectedCollectionValue<T, V> retval = (MappedDirectedCollectionValue<T, V>)MemberwiseClone();\r
- retval.directedcollectionvalue = directedcollectionvalue.Backwards();\r
- return retval;\r
- //If we made this classs non-abstract we could do\r
- //return new MappedDirectedCollectionValue<T,V>(directedcollectionvalue.Backwards());;\r
- }\r
-\r
-\r
- public override SCG.IEnumerator<V> GetEnumerator()\r
- {\r
- foreach (T item in directedcollectionvalue)\r
- yield return Map(item);\r
- }\r
-\r
- public override EnumerationDirection Direction\r
- {\r
- get { return directedcollectionvalue.Direction; }\r
- }\r
-\r
- IDirectedEnumerable<V> IDirectedEnumerable<V>.Backwards()\r
- {\r
- return Backwards();\r
- }\r
-\r
-\r
- }\r
-\r
- abstract class MappedCollectionValue<T, V> : CollectionValueBase<V>, ICollectionValue<V>\r
- {\r
- ICollectionValue<T> collectionvalue;\r
-\r
- abstract public V Map(T item);\r
-\r
- public MappedCollectionValue(ICollectionValue<T> collectionvalue)\r
- {\r
- this.collectionvalue = collectionvalue;\r
- }\r
-\r
- public override V Choose() { return Map(collectionvalue.Choose()); }\r
-\r
- public override bool IsEmpty { get { return collectionvalue.IsEmpty; } }\r
-\r
- public override int Count { get { return collectionvalue.Count; } }\r
-\r
- public override Speed CountSpeed { get { return collectionvalue.CountSpeed; } }\r
-\r
- public override SCG.IEnumerator<V> GetEnumerator()\r
- {\r
- foreach (T item in collectionvalue)\r
- yield return Map(item);\r
- }\r
- }\r
- \r
- class MultiplicityOne<K> : MappedCollectionValue<K, KeyValuePair<K, int>>\r
- {\r
- public MultiplicityOne(ICollectionValue<K> coll):base(coll) { }\r
- public override KeyValuePair<K, int> Map(K k) { return new KeyValuePair<K, int>(k, 1); }\r
- }\r
-\r
- class DropMultiplicity<K> : MappedCollectionValue<KeyValuePair<K, int>, K>\r
- {\r
- public DropMultiplicity(ICollectionValue<KeyValuePair<K, int>> coll):base(coll) { }\r
- public override K Map(KeyValuePair<K, int> kvp) { return kvp.Key; }\r
- }\r
- \r
- abstract class MappedDirectedEnumerable<T, V> : EnumerableBase<V>, IDirectedEnumerable<V>\r
- {\r
- IDirectedEnumerable<T> directedenumerable;\r
-\r
- abstract public V Map(T item);\r
-\r
- public MappedDirectedEnumerable(IDirectedEnumerable<T> directedenumerable)\r
- {\r
- this.directedenumerable = directedenumerable;\r
- }\r
-\r
- public IDirectedEnumerable<V> Backwards()\r
- {\r
- MappedDirectedEnumerable<T, V> retval = (MappedDirectedEnumerable<T, V>)MemberwiseClone();\r
- retval.directedenumerable = directedenumerable.Backwards();\r
- return retval;\r
- //If we made this classs non-abstract we could do\r
- //return new MappedDirectedCollectionValue<T,V>(directedcollectionvalue.Backwards());;\r
- }\r
-\r
-\r
- public override SCG.IEnumerator<V> GetEnumerator()\r
- {\r
- foreach (T item in directedenumerable)\r
- yield return Map(item);\r
- }\r
-\r
- public EnumerationDirection Direction\r
- {\r
- get { return directedenumerable.Direction; }\r
- }\r
- }\r
-}
-#endif
+/*
+ Copyright (c) 2003-2006 Niels Kokholm and Peter Sestoft
+ Permission is hereby granted, free of charge, to any person obtaining a copy
+ of this software and associated documentation files (the "Software"), to deal
+ in the Software without restriction, including without limitation the rights
+ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ copies of the Software, and to permit persons to whom the Software is
+ furnished to do so, subject to the following conditions:
+
+ The above copyright notice and this permission notice shall be included in
+ all copies or substantial portions of the Software.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ SOFTWARE.
+*/
+
+using System;
+using System.Diagnostics;
+using SCG = System.Collections.Generic;
+namespace C5
+{
+ abstract class MappedDirectedCollectionValue<T, V> : DirectedCollectionValueBase<V>, IDirectedCollectionValue<V>
+ {
+ IDirectedCollectionValue<T> directedcollectionvalue;
+
+ abstract public V Map(T item);
+
+ public MappedDirectedCollectionValue(IDirectedCollectionValue<T> directedcollectionvalue)
+ {
+ this.directedcollectionvalue = directedcollectionvalue;
+ }
+
+ public override V Choose() { return Map(directedcollectionvalue.Choose()); }
+
+ public override bool IsEmpty { get { return directedcollectionvalue.IsEmpty; } }
+
+ public override int Count { get { return directedcollectionvalue.Count; } }
+
+ public override Speed CountSpeed { get { return directedcollectionvalue.CountSpeed; } }
+
+ public override IDirectedCollectionValue<V> Backwards()
+ {
+ MappedDirectedCollectionValue<T, V> retval = (MappedDirectedCollectionValue<T, V>)MemberwiseClone();
+ retval.directedcollectionvalue = directedcollectionvalue.Backwards();
+ return retval;
+ //If we made this classs non-abstract we could do
+ //return new MappedDirectedCollectionValue<T,V>(directedcollectionvalue.Backwards());;
+ }
+
+
+ public override SCG.IEnumerator<V> GetEnumerator()
+ {
+ foreach (T item in directedcollectionvalue)
+ yield return Map(item);
+ }
+
+ public override EnumerationDirection Direction
+ {
+ get { return directedcollectionvalue.Direction; }
+ }
+
+ IDirectedEnumerable<V> IDirectedEnumerable<V>.Backwards()
+ {
+ return Backwards();
+ }
+
+
+ }
+
+ abstract class MappedCollectionValue<T, V> : CollectionValueBase<V>, ICollectionValue<V>
+ {
+ ICollectionValue<T> collectionvalue;
+
+ abstract public V Map(T item);
+
+ public MappedCollectionValue(ICollectionValue<T> collectionvalue)
+ {
+ this.collectionvalue = collectionvalue;
+ }
+
+ public override V Choose() { return Map(collectionvalue.Choose()); }
+
+ public override bool IsEmpty { get { return collectionvalue.IsEmpty; } }
+
+ public override int Count { get { return collectionvalue.Count; } }
+
+ public override Speed CountSpeed { get { return collectionvalue.CountSpeed; } }
+
+ public override SCG.IEnumerator<V> GetEnumerator()
+ {
+ foreach (T item in collectionvalue)
+ yield return Map(item);
+ }
+ }
+
+ class MultiplicityOne<K> : MappedCollectionValue<K, KeyValuePair<K, int>>
+ {
+ public MultiplicityOne(ICollectionValue<K> coll):base(coll) { }
+ public override KeyValuePair<K, int> Map(K k) { return new KeyValuePair<K, int>(k, 1); }
+ }
+
+ class DropMultiplicity<K> : MappedCollectionValue<KeyValuePair<K, int>, K>
+ {
+ public DropMultiplicity(ICollectionValue<KeyValuePair<K, int>> coll):base(coll) { }
+ public override K Map(KeyValuePair<K, int> kvp) { return kvp.Key; }
+ }
+
+ abstract class MappedDirectedEnumerable<T, V> : EnumerableBase<V>, IDirectedEnumerable<V>
+ {
+ IDirectedEnumerable<T> directedenumerable;
+
+ abstract public V Map(T item);
+
+ public MappedDirectedEnumerable(IDirectedEnumerable<T> directedenumerable)
+ {
+ this.directedenumerable = directedenumerable;
+ }
+
+ public IDirectedEnumerable<V> Backwards()
+ {
+ MappedDirectedEnumerable<T, V> retval = (MappedDirectedEnumerable<T, V>)MemberwiseClone();
+ retval.directedenumerable = directedenumerable.Backwards();
+ return retval;
+ //If we made this classs non-abstract we could do
+ //return new MappedDirectedCollectionValue<T,V>(directedcollectionvalue.Backwards());;
+ }
+
+
+ public override SCG.IEnumerator<V> GetEnumerator()
+ {
+ foreach (T item in directedenumerable)
+ yield return Map(item);
+ }
+
+ public EnumerationDirection Direction
+ {
+ get { return directedenumerable.Direction; }
+ }
+ }
+}
\ No newline at end of file
projects / mono.git / blobdiff