nstl Wiki & Documentation Rss Feed

Updated Wiki: Documentation

AndyM — Tue, 20 Oct 2009 18:04:01 GMT

Documentation

The current documentation does not reflect the 3.0 features yet.

Updated Wiki: Documentation Overview

AndyM — Fri, 02 Oct 2009 17:17:47 GMT

Documentation

The current documentation does not reflect the 3.0 features yet.

Updated Wiki: Home

AndyM — Fri, 02 Oct 2009 17:15:43 GMT

The NSTL Project

The NSTL project is originally a port and adaptation of the C++ STL to the .NET world. The main focus is to preserve the concepts and the power of the STL, especially in the area of algorithms and extensibility. It features the complete set of the STL's algorithms, a set of containers that are missing in the System.Collections.Generic namespace and the full range of adapters, binders and functors. It is fully compatible with the .NET collections and concepts and integrates well with them.

Further documentation can be found here.

Current Status

The current releaseversion is 3.0, implemented in .NET 3.5. A .NET 2.0 version is still available, too. Latest Builds are posted on a regular basis. As they are have undergone a full automated release build, they can be considered as stable as a regular release.

Road map

The current release integrates the NSTL tightly with the .NET collections and LINQ. The next step will try to evolve this integration and simplify the use of the NSTL by providing the algorithms of the NSTL as extension methods to omplement the LINQ query operators.

Updated Wiki: Home

AndyM — Mon, 01 Jun 2009 11:26:07 GMT

The NSTL Project

The NSTL project is a port and adaptation of the C++ STL to the .NET world. The main focus is to preserve the concepts and the power of the STL, especially in the area of algorithms and extensibility. It features the complete set of the STL's algorithms, a set of containers that are missing in the System.Collections.Generic namespace and the full range of adapters, binders and functors. It is fully compatible with the .NET collections and concepts.

Further documentation can be found here.

Current Status

The current releaseversion is 2.7, implemented in .NET 2.0. Latest Builds are posted on a regular basis. As they are have undergone a full automated release build, they can be considered as stable as a regular release.

Road map

In the next minor releases some missing algorithms from different STL implementations will be added and overloads will be provided to make the use of adapters for the .NET System.Collections.Generic classes unnecessary.

With LINQ, .NET 3.5 offers a comprehensive and powerfull algorithm and data structure library. The next major release 3.0 will integrate tightly with it. Additional to the full orthogonal decoupled power of the NSTL's algorithms, those that can not be replaced by LINQ standard query operators, will be offered as such query operators. .NETcollections will be enriched with extension methods to let them closely interact with the NSTL's feature, without using the bulky adapters that are necessary right now. The plan is a seamless transition between LINQ and the NSTL in both directions.

A stable pre release can be found in the Latest Builds section.

Updated Wiki: Home

AndyM — Mon, 01 Jun 2009 11:24:49 GMT

The NSTL Project

The NSTL project is a port and adaptation of the {C++} STL to the .NET world. The main focus is to preserve the concepts and the power of the STL, especially in the area of algorithms and extensibility. It features the complete set of the STL's algorithms, a set of containers that are missing in the System.Collections.Generic namespace and the full range of adapters, binders and functors. It is fully compatible with the .NET collections and concepts.

Further documentation can be found here.

Current Status

The current releaseversion is 2.7, implemented in .NET 2.0. Latest Builds are posted on a regular basis. As they are have undergone a full automated release build, they can be considered as stable as a regular release.

Road map

In the next minor releases some missing algorithms from different STL implementations will be added and overloads will be provided to make the use of adapters for the .NET System.Collections.Generic classes unnecessary.

With LINQ, .NET 3.5 offers a comprehensive and powerfull algorithm and data structure library. The next major release 3.0 will integrate tightly with it. Additional to the full orthogonal decoupled power of the NSTL's algorithms, those that can not be replaced by LINQ standard query operators, will be offered as such query operators. .NETcollections will be enriched with extension methods to let them closely interact with the NSTL's feature, without using the bulky adapters that are necessary right now. The plan is a seamless transition between LINQ and the NSTL in both directions.

A first stable alpha can be found in the Latest Builds section.

Updated Wiki: Home

AndyM — Wed, 24 Sep 2008 19:10:22 GMT

The NSTL Project

The NSTL project is a port and adaptation of the C++ STL to the .NET world. The main focus is to preserve the concepts and the power of the STL, especially in the area of algorithms and extensibility. It features the complete set of the STL's algorithms, a set of containers that are missing in the System.Collections.Generic namespace and the full range of adapters, binders and functors. It is fully compatible with the .NET collections and concepts.

Further documentation can be found here.

Current Status

