RankedMapTKey, TValue Class

[SerializableAttribute]
public class RankedMap<TKey, TValue> : Btree<TKey>, 
	ICollection<KeyValuePair<TKey, TValue>>, IEnumerable<KeyValuePair<TKey, TValue>>, 
	IEnumerable, ICollection, IReadOnlyCollection<KeyValuePair<TKey, TValue>>, 
	ISerializable, IDeserializationCallback

using System;
using Kaos.Collections;

namespace ExampleApp
{
    class RmExample02
    {
        static void Main()
        {
            var map = new RankedMap<char,int>();
            var input = "this is it";

            for (int pos = 0; pos < input.Length; ++pos)
                if (! Char.IsWhiteSpace (input[pos]))
                    map.Add (input[pos], pos);

            foreach (var kv in map)
                Console.WriteLine (kv);
        }

        /* Output:

        [h, 1]
        [i, 2]
        [i, 5]
        [i, 8]
        [s, 3]
        [s, 6]
        [t, 0]
        [t, 9]

        */
    }
}

using System;
using Kaos.Collections;

namespace ExampleApp
{
    class RmExample01
    {
        static void Main()
        {
            // Keys will compare case insensitive with this constructor.
            var fmt = new RankedMap<string,string> (StringComparer.InvariantCultureIgnoreCase);

            fmt.Add ("csv", "Comma Separated Values");
            fmt.Add ("DAT", "dBase II data file");
            fmt.Add ("dat", "Sony Digital Audio Tape");

            fmt.Add ("qt", "QuickTime movie clip");
            fmt.Add ("jpeg", "JPEG bitmap image format");
            fmt.Add ("sln", "Blend for Visual Studio");
            fmt.Add ("sln", "Visual Studio 2017");

            if (fmt.ContainsKey ("jpeg"))
                fmt.Add ("jpg", "JPEG bitmap image format");

            if (fmt.Keys.GetCount ("sln") > 1)
                fmt.Add ("sln", "Visual Studio Version Selector");

            // When you use foreach to enumerate map elements,
            // each element is retrieved as a KeyValuePair.
            Console.WriteLine ("All map elements:");
            foreach (System.Collections.Generic.KeyValuePair<string,string> pair in fmt)
                Console.WriteLine ($"  Key = {pair.Key}, Value = {pair.Value}");

            Console.WriteLine ($"\nDistinct format count: {fmt.Keys.GetDistinctCount()}");
            Console.WriteLine ($"Total format count: {fmt.Count}");

            Console.WriteLine ("\nRemove all sln format occurrences...");
            int removed = fmt.Remove ("sln", Int32.MaxValue);
            Console.WriteLine ($"Items removed: {removed}");

            Console.WriteLine ("Remove qt format...");
            fmt.Remove ("qt");

            // To get the keys alone, use the Keys property.
            RankedMap<string,string>.KeyCollection keys = fmt.Keys;

            // The items of a KeyCollection have the type specified for the map keys.
            Console.WriteLine ("\nKeys:");
            foreach (string x in keys)
                Console.WriteLine ($"  {x}");

            // To get the values alone, use the Values property.
            RankedMap<string,string>.ValueCollection values = fmt.Values;

            Console.WriteLine ("\nValues:");
            foreach (string x in values)
                Console.WriteLine ($"  {x}");
        }

        /* Output:

        All map elements:
          Key = csv, Value = Comma Separated Values
          Key = DAT, Value = dBase II data file
          Key = dat, Value = Sony Digital Audio Tape
          Key = jpeg, Value = JPEG bitmap image format
          Key = jpg, Value = JPEG bitmap image format
          Key = qt, Value = QuickTime movie clip
          Key = sln, Value = Blend for Visual Studio
          Key = sln, Value = Visual Studio 2017
          Key = sln, Value = Visual Studio Version Selector

        Distinct format count: 6
        Total format count: 9

        Remove all sln format occurrences...
        Items removed: 3
        Remove qt format...

        Keys:
          csv
          DAT
          dat
          jpeg
          jpg

        Values:
          Comma Separated Values
          dBase II data file
          Sony Digital Audio Tape
          JPEG bitmap image format
          JPEG bitmap image format

        */
    }
}

using System;
using System.Collections.Generic;
using System.IO;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Formatters.Binary;
using Kaos.Collections;

namespace ExampleApp
{
    [Serializable]
    public class PlayerComparer : Comparer<Player>
    {
        public override int Compare (Player x, Player y)
        {
            int cp = String.Compare (x.Clan, y.Clan);
            return cp != 0 ? cp : String.Compare (x.Name, y.Name);
        }
    }

    [Serializable]
    public class PlayerMap : RankedMap<Player,int>
    {
        public string Game { get; set; }

        public PlayerMap() : base (new PlayerComparer())
        { }

        public PlayerMap (SerializationInfo info, StreamingContext context) : base (info, context)
        {
            this.Game = info.GetString ("Game");
        }

        protected override void GetObjectData (SerializationInfo info, StreamingContext context)
        {
            base.GetObjectData (info, context);
            info.AddValue ("Game", Game, typeof (string));
        }
    }

    [Serializable]
    public class Player : ISerializable
    {
        public string Clan { get; private set; }
        public string Name { get; private set; }

        public Player (string clan, string name)
        { this.Clan = clan; this.Name = name; }

        protected Player (SerializationInfo info, StreamingContext context)
        {
            this.Clan = (string) info.GetValue ("Clan", typeof (string));
            this.Name = (string) info.GetValue ("Name", typeof (string));
        }

        public virtual void GetObjectData (SerializationInfo info, StreamingContext context)
        {
            info.AddValue ("Clan", Clan, typeof (string));
            info.AddValue ("Name", Name, typeof (string));
        }

        public override string ToString() => Clan + "." + Name;
    }


    class RmExample05
    {
        static void Main()
        {
            string fileName = "MapScores.bin";
            var map1 = new PlayerMap() { Game = "Day of Defeat" };
            map1.Add (new Player ("GG", "Floyd"), 11);
            map1.Add (new Player (null, "Player"), 22);
            map1.Add (new Player ("A1", "Betty"), 44);
            map1.Add (new Player ("GG", "Edwin"), 66);
            map1.Add (new Player (null, "Player"), 77);

            IFormatter formatter = new BinaryFormatter();
            using (var fs = new FileStream (fileName, FileMode.Create))
            { formatter.Serialize (fs, map1); }

            Console.WriteLine ($"Wrote {map1.Count} key/value pairs.\n");

            PlayerMap map2 = null;
            using (var fs = new FileStream (fileName, FileMode.Open))
            { map2 = (PlayerMap) formatter.Deserialize (fs); }

            Console.WriteLine ("Read back:");
            Console.WriteLine ($"Game = {map2.Game}");
            Console.WriteLine ("Players:");
            foreach (var kv in map2)
                Console.WriteLine ($"  {kv}");
        }

        /* Output:

        Wrote 5 key/value pairs.

        Read back:
        Game = Day of Defeat
        Players:
          [.Player, 22]
          [.Player, 77]
          [A1.Betty, 44]
          [GG.Edwin, 66]
          [GG.Floyd, 11]

        */
    }
}