Enhanced C#
Language of your choice: library documentation

Documentation moved to ecsharp.net

GitHub doesn't support HTTP redirects, so you'll be redirected in 3 seconds.

 All Classes Namespaces Functions Variables Enumerations Enumerator Properties Events Pages
Class Hierarchy
This inheritance list is sorted roughly, but not completely, alphabetically:
[detail level 1234567]
 CLoyc.Collections.Impl.AListNode< K, T >Internal implementation class. Base class for tree nodes in a list class derived from AListBase{T}. These nodes basically form an in-memory B+tree, not necessarily sorted, but structured like a B+tree. That means there are two node types: leaf and inner (internal) nodes.
 CLoyc.Collections.Impl.AListTreeObserverExtHelper methods for IAListTreeObserver{K,T}.
 CLoyc.Collections.ArrayOf4< T >
 CLoyc.MiniTest.AssertThe Assert class contains a collection of static methods that mirror the most common assertions used in NUnit.
 CBaseDictionary< K, V >
 CBaseILexer< ICharSource, Token >
 CLoyc.Syntax.Lexing.BaseLexerAlias for BaseLexer{C} where C is ICharSource.
 CLoyc.Syntax.BaseParser< Token, MatchType >An base class designed for parsers that use LLLPG (Loyc LL(k) Parser Generator). Note: this is the old (harder to use) base class design. You should use BaseParserForList{Token,MatchType} instead.
 CLoyc.Utilities.BloomFilterM64K2A bloom filter for very small sets.
 CLoyc.Geometry.BoundingBoxExtExtension methods for BoundingBox{T}.
 CLoyc.Geometry.BoundingBoxMathMath and extension methods for BoundingBox{T}.
 CLeMP.Prelude.BuiltinMacrosDefines noMacro(...) for suppressing macro expansion and import macros your.namespace.name as an alias for #importMacros(your.namespace.name).
 CLoyc.Collections.CGContains global functions of Loyc.Collections that don't belong in any specific class.
 CLoyc.CheckParamHelper methods for checking argument values that throw exceptions when an argument value is not acceptable.
 CLoyc.Utilities.CoExtension methods for Co{T}.
 CLoyc.Syntax.CodeSymbolsA list of common symbols that have special meaning somewhere in Loyc or EC#: operators, built-in data types, keywords, trivia, etc.
 CLoyc.Collections.CollectionDebugView< T >This helper class gives a nice view of a custom collection within the debugger.
 CLeMP.CompilerA class that helps you invoke MacroProcessor on on a set of source files, given a set of command-line options.
 CLoyc.Collections.CPTrie< T >Compact patricia tree class that stores keys as byte arrays. This class is intended to be use as a base class; a derived class can give meaning to the byte arrays, e.g. CPStringTrie encodes strings into byte arrays so they can be placed in the trie.
 CLoyc.Collections.DictionaryDebugView< K, V >Workaround for a limitation of the debugger: it doesn't support CollectionDebugView{T} when T is KeyValuePair{K,V}. This class is identical, except that T is replaced with KeyValuePair{K,V}.
 CLoyc.Collections.DictionaryExtExtension methods for Dictionary{K,V} and IDictionary{K,V}.
 CDList< Token >
 CLoyc.Ecs.EcsNodePrinterPrints a Loyc tree to EC# source code.
 CLoyc.Ecs.EcsPrecedenceContains Precedence objects that represent the precedence rules of EC#.
 CLoyc.Ecs.EcsValidatorsA class filled with methods for checking whether a node has the correct LNode.Name and structure. For example, IsPropertyDefinition(node) checks whether node meets the requirements for being a property definition, such as having a Name equal to #property, and having name and return value that are complex identifiers.
 CLoyc.Collections.EmptyArray< T >EmptyArray{T}.Value lets you avoid allocating an empty array on the heap.
 CLoyc.Collections.Impl.AListInnerBase< K, T >.Entry
 CLoyc.Collections.Impl.SparseAListLeaf< T >.Entry
 CLoyc.Collections.EnumerableExtAdditional extension methods for IEnumerable{T}, beyond what LINQ provides.
 CEqualityComparer< T >
 CLoyc.ExceptionExtExtension methods for exceptions.
 CLoyc.EzStopwatchA wrapper around Stopwatch with a more convenient interface, currently oriented around measuring milliseconds (TODO: increase similarity to Stopwatch)
 CLoyc.GContains global functions that don't belong in any specific class.
 CLoyc.Utilities.GoInterfaceMainly for internal use by the other GoInterface classes.
 CLoyc.Utilities.GoInterface< Interface >GoInterface<Interface> creates wrappers around objects of your choosing that implement the specified Interface, forwarding calls to methods in the wrapped object. It is inspired by the duck-typed interfaces in the Go programming language.
 CLoyc.Utilities.GoInterface< Interface, T >GoInterface<Interface,T> creates a wrapper that implements the specified Interface, forwarding calls to methods in T. It is inspired by the duck-typed interfaces in the Go programming language.
 CLoyc.GSymbolThis class produces global symbols.
 CLoyc.Collections.IAdd< in T >An interface for depositing items. Includes only an Add(T) method.
 CIAdditionGroup< Vector3< T >>
 CIAdditionGroup< Vector< T >>
 CLoyc.Collections.Impl.IAListTreeObserver< K, T >An interface that is called to notify observers when items or nodes in the tree of a class derived from AListBase{K,T} (e.g. AList or BList) are added or removed.
 CIAutoCreatePool< string, Symbol >
 CLoyc.Collections.IBinumerable< T >Interface for a collection that can return IBinumerator{T}s pointing to the beginning and end of the collection.
 CIBRange< uchar >
 CLoyc.ICloneable< out T >Interface for types that can duplicate themselves.
 CICollection< KeyValuePair< K, V >>
 CICollection< Num >
 CICollection< Symbol >
 CICollection< T >
 CICollection< TKey >
 CICollection< TValue >
 CIComparable< FPI16 >
 CIComparable< FPI23 >
 CIComparable< FPI8 >
 CIComparable< FPL16 >
 CIComparable< FPL32 >
 CIComparable< IntRange >
 CIComparable< MacroInfo >
 CIComparable< Pair< T1, T2 >>
 CIComparable< Symbol >
 CIComparer< T >
 CLoyc.Math.IConvertTo< T >Provides methods for converting common numeric types to another numeric type "T".
 CIDictionary< byte[], TValue >
 CIDictionary< int, TValue >
 CIDictionary< K, V >
 CIDictionary< K1, K2 >
 CIDictionary< long, TValue >
 CIDictionary< string, TValue >
 CIDictionary< Symbol, ValueT >
 CIDictionary< TKey, TValue >
 CIEnumerable< SymbolE >
 CIEnumerable< T >
 CIEnumerable< TKey >
 CIEnumerable< TValue >
 CIEnumerator< T >
 CIEnumerator< Token >
 CIEnumeratorFrame< DescendantsFrame, LNode >
 CLoyc.Collections.Impl.IEnumeratorFrame< Frame, T >Helper interface for NestedEnumerator{Frame, T}.
 CIEqualityComparer< KeyValuePair< K, V >>
 CIEqualityComparer< LNode >
 CIEqualityComparer< object >
 CIEqualityComparer< T >
 CIEquatable< AndPred >
 CIEquatable< FPI16 >
 CIEquatable< FPI23 >
 CIEquatable< FPI8 >
 CIEquatable< FPL16 >
 CIEquatable< FPL32 >
 CIEquatable< GrammarPos >
 CIEquatable< IntRange >
 CIEquatable< IntSet >
 CIEquatable< InvertibleSet< T >>
 CIEquatable< IPGTerminalSet >
 CIEquatable< LNode >
 CIEquatable< MSet< T >>
 CIEquatable< NegList< T >>
 CIEquatable< NegListSource< T >>
 CIEquatable< Pair< T1, T2 >>
 CIEquatable< Precedence >
 CIEquatable< ReversedList< T >>
 CIEquatable< Set< T >>
 CIEquatable< Symbol >
 CIEquatable< Token >
 CIEquatable< TokenTree >
 CIEquatable< UString >
 CLoyc.Math.IExp< T >Provides power, logarithm, raise-e-to-exponent (Exp) and logarithm-of-e (Log) operations.
 CLoyc.Utilities.IGoInterfaceWrapperAll GoInterface wrappers implement this interface.
 CLoyc.IHasLocationThis interface allows an object to declare its "location". It is used by MessageSink.LocationString, which helps convert the "context" of a message into a string.
 CLoyc.Math.IHasRoot< T >Provides the Sqrt operation and its inverse, Square.
 CLoyc.IHasValue< out T >Interface for things that have a Value property.
 CLoyc.Math.IIncrementer< T >Provides increment, decrement, and next/previous-representable- value operations.
 CLoyc.Syntax.IIndexToLineContains IndexToLine method.
 CLoyc.Collections.IIsEmptyHolds the IsEmpty property that tells you if a collection is empty.
 CIList< T >
 CIListSource< char >
 CIListSource< IntRange >
 CIListSource< IToken< int >>
 CIListSource< Token >
 CLoyc.Syntax.Lexing.ILllpgApi< Token, MatchType, LaType >For reference purposes, this interface is a list of the non-static methods that LLLPG expects to be able to call when it is generating code. LLLPG does not actually need lexers and parsers to implement this interface; they simply need to implement the same set of methods as this interface contains.
 CILllpgApi< Token, MatchType, MatchType >
 CLoyc.Syntax.ILNodeVisitorInterface for people that want to implement the visitor pattern with LNode. If your visitor does not need a base class, use LNodeVisitor as the base class.
 CLoyc.IMessageSinkA general-purpose interface for a class that accepts formatted messages with context information.
 CLoyc.Syntax.Lexing.IndentTokenGeneratorA preprocessor usually inserted between the lexer and parser that inserts "indent", "dedent", and "end-of-line" tokens at appropriate places in a token stream.
 CLoyc.Syntax.IndexPositionMapperSynonym for IndexPositionMapper<IListSource<char>>.
 CINegListSource< LNode >
 CLoyc.Geometry.INewPoint3< Point, T >This interface exists to work around a limitation of C#; see IPoint{T} and IPoint3{T}.
 CLoyc.Geometry.INewPoint< Point, T >This interface exists to work around a limitation of C#; see IPoint{T}.
 CLoyc.Geometry.INewRectangle3< Rect, T >This interface exists to work around a limitation of C#; see IRectangle3{T}.
 CLoyc.Geometry.INewRectangle< Rect, T >This interface exists to work around a limitation of C#; see IRectangle{T}.
 CLoyc.Syntax.Les.INodePrinterWriterThis interface is implemented by helper objects that handle the low-level details of node printing. It is used by LesNodePrinter.
 CLoyc.Collections.INotifyListChanging< T >Encapsulates the ListChanging event that notifies listeners of dynamic changes to an indexed list, such as when items get added and removed or the whole list is refreshed.
 CSystem.Windows.Forms.InputBoxThis static class contains methods named Show() to display a dialog box with an input field, similar in appearance to the one in Visual Basic. The Show() method returns null if the user clicks Cancel, and non-null if the user clicks OK.
 CLeMP.InputOutputFor LeMP: an input file plus per-file options (input and output language) and output code.
 CLoyc.Collections.Impl.InternalListContains static methods to help manage raw arrays with even less overhead than InternalList{T}.
 CLoyc.Collections.Impl.InternalSetStatsStatistics returned from InternalSet{T}.CountMemory.
 CInvertibleSet< LNode >
 CLoyc.Math.IOneProvider< T >Provides the value of "one" for type T.
 CLoyc.Syntax.IParsingServiceAn interface that encapsulates the lexer, parser, and printer of a programming language, or a non-programming language that can be represented by Loyc trees.
 CLoyc.LLParserGenerator.IPGCodeGenHelperA class that implements this interface will generate small bits of code that the parser generator will use. The default implementation is IntStreamCodeGenHelper. To install a new code generator, set the LLParserGenerator.CodeGenHelper property or supply the generator in the constructor of LLParserGenerator.
 CLoyc.Geometry.IPointReader< T >Interface for reading the coordinates of a 2D point.
 CLoyc.Collections.IPop< T >Represents a collection that produces a sequence of items, and can return the next item without popping it (the Peek operation).
 CLoyc.Collections.IPush< T >Represents a collection that accepts a sequence of items.
 CIReadOnlyCollection< KeyValuePair< K, V >>
 CIReadOnlyCollection< Symbol >
 CIReadOnlyCollection< T >
 CIReadOnlyCollection< TKey >
 CIReadOnlyCollection< TValue >
 CIReadOnlyDictionary< byte[], TValue >
 CIReadOnlyDictionary< int, TValue >
 CIReadOnlyDictionary< K, BMultiMap< K, V >.ValueList >
 CIReadOnlyDictionary< K, V >
 CIReadOnlyDictionary< K1, K2 >
 CIReadOnlyDictionary< long, TValue >
 CIReadOnlyDictionary< Symbol, ValueT >
 CIReadOnlyDictionary< TKey, TValue >
 CIReadOnlyList< Num >
 CIReadOnlyList< T >
 CLoyc.IReferenceComparableThis is a tag which indicates that objects of this type are unique; specifically, any two different objects that implement this interface are always unequal, and one object is equal only to itself.
 CISet< T >
 CLoyc.Collections.ISetOperations< in T, in InSetT, out OutSetT >
 CLoyc.Collections.ISetTests< SetT >Set testing operations.
 CLoyc.Syntax.Lexing.ISimpleTokenAlias for ISimpleToken{int}.
 CLoyc.Collections.ISinkArray< T >Represents a write-only array.
 CLoyc.Geometry.ISizeReader< T >Interface for reading the size of a 2D object.
 CLoyc.ITags< T >Interface for an object that can have "tags" attached, which are arbitrary objects reached through a key Symbol.
 CLoyc.Math.ITrigonometry< T >Provides trigonometry operations.
 CLoyc.Math.IZeroProvider< T >Provides the value of "zero" for type T.
 CLoyc.Collections.Impl.KeyWalkerInternal implementation class. Represents a pointer to a location within a byte array.
 CLoyc.LLParserGenerator.LLParserGenerator.KthSetRepresents the possible interpretations of a single input character, in terms of transitions in the grammar.
 CLoyc.Collections.LCExtExtension methods for Loyc Collection interfaces (such as IListSource{T}) and for Loyc Collection adapters (such as AsReadOnly{T}, which returns a CollectionAsReadOnly{T} adapter.)
 CLoyc.Collections.LCInterfacesThis class contains extension methods that are provided as part of various Loyc.Collections interfaces. For example, it provides methods such as IndexOf(), Contains() and CopyTo(), that the traditional ICollection{T} and IList{T} interfaces require the author to write himself.
 CLoyc.Syntax.Les.LesNodePrinterPrints a Loyc tree in LES (Loyc Expression Syntax) format.
 CLoyc.Syntax.Les.LesPrecedenceContains Precedence objects that represent the precedence levels of LES.
 CLoyc.Syntax.Les.LesPrecedenceMapThis class's main job is to maintain a table of Precedence values for LES operators. When you ask about a new operator, its precedence is cached for future reference.
 CLoyc.Syntax.Lexing.LexerSourceA synonym for LexerSource{C} where C is ICharSource.
 CLoyc.Syntax.LineAndColHolds a line number (Line) and a position in the line (PosInLine). This class isn't really needed in Loyc but is separated from SourcePos in case anyone might want position without a filename.
 CLoyc.Geometry.LineMathContains algorithms that operate on lines.
 CLoyc.Syntax.LineRemapperA small helper class for languages such as C# and C++ that permit the locations reported by error messages to be remapped. This class stores and applies such commands (#line in C#/C++)
 CLoyc.Geometry.LineSegment3< T >Holds a 3D line segment.
 CLoyc.Geometry.LineSegment< T >Holds a 2D line segment.
 CLoyc.Collections.LinqToCollectionsWork in progress. This class will enhance LINQ-to-Objects with type-preserving and/or higher-performance extension methods.
 CLoyc.Collections.ListChangeInfo< T >Contains information about how a collection is about to change.
 CLoyc.Collections.ListExtExtension methods and helper methods for List{T}, IList{T}, IReadOnlyList{T}, arrays, IListSource{T}, and for related mutable interfaces such as IArray{T}.
 CListSourceBase< char >
 CListSourceBase< NegList< T >>
 CListSourceBase< NegListSource< T >>
 CListSourceBase< TOut >
 CListSourceBase< TResult >
 CLoyc.Collections.ListSourceDebugView< T >This helper class gives a nice view of a custom collection within the debugger.
 CLoyc.LLParserGenerator.LLParserGeneratorEncapsulates LLLPG, the Loyc LL Parser Generator, which generates LL(k) recursive-descent parsers.
 CLoyc.LLParserGenerator.LlpgGeneralTestsBaseShared base class for "full-stack" LLLPG tests that use LeMP, the Ecs parser, and LLLPG macros in addition to the core engine.
 CLoyc.LLParserGenerator.LlpgHelpersHelper methods for making LLLPG grammar nodes. Used by LlpgCoreTests.
 CLoyc.Syntax.LNodeExtStandard extension methods for LNode.
 CLoyc.Syntax.LNodeFactoryContains helper methods for creating LNodes. An LNodeFactory holds a reference to the current source file (File) so that it does not need to be repeated every time you create a node.
 CLoyc.LocalizeLocalize is a global hook into which a string-mapping localizer can be installed. It is designed to make internationalization exceptionally easy for developers. TODO: expand I18N features based on Mozilla's L20N.
 CLeMP.MacroContextStandard extension methods for IMacroContext.
 CLeMP.MacroProcessorEncapsulates the LeMP engine, a simple LISP-style macro processor, suitable for running LLLPG and other lexical macros.
 CLoyc.LLPG.MacrosMacros for using LLLPG in LeMP.
 CLoyc.Math.Math128Contains methods for manipulating 128-bit numbers, multiplying 64-bit numbers to produce 128-bit results, and dividing 128-bit numbers by 64-bit numbers.
 CLoyc.Math.MathExProvides additional math functions that are not available in System.Math.
 CLoyc.Math.MathExtensionsStandard extension methods for generic math interfaces such as IOrdered{T}.
 CLoyc.Math.Maths< T >This class helps generic code to perform calculations on numbers of unknown type, by providing access to various math interfaces.
 CLoyc.MemoizedTypeName.NET Framework reflection doesn't offer complete type names for generic types such as "List&lt;int>" (the Type.Name value of that class is "List`1"). Get fills in the gap, and also saves the computed name for fast repeated lookups.
 CLoyc.MemoizedTypeName< T >MemoizedTypeName<T>.Get() is an alternative to MemoizedTypeName.Get(typeof(T)).
 CLoyc.MessageSinkHolds the default message sink for this thread (Current), Symbols for the common message types, such as Warning and Error, and default instances of ConsoleMessageSink, TraceMessageSink and NullMessageSink.
 CLoyc.NoValueNoValue.Value is meant to be used as the value of a property that has "no value", meaning no value is assigned or that the property is meaningless at the current time or in the current context.
 CLoyc.PairPair.Create(a, b) is a helper method for making pairs.
 CLoyc.Syntax.ParsingServiceExtension methods for IParsingService.
 CLoyc.LLParserGenerator.PGTerminalSetExtension methods for IPGTerminalSet.
 CLoyc.Geometry.PointExtContains methods for manipulating points in generic code.
 CLoyc.Geometry.PointMathMath and extension methods for Point{T}.
 CLoyc.Geometry.PolygonMathContains useful basic polygon algorithms: hit testing, area calculation, orientation detection.
 CLoyc.LLParserGenerator.PredAAnalytic predicate: a simpler form of predicate used for prediction analysis.
 CLoyc.LLParserGenerator.PredVisitorBase class for implementing a visitor that examines a tree of LLLPG Predicates.
 CLoyc.LLParserGenerator.ProgramEntry point of LLLPG.exe, with QuickRun() method to help invoke LLLPG programmatically.
 CLoyc.Collections.RangeExtExtension/helper methods for ranges.
 CReadOnlyCollectionBase< TOut >
 CLoyc.Geometry.Rectangle3ExtContains methods to manipulate rectangles.
 CLoyc.Geometry.RectangleExtContains methods to manipulate rectangles.
 CLoyc.LLParserGenerator.RuleRepresents an LLLPG rule, which is a Predicate plus a Name and optional attributes (e.g. token, private, etc.).
 CLoyc.MiniTest.RunTestsSearches for test methods and runs them, printing the name of each test to the console followed by errors (if any) produced by the test.
 CLoyc.Collections.Impl.SCellStandard cell, used to encode keys in a CPSNode
 CLoyc.Collections.SimpleCache< T >A cache designed to save memory by sharing instances of identical strings and other immutable objects.
 CLoyc.Utilities.SimpleTimerA fast, simple timer class with a more convenient interface than System.Diagnostics.Stopwatch. Its resolution is typically 10-16 ms on desktop Windows systems.
 CLoyc.Syntax.SourceRangeHolds a reference to a source file (ISourceFile<char>) and the beginning and end indices of a range in that file.
 CLoyc.Utilities.StatisticA lightweight class to help you compute the minimum, maximum, average and standard deviation of a set of values. Call Clear(), then Add(each value); you can compute the average and standard deviation at any time by calling Avg() and StdDeviation().
 CLoyc.StringExtExtension methods for strings, such as SplitAt, Left, Right, Format and USlice.
 CLoyc.Threading.ThreadExCreates and controls a thread, and fills in a gap in the .NET framework by propagating thread-local variables from parent to child threads, and by providing a ThreadStarting event.
 CLoyc.Threading.ThreadLocalVariableBaseWhen used with ThreadEx, implementing this base class allows you to be notified when a child thread is created or terminates.
 CLoyc.Threading.TinyReaderWriterLockA fast, tiny 4-byte lock to support multiple readers or a single writer. Designed for low-contention, high-performance scenarios where reading is common and writing is rare.
 CLoyc.Syntax.Les.TokenExtProvides the Type() extension method required by Token and the ToString(Token) method to express an LES token as a string, for tokens that contain sufficient information to do so.
 CLoyc.Ecs.Parser.TokenExtProvides the Type() extension method required by Token and the ToString(Token) method to express an EC# token as a string, for tokens that contain sufficient information to do so.
 CLoyc.Triplet< T1, T2, T3 >A tuple of three values (A, B and C) in a struct.
 CLoyc.TypeExtExtension methods for Type.
 CLoyc.Utilities.UGContains global functions of Loyc.Utilities that don't belong in any specific class.
 CLoyc.ValueComparer< T >You'd think the .NET framework would have a built-in method–even a CIL opcode–to bitwise-compare two values. Not supporting bitwise compare is, in my opinion, one of several mind-bogglingly dumb decisions in the CLR. Instead, all you can do is call ValueComparer.Default.Equals(a, b).
 CLoyc.Geometry.VectorExtExtension methods for vectors. TODO: reconsider distribution of methods between this class and PointMath in Loyc.Utilities.
 CLoyc.Collections.VListBlock< T >VListBlock implements the core functionality of FVList, VList, FWList and WList. It is not intended to be used directly.
 CLoyc.void.Value represents the sole value of System.Void (called "void" in C#).
 CLoyc.WeakReferenceExtThe new WeakReference{T} type in .NET 4.5 removes the Target and IsAlive properties. These extension methods restore that traditional functionality, making it easier to transition from the old WeakReference to the new one.
 CLoyc.Syntax.Lexing.WhitespaceFilterAlias for WhitespaceFilter{Token}
 CLoyc.Syntax.Lexing.WhitespaceTagWhitespaceTag.Value can be used as the Token.Value of whitespace tokens, to make whitespace easy to filter out.
 CWListProtected< KeyValuePair< Symbol, ValueT >>
 CLoyc.Collections.WListProtected< T >WList implementation in which the WList operations are only accessible to a derived class.
 CLoyc.WrapperBase< T >Abstract class that helps you implement wrappers by automatically forwarding calls to Equals(), GetHashCode() and ToString().