The current releaseversion is 2.7, implemented in .NET 2.0. Latest Builds are posted on a regular basis. As they are have undergone a full automated release build, they can be considered as stable as a regular release.

Road map

In the next minor releases some missing algorithms from different STL implementations will be added and overloads will be provided to make the use of adapters for the .NET System.Collections.Generic classes unnecessary.

With LINQ, .NET 3.5 offers a comprehensive and powerfull algorithm and data structure library. The next major release 3.0 will integrate tightly with it. Additional to the full orthogonal decoupled power of the NSTL's algorithms, those that can not be replaced by LINQ standard query operators, will be offered as such query operators. .NETcollections will be enriched with extension methods to let them closely interact with the NSTL's feature, without using the bulky adapters that are necessary right now. The plan is a seamless transition between LINQ and the NSTL in both directions.

A first stable alpha can be found in the Latest Builds section.

Updated Wiki: Home

AndyM — Sun, 21 Sep 2008 13:45:52 GMT

UPDATED WIKI: Home

AndyM — Wed, 07 May 2008 18:29:30 GMT

The NSTL Project

The NSTL project is a port and adaptation of the C++ STL to the .NET world. The main focus is to preserve the concepts and the power of the STL, especially in the area of algorithms and extensibility. It features the complete set of the STL's algorithms, a set of containers that are missing in the System.Collections.Generic namespace and the full range of adapters, binders and functors. It is fully compatible with the .NET collections and concepts.

Further documentation can be found here.

Current Status

The current releaseversion is 2.6, implemented in .NET 2.0. Latest Builds are posted on a regular basis. As they are have undergone a full automated release build, they can be considered as stable as a regular release.

Road map

In the next minor releases some missing algorithms from different STL implementations will be added and overloads will be provided to make the use of adapters for the .NET System.Collections.Generic classes unnecessary.

With LINQ, .NET 3.5 offers a comprehensive and powerfull algorithm and data structure library. The next major release 3.0 will integrate tightly with it. Additional to the full orthogonal decoupled power of the NSTL's algorithms, those that can not be replaced by LINQ standard query operators, will be offered as such query operators. .NETcollections will be enriched with extension methods to let them closely interact with the NSTL's feature, without using the bulky adapters that are necessary right now. The plan is a seamless transition between LINQ and the NSTL in both directions.

UPDATED WIKI: Home

AndyM — Wed, 07 May 2008 07:34:05 GMT

The NSTL Project

The NSTL project is a port and adaptation of the C++ STL to the .NET world. The main focus is to preserve the concepts and the power of the STL, especially in the area of algorithms and extensibility. It features the complete set of the STL's algorithms, a set of containers that are missing in the System.Collections.Generic namespace and the full range of adapters, binders and functors. It is fully compatible with the .NET collections and concepts.

Further documentation can be found here.

Current Status

The current release version is 2.5, implemented in .NET 2.0. Latest Builds are posted on a regular basis. As they are have undergone a full automated release build, they can be considered as stable as a regular release.

Road map

In the next minor releases some missing algorithms from different STL implementations will be added and overloads will be provided to make the use of adapters for the .NET System.Collections.Generic classes unnecessary.

With LINQ, .NET 3.5 offers a comprehensive and powerfull algorithm and data structure library. The next major release 3.0 will integrate tightly with it. Additional to the full orthogonal decoupled power of the NSTL's algorithms, those that can not be replaced by LINQ standard query operators, will be offered as such query operators. .NETcollections will be enriched with extension methods to let them closely interact with the NSTL's feature, without using the bulky adapters that are necessary right now. The plan is a seamless transition between LINQ and the NSTL in both directions.

UPDATED WIKI: Home

AndyM — Mon, 05 May 2008 22:09:59 GMT

The NSTL Project

The NSTL project is a port and adaptation of the C++ STL to the .NET world. The main focus is to preserve the concepts and the power of the STL, especially in the area of algorithms and extensibility. It features the complete set of the STL's algorithms, a set of containers that are missing in the System.Collections.Generic namespace and the full range of adapters, binders and functors. It is fully compatible with the .NET collections and concepts.

Further documentation can be found here.

Current Status

The current release version is 2.5, implemented in .NET 2.0.

Road map

In the next minor releases some missing algorithms from different STL implementations will be added and overloads will be provided to make the use of adapters for the .NET System.Collections.Generic classes unnecessary.

With LINQ, .NET 3.5 offers a comprehensive and powerfull algorithm and data structure library. The next major release 3.0 will integrate tightly with it. Additional to the full orthogonal decoupled power of the NSTL's algorithms, those that can not be replaced by LINQ standard query operators, will be offered as such query operators. .NETcollections will be enriched with extension methods to let them closely interact with the NSTL's feature, without using the bulky adapters that are necessary right now. The plan is a seamless transition between LINQ and the NSTL in both directions.

UPDATED WIKI: Home

AndyM — Mon, 05 May 2008 22:09:40 GMT

The NSTL Project

The NSTL project is a port and adaptation of the C++ STL to the .NET world. The main focus is to preserve the concepts and the power of the STL, especially in the area of algorithms and extensibility. It features the complete set of the STL's algorithms, a set of containers that are missing in the System.Collections.Generic namespace and the full range of adapters, binders and functors. It is fully compatible with the .NET collections and concepts.

Further documentation can be found here.

Current Status

The current release version is 2.6, implemented in .NET 2.0.

Road map

In the next minor releases some missing algorithms from different STL implementations will be added and overloads will be provided to make the use of adapters for the .NET System.Collections.Generic classes unnecessary.

With LINQ, .NET 3.5 offers a comprehensive and powerfull algorithm and data structure library. The next major release 3.0 will integrate tightly with it. Additional to the full orthogonal decoupled power of the NSTL's algorithms, those that can not be replaced by LINQ standard query operators, will be offered as such query operators. .NETcollections will be enriched with extension methods to let them closely interact with the NSTL's feature, without using the bulky adapters that are necessary right now. The plan is a seamless transition between LINQ and the NSTL in both directions.

UPDATED WIKI: Home

AndyM — Mon, 05 May 2008 22:08:10 GMT

The NSTL Project

The NSTL project is a port and adaptation of the C++ STL to the .NET world. The main focus is to preserve the concepts and the power of the STL, especially in the area of algorithms and extensibility. It features the complete set of the STL's algorithms, a set of containers that are missing in the System.Collections.Generic namespace and the full range of adapters, binders and functors. It is fully compatible with the .NET collections and concepts.

Further documentation can be found here.

Current Status

The current release version is 2.6, implemented in .NET 2.0.

Road map

In the next minor releases some missing algorithms from different STL implementations will be added and overloads will be provided to make the use of adapters for the .NET System.Collections.Generic classes unnecessary.

With LINQ, .NET 3.5 offers a comprehensive and powerfull algorithm and data structure library. The next major release 3.0 will integrate tightly with it. Additional to the full orthogonal decoupled power of the NSTL's algorithms, those that can not be replaced by LINQ standard query operators, will be offered as such query operators. .NETcollections will be enriched with extension methods to let them closely interact with the NSTL's feature, without using the bulky adapters that are necessary right now. The plan is a seamless transition between LINQ and the NSTL. in both directions.

UPDATED WIKI: Documentation Overview

AndyM — Fri, 14 Mar 2008 22:05:10 GMT

Documentation

UPDATED WIKI: Documentation Overview

AndyM — Fri, 14 Mar 2008 22:04:28 GMT

Documentation

UPDATED WIKI: Code Examples

AndyM — Wed, 02 Jan 2008 18:58:26 GMT

Examples

The following example finds the intersection of two collections of System.Type objects. It uses the adapter functionality of the NstlUtil class to be able to use standard .NET collections from the System.Collections.Generic namespace.

using System;
using System.Collections.Generic;
using NStl;
 
namespace NstlExamples
{
    class A { }
    class B : A { }
    class C : A { }
    class D : B { }
    class E { }
 
    class LessByName<T> : BinaryPredicate<T, T>
    {
        bool BinaryFunction<T, T, bool>.Execute(T lhs, T rhs)
        {
            return lhs.ToString().CompareTo(rhs.ToString()) < 0;
        }
    }
 
    class Program
    {
        static void Main()
        {
            Type[] tps1 = new Type[] { typeof(A), typeof(B), typeof(E) };
            Type[] tps2 = new Type[] { typeof(A), typeof(B), typeof(D) };
 
            Algorithm.Sort(NstlUtil.Begin(tps1), NstlUtil.End(tps1),
                           new LessByName<Type>());
            Algorithm.Sort(NstlUtil.Begin(tps2), NstlUtil.End(tps2),
                           new LessByName<Type>());
 
            List<Type> result = new List<Type>();
 
            Algorithm.SetIntersection(NstlUtil.Begin(tps1), NstlUtil.End(tps1),
                     NstlUtil.Begin(tps2), NstlUtil.End(tps2),
                     NstlUtil.BackInserter(result), new LessByName<Type>());
 
        }
    }
}

The next code block does exactly the same as the first one. The difference is that instead of implementing a functor to compare two Types, it uses a anonymous delegate which is adapted by the Functional.PtrFun(...) method.

using System;
using System.Collections.Generic;
using NStl;
 
namespace NstlExamples
{
    class A { }
    class B : A { }
    class C : A { }
    class D : B { }
    class E { }
 
    class Program
    {
        static void Main()
        {
            BinaryFunction<Type, Type, bool> lessByName = 
                Functional.PtrFun<Type, Type, bool>(delegate(Type lhs, Type rhs){
                                        return lhs.ToString().CompareTo(rhs.ToString()) < 0;
                                                                                 });
            Type[] tps1 = new Type[] { typeof(A), typeof(B), typeof(E) };
            Type[] tps2 = new Type[] { typeof(A), typeof(B), typeof(D) };
 
            Algorithm.Sort(NstlUtil.Begin(tps1), NstlUtil.End(tps1), lessByName);
            Algorithm.Sort(NstlUtil.Begin(tps2), NstlUtil.End(tps2), lessByName);
 
            List<Type> result = new List<Type>();
            Algorithm.SetIntersection(NstlUtil.Begin(tps1), NstlUtil.End(tps1),
                     NstlUtil.Begin(tps2), NstlUtil.End(tps2),
                     NstlUtil.BackInserter(result), lessByName);
 
        }
    }
}

In the next example all values are extracted from a collection of key value pairs using the Algorithm.Transform algorithm and the Select.SecondFromKeyValuePair functor and inserted into a LinkedList.

using System.Collections.Generic;
using NStl;
 
namespace NstlExamples
{
    class Program
    {
        static void Main()
        {
            List<KeyValuePair<int, string>> int2str = new List<KeyValuePair<int, string>>();
 
            // … file the list
            for (int i = 0; i < 10; ++i)
                int2str.Add(new KeyValuePair<int, string>(i, i.ToString()));
 
            LinkedList<string> strs = new LinkedList<string>();
 
            Algorithm.Transform(NstlUtil.Begin(int2str), NstlUtil.End(int2str),
                NstlUtil.BackInserter(strs), Select.SecondFromKeyValuePair<int, string>());
 
        }
    }
}

In the next example the value of 10 is searched in a custom NSTL collection using an existing static function and the Algorithm.Find(...) linear search algorithm.

using System;
using NStl;
 
namespace NstlExamples
{
    class Program
    {
        static bool Equals10(int par)
        {
            return par == 10;
        }
        static void Main()
        {
            DList<int> ints = new DList<int>();
            for (int i = 0; i < 20; ++i)
                ints.PushBack(i);
 
            DList<int>.Iterator found = 
                Algorithm.FindIf(ints.Begin(), ints.End(), 
                            Functional.PtrFun<int, bool>(Equals10));
 
            if (!found.Equals(ints.End()))
                Console.WriteLine("Found value: " + found.Value.ToString());
        }
    }
}

The above sample can also be implemented without a custom function at all by using the provided binary function returned by the Compare.EqualTo<T>() factory method and a so called binder. The Bind.Second binder factory method returns an adapter object that will store the value of 10 and pass it as the second parameter into the EqualTo binary function for each item in the DList<T>.

using System;
using NStl;
 
namespace NstlExamples
{
    class Program
    {
        static void Main()
        {
            DList<int> ints = new DList<int>();
            for (int i = 0; i < 20; ++i)
                ints.PushBack(i);
 
            UnaryPredicate<int> equals10 = 
                Bind.Second(Compare.EqualTo<int>(), 10);
            
            DList<int>.Iterator found = 
                Algorithm.FindIf(ints.Begin(), ints.End(), equals10);
 
            if (!found.Equals(ints.End()))
                Console.WriteLine("Found value: " + found.Value.ToString());
        }
    }
}

It is possible to combine existing functors using the so called composition binders. Basically these are functors that execute a given functor and use the result as input for other functors. The following example evaluates as string property, converts the result to an integer and appends it to a target collection.

using System.Collections.Generic;
using NStl;
 
namespace NstlExamples
{
    class Something
    {
        public Something(string name)
        {
            this.name = name;
        }
        public string Name
        {
            get { return name; }
        }
        private readonly string name;
    }
    class Program
    {
        static void Main()
        {
            IList<Something> somethings = new List<Something>();
            for (int i = 0; i < 20; ++i)
                somethings.Add(new Something(i.ToString()));
 
            // ... evaluate string property
            UnaryFunction<Something, string> somethingsPropName =
                Functional.PtrFun<Something, string>(delegate(Something s) { return s.Name; });
            
            // ... convert a string to an integer
            UnaryFunction<string, int> convertToInt =
                Functional.PtrFun<string, int>(delegate(string s) { return int.Parse(s); });
 
            // ... combine both functors to convert the name property to an integer
            UnaryFunction<Something, int> somethingsName2Int =
                Compose.FGx(convertToInt, somethingsPropName);
 
            ICollection<int> namesAsInts = new LinkedList<int>();
 
            Algorithm.Transform(NstlUtil.Begin(somethings), NstlUtil.End(somethings), 
                                NstlUtil.BackInserter(namesAsInts), somethingsName2Int);
        }
    }
}

UPDATED WIKI: Documentation Overview

AndyM — Thu, 15 Nov 2007 22:39:58 GMT

Documentation

UPDATED WIKI: Code Examples

AndyM — Mon, 21 May 2007 01:37:37 GMT

Examples

using System;
using System.Collections.Generic;
using NStl;
 
namespace NstlExamples
{
    class A { }
    class B : A { }
    class C : A { }
    class D : B { }
    class E { }
 
    class LessByName<T> : BinaryPredicate<T, T>
    {
        bool BinaryFunction<T, T, bool>.Execute(T lhs, T rhs)
        {
            return lhs.ToString().CompareTo(rhs.ToString()) < 0;
        }
    }
 
    class Program
    {
        static void Main()
        {
            Type[] tps1 = new Type[] { typeof(A), typeof(B), typeof(E) };
            Type[] tps2 = new Type[] { typeof(A), typeof(B), typeof(D) };
 
            Algorithm.Sort(NstlUtil.Begin(tps1), NstlUtil.End(tps1),
                           new LessByName<Type>());
            Algorithm.Sort(NstlUtil.Begin(tps2), NstlUtil.End(tps2),
                           new LessByName<Type>());
 
            List<Type> result = new List<Type>();
 
            Algorithm.SetIntersection(NstlUtil.Begin(tps1), NstlUtil.End(tps1),
                     NstlUtil.Begin(tps2), NstlUtil.End(tps2),
                     NstlUtil.BackInserter(result), new LessByName<Type>());
 
        }
    }
}

using System;
using System.Collections.Generic;
using NStl;
 
namespace NstlExamples
{
    class A { }
    class B : A { }
    class C : A { }
    class D : B { }
    class E { }
 
    class Program
    {
        static void Main()
        {
            BinaryFunction<Type, Type, bool> lessByName = 
                Functional.PtrFun<Type, Type, bool>(delegate(Type lhs, Type rhs){
                                        return lhs.ToString().CompareTo(rhs.ToString()) < 0;
                                                                                 });
            Type[] tps1 = new Type[] { typeof(A), typeof(B), typeof(E) };
            Type[] tps2 = new Type[] { typeof(A), typeof(B), typeof(D) };
 
            Algorithm.Sort(NstlUtil.Begin(tps1), NstlUtil.End(tps1), lessByName);
            Algorithm.Sort(NstlUtil.Begin(tps2), NstlUtil.End(tps2), lessByName);
 
            List<Type> result = new List<Type>();
            Algorithm.SetIntersection(NstlUtil.Begin(tps1), NstlUtil.End(tps1),
                     NstlUtil.Begin(tps2), NstlUtil.End(tps2),
                     NstlUtil.BackInserter(result), lessByName);
 
        }
    }
}

In the next example all values are extracted from a collection of key value pairs using the Algorithm.Transform algorithm and the Functional.Select2nd functor and inserted into a LinkedList.

using System.Collections.Generic;
using NStl;
 
namespace NstlExamples
{
    class Program
    {
        static void Main()
        {
            List<KeyValuePair<int, string>> int2str = new List<KeyValuePair<int, string>>();
 
            // … file the list
            for (int i = 0; i < 10; ++i)
                int2str.Add(new KeyValuePair<int, string>(i, i.ToString()));
 
            LinkedList<string> strs = new LinkedList<string>();
 
            Algorithm.Transform(NstlUtil.Begin(int2str), NstlUtil.End(int2str),
                NstlUtil.BackInserter(strs), Functional.Select2nd<int, string>());
 
        }
    }
}

In the next example the value of 10 is searched in a custom NSTL collection using an existing static function and the Algorithm.Find(...) linear search algorithm.

using System;
using NStl;
 
namespace NstlExamples
{
    class Program
    {
        static bool Equals10(int par)
        {
            return par == 10;
        }
        static void Main()
        {
            DList<int> ints = new DList<int>();
            for (int i = 0; i < 20; ++i)
                ints.PushBack(i);
 
            DList<int>.Iterator found = 
                Algorithm.FindIf(ints.Begin(), ints.End(), 
                            Functional.PtrFun<int, bool>(Equals10));
 
            if (!found.Equals(ints.End()))
                Console.WriteLine("Found value: " + found.Value.ToString());
        }
    }
}

The above sample can also be implemented without a custom function at all by using the provided binary function returned by the Functional.EqualTo<T>() factory method and a so called binder. The Functional.Bind2nd binder factory method returns an adapter object that will store the value of 10 and pass it as the second parameter into the EqualTo binary function for each item in the DList<T>.

using System;
using NStl;
 
namespace NstlExamples
{
    class Program
    {
        static void Main()
        {
            DList<int> ints = new DList<int>();
            for (int i = 0; i < 20; ++i)
                ints.PushBack(i);
 
            UnaryPredicate<int> equals10 = 
                Functional.Bind2nd(Functional.EqualTo<int>(), 10);
            
            DList<int>.Iterator found = 
                Algorithm.FindIf(ints.Begin(), ints.End(), equals10);
 
            if (!found.Equals(ints.End()))
                Console.WriteLine("Found value: " + found.Value.ToString());
        }
    }
}

using System.Collections.Generic;
using NStl;
 
namespace NstlExamples
{
    class Something
    {
        public Something(string name)
        {
            this.name = name;
        }
        public string Name
        {
            get { return name; }
        }
        private readonly string name;
    }
    class Program
    {
        static void Main()
        {
            IList<Something> somethings = new List<Something>();
            for (int i = 0; i < 20; ++i)
                somethings.Add(new Something(i.ToString()));
 
            // ... evaluate string property
            UnaryFunction<Something, string> somethingsPropName =
                Functional.PtrFun<Something, string>(delegate(Something s) { return s.Name; });
            
            // ... convert a string to an integer
            UnaryFunction<string, int> convertToInt =
                Functional.PtrFun<string, int>(delegate(string s) { return int.Parse(s); });
 
            // ... combine both functors to convert the name property to an integer
            UnaryFunction<Something, int> somethingsName2Int =
                Functional.ComposeFGx(convertToInt, somethingsPropName);
 
            ICollection<int> namesAsInts = new LinkedList<int>();
 
            Algorithm.Transform(NstlUtil.Begin(somethings), NstlUtil.End(somethings), 
                                NstlUtil.BackInserter(namesAsInts), somethingsName2Int);
        }
    }
}

UPDATED WIKI: Code Examples

AndyM — Mon, 21 May 2007 01:34:55 GMT

Examples

using System;
using System.Collections.Generic;
using NStl;
 
namespace NstlExamples
{
    class A { }
    class B : A { }
    class C : A { }
    class D : B { }
    class E { }
 
    class LessByName<T> : BinaryPredicate<T, T>
    {
        bool BinaryFunction<T, T, bool>.Execute(T lhs, T rhs)
        {
            return lhs.ToString().CompareTo(rhs.ToString()) < 0;
        }
    }
 
    class Program
    {
        static void Main()
        {
            Type[] tps1 = new Type[] { typeof(A), typeof(B), typeof(E) };
            Type[] tps2 = new Type[] { typeof(A), typeof(B), typeof(D) };
 
            Algorithm.Sort(NstlUtil.Begin(tps1), NstlUtil.End(tps1),
                           new LessByName<Type>());
            Algorithm.Sort(NstlUtil.Begin(tps2), NstlUtil.End(tps2),
                           new LessByName<Type>());
 
            List<Type> result = new List<Type>();
 
            Algorithm.SetIntersection(NstlUtil.Begin(tps1), NstlUtil.End(tps1),
                     NstlUtil.Begin(tps2), NstlUtil.End(tps2),
                     NstlUtil.BackInserter(result), new LessByName<Type>());
 
        }
    }
}

using System;
using System.Collections.Generic;
using NStl;
 
namespace NstlExamples
{
    class A { }
    class B : A { }
    class C : A { }
    class D : B { }
    class E { }
 
    class Program
    {
        static void Main()
        {
            BinaryFunction<Type, Type, bool> lessByName = 
                Functional.PtrFun<Type, Type, bool>(delegate(Type lhs, Type rhs){
                                        return lhs.ToString().CompareTo(rhs.ToString()) < 0;
                                                                                 });
            Type[] tps1 = new Type[] { typeof(A), typeof(B), typeof(E) };
            Type[] tps2 = new Type[] { typeof(A), typeof(B), typeof(D) };
 
            Algorithm.Sort(NstlUtil.Begin(tps1), NstlUtil.End(tps1), lessByName);
            Algorithm.Sort(NstlUtil.Begin(tps2), NstlUtil.End(tps2), lessByName);
 
            List<Type> result = new List<Type>();
            Algorithm.SetIntersection(NstlUtil.Begin(tps1), NstlUtil.End(tps1),
                     NstlUtil.Begin(tps2), NstlUtil.End(tps2),
                     NstlUtil.BackInserter(result), lessByName);
 
        }
    }
}

In the next example all values are extracted from a collection of key value pairs using the Algorithm.Transform algorithm and the Functional.Select2nd functor and insert them into a LinkedList.

using System.Collections.Generic;
using NStl;
 
namespace NstlExamples
{
    class Program
    {
        static void Main()
        {
            List<KeyValuePair<int, string>> int2str = new List<KeyValuePair<int, string>>();
 
            // … file the list
            for (int i = 0; i < 10; ++i)
                int2str.Add(new KeyValuePair<int, string>(i, i.ToString()));
 
            LinkedList<string> strs = new LinkedList<string>();
 
            Algorithm.Transform(NstlUtil.Begin(int2str), NstlUtil.End(int2str),
                NstlUtil.BackInserter(strs), Functional.Select2nd<int, string>());
 
        }
    }
}

In the next example the value of 10 is searched in a custom NSTL collection using an existing static function and the Algorithm.Find(...) linear search algorithm.

using System;
using NStl;
 
namespace NstlExamples
{
    class Program
    {
        static bool Equals10(int par)
        {
            return par == 10;
        }
        static void Main()
        {
            DList<int> ints = new DList<int>();
            for (int i = 0; i < 20; ++i)
                ints.PushBack(i);
 
            DList<int>.Iterator found = 
                Algorithm.FindIf(ints.Begin(), ints.End(), 
                            Functional.PtrFun<int, bool>(Equals10));
 
            if (!found.Equals(ints.End()))
                Console.WriteLine("Found value: " + found.Value.ToString());
        }
    }
}

using System;
using NStl;
 
namespace NstlExamples
{
    class Program
    {
        static void Main()
        {
            DList<int> ints = new DList<int>();
            for (int i = 0; i < 20; ++i)
                ints.PushBack(i);
 
            UnaryPredicate<int> equals10 = 
                Functional.Bind2nd(Functional.EqualTo<int>(), 10);
            
            DList<int>.Iterator found = 
                Algorithm.FindIf(ints.Begin(), ints.End(), equals10);
 
            if (!found.Equals(ints.End()))
                Console.WriteLine("Found value: " + found.Value.ToString());
        }
    }
}

using System.Collections.Generic;
using NStl;
 
namespace NstlExamples
{
    class Something
    {
        public Something(string name)
        {
            this.name = name;
        }
        public string Name
        {
            get { return name; }
        }
        private readonly string name;
    }
    class Program
    {
        static void Main()
        {
            IList<Something> somethings = new List<Something>();
            for (int i = 0; i < 20; ++i)
                somethings.Add(new Something(i.ToString()));
 
            // ... evaluate string property
            UnaryFunction<Something, string> somethingsPropName =
                Functional.PtrFun<Something, string>(delegate(Something s) { return s.Name; });
            
            // ... convert a string to an integer
            UnaryFunction<string, int> convertToInt =
                Functional.PtrFun<string, int>(delegate(string s) { return int.Parse(s); });
 
            // ... combine both functors to convert the name property to an integer
            UnaryFunction<Something, int> somethingsName2Int =
                Functional.ComposeFGx(convertToInt, somethingsPropName);
 
            ICollection<int> namesAsInts = new LinkedList<int>();
 
            Algorithm.Transform(NstlUtil.Begin(somethings), NstlUtil.End(somethings), 
                                NstlUtil.BackInserter(namesAsInts), somethingsName2Int);
        }
    }
}

UPDATED WIKI: Code Examples

AndyM — Mon, 21 May 2007 01:34:29 GMT

Examples

using System;
using System.Collections.Generic;
using NStl;
 
namespace NstlExamples
{
    class A { }
    class B : A { }
    class C : A { }
    class D : B { }
    class E { }
 
    class LessByName<T> : BinaryPredicate<T, T>
    {
        bool BinaryFunction<T, T, bool>.Execute(T lhs, T rhs)
        {
            return lhs.ToString().CompareTo(rhs.ToString()) < 0;
        }
    }
 
    class Program
    {
        static void Main()
        {
            Type[] tps1 = new Type[] { typeof(A), typeof(B), typeof(E) };
            Type[] tps2 = new Type[] { typeof(A), typeof(B), typeof(D) };
 
            Algorithm.Sort(NstlUtil.Begin(tps1), NstlUtil.End(tps1),
                           new LessByName<Type>());
            Algorithm.Sort(NstlUtil.Begin(tps2), NstlUtil.End(tps2),
                           new LessByName<Type>());
 
            List<Type> result = new List<Type>();
 
            Algorithm.SetIntersection(NstlUtil.Begin(tps1), NstlUtil.End(tps1),
                     NstlUtil.Begin(tps2), NstlUtil.End(tps2),
                     NstlUtil.BackInserter(result), new LessByName<Type>());
 
        }
    }
}

using System;
using System.Collections.Generic;
using NStl;
 
namespace NstlExamples
{
    class A { }
    class B : A { }
    class C : A { }
    class D : B { }
    class E { }
 
    class Program
    {
        static void Main()
        {
            BinaryFunction<Type, Type, bool> lessByName = 
                Functional.PtrFun<Type, Type, bool>(delegate(Type lhs, Type rhs){
                                        return lhs.ToString().CompareTo(rhs.ToString()) < 0;
                                                                                 });
            Type[] tps1 = new Type[] { typeof(A), typeof(B), typeof(E) };
            Type[] tps2 = new Type[] { typeof(A), typeof(B), typeof(D) };
 
            Algorithm.Sort(NstlUtil.Begin(tps1), NstlUtil.End(tps1), lessByName);
            Algorithm.Sort(NstlUtil.Begin(tps2), NstlUtil.End(tps2), lessByName);
 
            List<Type> result = new List<Type>();
            Algorithm.SetIntersection(NstlUtil.Begin(tps1), NstlUtil.End(tps1),
                     NstlUtil.Begin(tps2), NstlUtil.End(tps2),
                     NstlUtil.BackInserter(result), lessByName);
 
        }
    }
}

In the next example all values are extracted from a collection of key value pairs using the Algorithm.Transform algorithm and the Functional.Select2nd functor and insert them into a LinkedList.

using System.Collections.Generic;
using NStl;
 
namespace NstlExamples
{
    class Program
    {
        static void Main()
        {
            List<KeyValuePair<int, string>> int2str = new List<KeyValuePair<int, string>>();
 
            // … file the list
            for (int i = 0; i < 10; ++i)
                int2str.Add(new KeyValuePair<int, string>(i, i.ToString()));
 
            LinkedList<string> strs = new LinkedList<string>();
 
            Algorithm.Transform(NstlUtil.Begin(int2str), NstlUtil.End(int2str),
                NstlUtil.BackInserter(strs), Functional.Select2nd<int, string>());
 
        }
    }
}

In the next example the value of 10 is searched in a custom NSTL collection using an existing static function and the Algorithm.Find(...) linear search algorithm.

using System;
using NStl;
 
namespace NstlExamples
{
    class Program
    {
        static bool Equals10(int par)
        {
            return par == 10;
        }
        static void Main()
        {
            DList<int> ints = new DList<int>();
            for (int i = 0; i < 20; ++i)
                ints.PushBack(i);
 
            DList<int>.Iterator found = 
                Algorithm.FindIf(ints.Begin(), ints.End(), 
                            Functional.PtrFun<int, bool>(Equals10));
 
            if (!found.Equals(ints.End()))
                Console.WriteLine("Found value: " + found.Value.ToString());
        }
    }
}

using System;
using NStl;
 
namespace NstlExamples
{
    class Program
    {
        static void Main()
        {
            DList<int> ints = new DList<int>();
            for (int i = 0; i < 20; ++i)
                ints.PushBack(i);
 
            UnaryPredicate<int> equals10 = 
                Functional.Bind2nd(Functional.EqualTo<int>(), 10);
            
            DList<int>.Iterator found = 
                Algorithm.FindIf(ints.Begin(), ints.End(), equals10);
 
            if (!found.Equals(ints.End()))
                Console.WriteLine("Found value: " + found.Value.ToString());
        }
    }
}

using System.Collections.Generic;
using NStl;
 
namespace NstlExamples
{
    class Something
    {
        public Something(string name)
        {
            this.name = name;
        }
        public string Name
        {
            get { return name; }
        }
        private readonly string name;
    }
    class Program
    {
        static void Main()
        {
            IList<Something> somethings = new List<Something>();
            for (int i = 0; i < 20; ++i)
                somethings.Add(new Something(i.ToString()));
 
            // ... evaluate string property
            UnaryFunction<Something, string> somethingsPropName =
                Functional.PtrFun<Something, string>(delegate(Something s) { return s.Name; });
            
            // ... convert a string to an integer
            UnaryFunction<string, int> convertToInt =
                Functional.PtrFun<string, int>(delegate(string s) { return int.Parse(s); });
 
            // ... combine both functors to convert the name property to an integer
            UnaryFunction<Something, int> somethingsName2Int =
                Functional.ComposeFGx(convertToInt, somethingsPropName);
 
            ICollection<int> namesAsInts = new LinkedList<int>();
 
            Algorithm.Transform(NstlUtil.Begin(somethings), NstlUtil.End(somethings), 
                                NstlUtil.BackInserter(namesAsInts), somethingsName2Int);
        }
    }
}

UPDATED WIKI: Documentation Overview

AndyM — Sun, 04 Mar 2007 20:58:46 GMT

Documentation