JetBrains.Platform.Core

Implementation of based on

Implementation of that only allows to take an upgradable read lock on a dedicated thread.

Support upgrade on provided thread only

Rather ineffective on modification (memory traffic O(n^2)), but no overhead on reading

Written on the main thread, read on any thread, sync not required.

If we're running idle tasks, tells if we're OK to run more. Calls if avail, otherwise OK.

Calls on the current one, returns whether present and successful (= do not call default impl).

Callback functor to give out to driver on .

Undoer for , called upon lifetime termination or on a fault.

External idle processing driver callbacks.

External idle driver verdict.

The driver is ready to provide OnIdle callbacks.

The driver is temporary unavailable.

The driver gone down and should be switched off.

Idle processing results, values must map to FDoIdle return values.

Don't call callback until you're asked again with .

Call once more as soon as the idle state is achieved again.

User handler to install the IDLE processing external driver. By default, IDLE tasks are scheduled with an idle priority level of the system Dispatcher. Installing an external driver replaces this with a custom implementation. An example of the custom implementation is the Visual Studio FDoIdle callback. This handler gets installed with , only one at a time.

calls this on the external idle driver while processing the idle tasks on the queue, asks whether it's OK to continue doing so, or the idle state might not hold anymore. Maps to IMsoComponentManager::FContinueIdle.

will be called when implementation thinks it should ping the underlying scheduler (not per every scheduled event, but with throttling) to schedule the idle processing. After that, the driver should call the callback it has been given upon registration when it thinks the idle state has been reached, and continue doing so as long as it gets . After the idle events have been processed by this callback with a successful return value, it is guaranteed that the driver will be called for anew at least once the next time new idle events are added.

When implemented on , allows overriding its operation for scheduling idle tasks ( level). See as a reference implementation.

See , .

Given you when you register a new external driver with . Call when you detect the idle time after you've been requested for that with and until this delegate returns .

Given you when you register a new external driver with . Call when the external idle driver becomes temporary unavailable.

Custom message translators that could be registered on the fly, and will be executed before the standard message procesing.

Base empty marker interface for all interfaces which might be implemented as traits on an object implementing , for discoverability. That interface itself also derives from it, for discoverability.

An marker interface telling that this transport implementation is operating over Windows messages, and we can expect its nice interoperability with them.

In case transport impl has variance, gives the current situation.

Reflection helpers cache for reading Avalon Dispatcher flag which tells if it's a bad moment to be pumping.

Force set undesired pumping behaviour for the scope

Says what current dispatcher thinks on whether it's a good moment to pump messages. For example, Avalon's Dispatcher might have its own internal flag when it things it's a bad idea, and if its transport HWND by chance receives a message at such a moment, it would throw. The exception itself isn't a problem since we would catch it in the pump, but the message itself would be lost, causing part of Avalon functionality to break (potentially permanently).

Pump if and are hidden

The number of messages actually pumped, or , or

Allows to schedule async tasks execution on a Dispatcher thread. Get from ..

Wait this much before running reliability loop, also the quant of the waiting in the loop, so shan't be big.

To avoid flooding the underlying transport with pings when main thread is genuinely stuck and not processing messages, keep increasing intervals.

Called by owner to request invocation over transport. Adds reliability by making sure it's called even if the underlying transport loses an invocation or two (and it MIGHT based on the contract).

Called from actual transport.

Gives access to actual transport (and its extra interfaces!) WARNING: this value MIGHT change over time if the underlying transport is replaced, do not cache.

Heart of this reliability layer. When we think a transport invocation is en route, tracks that it reaches invocation on home thread sooner or later. Posts more invocation requests on the underlying transport from time to time. Strategy: do not wait too long, but do not flood the transport since its queue is limited (e.g. thousands on NT Windows Message Queue, etc). Starts rolling when gevent fires outgoing, and keeps its callback busy until this en-route message arrives. For next messages, it's roll over the gevent again.

When an invocation is requested, we want to start an async reliability tracking function, but not run them in parallel if multiple invocations pass quickly => rather than introduce synchronization for them, just use a gevent. The starts rolling when outgoing fires.

Protects r/w of .

NULL when there's no pending underlying transport invocation. If there is, the moment when it's been last requested.

For dispatcher transports based on WM, implements the handling.

Custom message translators that could be registered on the fly, and will be executed before the standard message procesing.

The collection is copy-on-write.

Pre-processes a message before it's dispatched the regular way, in case the message gets into our message loop.

Windows message record. Whether the message has been consumed by the pre-processing code, and should not be dispatched the regular way or given to following pre-processors.

Reference impl (holding former members) for support of on , if it's ever decided to implement it there.

Main thread modification only. Any thread access. backend.

See , .

Custom-registered message for our transport. lParam: of posting the message. wParam: if reposting for shy scheduling, tracks the number of reposts.

This counter is incremented every time a normal-priority action is reposted

This counter is incremented every time a reposted normal-priority action is processed. If there are no pending reposted normal-priority actions, it should be equal to

Home thread access only. Immutable to be safe from nested modifications while iterating and calling handlers.

Slots by , NULL means request not pending for this priority, non-NULL means it's pending.

Implements a custom message pump for pumping all of the messages currently in the queue.

The number of messages pumped.

Sends the message over transport! Optionally, combines with putting new action on the queue (because it also holds the generation number).

IF message is being reposted for shy scheduling, increases with every repost to avoid infinite loops. Goes into wParam. If succeeded.

Just as a Windows message.

Try to let everyone execute ahead of us, smth like "Idle processing". Enum value: priorities of that and below go with this strategy.

Try to jump on ASAP. Initially working as normal, might consider a message hook to hop on anyone's message processing. Enum value: priorities of that and above go with this strategy.

Creates platform-specific, thread-bound implementation of the entity actually deferring the execution.

The underlying transport for which does not interact with any OS-shared media for scheduling (such as Windows Messages on Windows, epoll on Linux, etc), but keeps its own queue. As a result, • Dispatcher Actions would be processed ONLY if you run the message loop with 's Run* family of the methods on this thread. Any other message loops, e.g. modal dialogs, would freeze the Dispatcher. • 's Run* methods would ONLY process its own actions, and not any UI operations. If you use this to run a message loop in a UI App, its UI will freeze. So this implementation is only suitable for homogeneous applications (no code trying to use any other dispatching methods) without any UI. UI applications require OS-aware dispatcher integration.

Home thread access only. Immutable to be safe from nested modifications while iterating and calling handlers.

Slots by , NULL means request not pending for this priority, non-NULL means it's pending.

Initializes the instance.

Optional. Not needed in production. If for technical reasons you need more than one instance per thread, such as in tests, so that they were not equal, use this parameter.

Waiting for event to be SET

true if event was SET, false if timeout expired

Waiting for event to be SET or new message is appeared in queue

true if event was SET, false if timeout expired, null if new message is appeared in queue

Waiting for event to be SET

true if event was SET, false if new message is appeared in queue

The same as . but allows null value for parameter. . may return null when . is true

Optional (for uniform code with cases when we got no captured context). The Execution Context to restore — but for its , we leave it as set on this thread (unless overridden), because the original sync context might be coming from another thread with another scheduling strategy. The function to execute under the restored execution context. Optional. Cheat! Sometimes we need to run stuff under our own synchronization context. Rather than setting and restoring it explicitly (and one more extra time), reuse the functionality of this method which already does exactly that.

Manual closure for nicer call stack looks.

Provides support for several common patterns of lazy initialization, including the ability to initialize value types and to use null values. This is a frugal version of and that does not create any objects until the lazy value is initialized to a reference type. This class only supports creating reference types with default constructors in a thread-unsafe or publication-only manner, but its added memory usage is exactly zero (it takes as much space in the containing class as a field with a reference to the lazily-created value would do). For use in private fields only. Do not expose! Assigning this object to any variables breaks the pattern.

Specifies the type of element being laziliy initialized.

Queues the action to execute once on the .. thread when the timeout elapses. Handles intervals smaller than only. Returns a token that cancels the action execution. The token disposal is optional. The execution will be either guarded or not, depending on the presence of property value.

this The name for the task. The action to execute. Exceptions will be trapped. A non-negative time interval.

The problem with is that in case of exception thrown during calculation, this exception is cached and all following invokations will throw exactly the same exception. So in case we want to interrupt calculation of lazy with OCE and than calculate real value by following invocation, we should use this class.

Concurrent blocking queue with predefined size. All operations are thread safe. Operations like ToArray or GetEnumerator takes queue snapshot at some moment.

Constructs queue with predefined size. Queue size is defined logarithmically. Queue is not growing, nor shrinking.

From 1 to 20. Real queue size will be 1<<.

Enqueues to the tail of the queue. Increases tail.

Dequeues from the head of the queue. Moves head.

Peeks from the head of the queue. Leaves head untouched. Sequential peeks will return same result if no other thread dequeues or clears simultaneously.

Number of elements in queue snapshot.

Not real SyncRoot, but you can use it for external synchronization

Same as . Implementation of

Same as but returns null returns false

Same as but returns null when returns false

Thread Apartments APIs wrapper for compatibility with .NET Core on Unix. On platforms with native thread apartment model support (.NET Framework, .NET Core WindowsDesktop.App) it's just a proxy to platform APIs and on other platforms it emulates STA threads for our Dispatcher.

Shares the dictionary with other code running on our AppDomain, such as the Launcher, which needs to designate the entry thread as STA. This name MUST be in sync with JetLauncher. The data value type (Of ) and its meaning (presence of a thread means it's STA) and its threading ( lock on itself) MUST be in sync with JetLauncher. On , the values there will not be respected by the real runtime, but are not an error either.

A map with STA threads, access locked by itself, shared with other participants (e.g. Launcher) via under the , so must be a primitive type understood by all frameworks.

Emulates on platforms without native thread apartment model support. Must be called only from methods marked with .

Use this method instead of

This class provides functionality to manage and control the state of predefined thread-local storages (TLS) within an application. This class allows for the registration of specific TLS handlers that can be suppressed (reset to default) and later restored as needed.

Registers handlers for a specific thread-local storage (TLS) key. These handlers will be used to reset the TLS value to its default state and restore it when needed.

Temporarily suppresses the current values of all registered thread-local storages, resetting them to their default values.

Provides support for several common patterns of lazy initialization, including the ability to initialize value types and to use null values. This is a frugal version of that does not create any objects until the lazy value is initialized to a reference type. Note that if you're passing a factory function and it's a closure, a new reference object is created for it per each instance. To avoid this, you can use .

Specifies the type of element being laziliy initialized.

Mode and state data packed into a single int for less space. LazyExecutionMode values and Flag* fields.

Creates the value on-demand using the default constructor.

Creates the value on-demand with the user-supplied factory. See if you want to pass a parameter to the factory lambda without allocating a closure for each instance.

Just wraps an already-created value.

Provides support for several common patterns of lazy initialization, including the ability to initialize value types and to use null values. This is a frugal version of that does not create any objects until the lazy value is initialized to a reference type. The difference from is that you don't have to create a new closure for the factory function with each call. Instead, you can pre-cache a function taking a parameter and pass the parameter into this struct separately. This way no reference types are created per instance until it's time to instantiate your object.

Specifies the type of element being laziliy initialized. Type of the parameter passed to the factory function.

Mode and state data packed into a single int for less space. LazyExecutionMode values and Flag* fields.

An object instance with access protected with a lock. To get the protected instance, call with a using construct, and read its . To make such an object, define a lock as , and wrap some value with .

For API completeness, allows to extract the value protected by this object, without taking the actual lock.

Takes the lock and returns the object thru which you can access the locked value.

A disposable object which (a) MUST be disposed of when done (preferrably, with a using); (b) gives access to the protected object in .

Takes the lock and returns the object thru which you can access the locked value.

A disposable object which (a) MUST be disposed of when done (preferrably, with a using); (b) gives access to the protected object in (though in this overload you also get the clean object in an out parameter). The lock for this value is taken while you are inside the using block.

Takes the lock and executes a function which accesses the locked value. Less optimal than family overloads, but sometimes helpful for one-liners.

When you need to create an instance of some object to lock against it (), use this class. It has an additional method for entering the lock with a timeout (throwing an exception if failed).

Makes a wrapper for an object which can only be accessed under a lock. To get the protected instance, call with a using construct, and read its . If you do not expose the value to your clients directly but only thru this wrapper, then it helps them take the locks correctly with minimal overhead.

The value protected by the lock. Clients will be able to read it until the lock is released. A timeout for waiting on the lock, turns a potential deadlock into an exception, which often saves the program from a complete hand. is a special value which does not set a timeout for the wait. A wrapper object. No special handling requirements for it.

Takes a lock. If the timeout expires before the lock can be acquired, throws an exception.

Takes a lock. If the timeout expires before the lock can be acquired, throws an exception. Exposes the given to the clients. If you do not expose the value to your clients directly but only thru this method, then it helps them take the locks correctly with minimal overhead. See for a wrapper with similar functionality.

The value protected by the lock. Clients will be able to read it until the lock is released. A timeout for waiting on the lock, turns a potential deadlock into an exception, which often saves the program from a complete hand. is a special value which does not set a timeout for the wait. A disposable object which (a) MUST be disposed of when done (preferrably, with a using); (b) gives access to the protected object in .

This class just uses WaitForSingleObject directly to work around unwanted consequences of message pumping that may happen while doing WaitHandle.WaitOne. It is not intended to implement all the functionality that WaitHandle possess.

Waiting for event to be SET

true if event was SET, false if timeout expired

Waiting for event to be SET or new message is appeared in queue

true if event was SET, false if timeout expired, null if new message is appeared in queue

Waiting for event to be SET

true if event was SET, false if new message is appeared in queue

External API for events, named NativeManualEvent for compat. reasons

External API for events, named NativeAutoEvent for compat. reasons

Takes the lock or throws. Timeout does not work when under debugger.

Gets the value if lock is currently held. Otherwise, throws.

Releases the lock. Do not call multiple times; it tries to check for multiple calls, but, being a struct, this does not work when copied byvalue.

Enters the writer lock. If the time limit expires, throws an exception.

For high performance code. No lambda and heap allocation.

Enters the writer lock. If the time limit expires, throws an exception. Exits the writer lock when you dispose of the return value.

Enters the reader lock. If the time limit expires, throws an exception.

Enters the reader lock. If the time limit expires, throws an exception. NOTE: this overload takes milliseconds for perf because it's what the library method uses internally.

For high performance code. No lambda and heap allocation.

Enters the reader lock. If the time limit expires, throws an exception. Exits the reader lock when you dispose of the return value.

Enters the reader lock upgradeable to writer lock (by a nested request). If the time limit expires, throws an exception.

Enters the reader lock upgradeable to writer lock (by a nested request). If the time limit expires, throws an exception. Exits the reader lock when you dispose of the return value.

Enters the reader lock upgradeable to writer lock (by a nested request). Exits the reader lock when you dispose of the return value.

Disable monitoring of long activities under read lock without interruption checks on the current thread

For CheckLastInterruptTime inlining optimization

Try to acquire write lock

timeout in milliseconds Zero timeout means that we don not wait and we have only one attempt to fetch write lock, and we don not hope to acquire write lock in case of active reader locks in other threads, so we do not change the value of AccessRequested to not interrupt readers. Otherwise, at any timeout value greater than zero we set AccessRequested to true and readers have a chance to interrupt before timeout elapse. Any timeout value less than zero will lead to infinite waiting with AccessRequested set to true, true in case of successfully acquired lock, otherwise false

A reference wrapper for the for those usages that don't mind creating a new object.

Locks.

Unlocks.

Pushes an / bracket.

An asynchronous reader/writer lock that allows multiple concurrent readers or a single exclusive writer.

This lock is not reentrant for write or cross‑mode acquisitions: once you hold a write lock, you cannot acquire another write or a read lock until you’ve released it (and vice‑versa). You may acquire multiple read locks in the same async control flow; each acquisition is treated as a separate reader and must be released independently.

Asynchronously acquires either the reader or writer lock (depending on ), executes on the passed as soon as the lock is granted, and then releases the lock immediately without extra scheduling hops.

Call for diagnostic only, because it's not guaranteed to work for all messages. Set this to up-to-date message decoder when debugging.

If there's no space for sending more messages, they can be stacked here.

Sends a message to the receiving party. If the buffer is currently full, stores it in queue and does not block.

Makes sure all of the messages currently on the queue get sent out, synchronously.

Lightweight task scheduler that executes items sequentially on a passed scheduler

Yields' implementation.

This asks if the stuff could be executed inplace without scheduling, never true for a yielder.

The action given to awaiter MUST be executed no matter what; this is the place where we should report cancellations and failures. We cannot track failures on a value type I'm afraid, but the cancellations we can do. And should.

Create and start a new task under the task barrier.

NOTE: This lock is not fair: success is determined by who first acquires the lock, not who first waits. A writer waiting in the queue does not block new readers from entering.

Adornment to system that allows never suffer from threads exhaustion.
Problem: will NOT start your action on a background thread immediately IF all available threads are occupied. System pool has a growth strategy and it depends on framework. NETFramework adds new thread to available ones every 1 second.
Solution: Use to enqueue action that will be scheduled to system pool and if job isn't started after (default: 50ms) new thread will be created.
Caution: You must catch exceptions in queued actions by yourself (the same for system ThreadPool).
Implementation details: - It's guaranteed that action will be executed once and only once. - All internal algorithms are non-blocking wait-free ( is used and it's lock-free) - Algorithms try to null memory as fast as possible, so GC load mustn't be high - Special infinite running "Controller" thread is started first time you access - All internally created threads has IsBackground == true and Name starts with "UnlimitedPool"

Queue action to execute on background

Action to execute. You must try/catch exceptions inside action by yourself (as in ) if action is null

Change until lifetime terminates

Special that guarantees that enqueued task will be executed as fast as possible on a system thread pool or (if pool is exhausted) on dedicated thread.

Implements the (clumsy) interface (should be reworked) for a timer which ticks on thread. Originally, there were multiple implementations (based on WinForms, custom impl on threading timer, etc). This one is based on our threading primitives, and is supposed to be platform-independent.

A timer which executes its callback method on a thread pool thread.

Initializes a new instance of the timer. The timer is not started.

Initializes a new instance of the timer and start it with the specified period.

Initializes a new instance of the timer and start it within the specified time and with the specified period.

Start or restart the timer.

Stop the timer.

Changes the start time and the interval between callback invocations.

The delay before invoking the callback. Specify negative one (-1) milliseconds to prevent the timer from restarting. Specify zero (0) to restart the timer immediately. The interval between invocations of the callback method. Specify negative one (-1) milliseconds to disable periodic signaling.

Allows to join expected callbacks from unguarded context into the current guarded context. When running in the guarded context, nest the actions that might cause callbacks from unguarded context within a call. will come True. In the callback handler, use . If , it will be merged into the current guarded context (this is considered a reentrant-safe activity). Otherwise, will be used. Can be reused.

Init.

Identifies the thread. Behavior flags & options.

Whether we're inside .

Executes the in the guarded context. If (ie running inside ), merges the call into the current guarded context. Otherwise, does the regular . Executes sync or async. Must be run on the thread. Catches all exceptions. The lifetime of this schedulled request is limited by the lifetime of this unguarded callbacks merger.

Executes the in the guarded context. If (ie running inside ), merges the call into the current guarded context. Otherwise, does the regular . Executes sync or async. Must be run on the thread. Catches all exceptions. True if executed immediately, False if queued (-compatible behavior).

Says that we're expecting callbacks from the unguarded context, and they should be allowed into the current context if they use .

behavior aspects.

Use the default behavior: if the callbacks were queued for execution with , they're not reclaimed after the owning object is disposed of, and will still have a chance to execute. This is the default.

If there're any pending callbacks queued for execution with at the moment the owning object is disposed of, they're dropped. No code submitted through this object will execute after it is disposed of.

When running inside , nested calls to are prohibited. An attempt to place such a call will result in an exception. This is the default.

When running inside , nested calls to are allowed.

Implements a raw circular buffer which is attached to an existing memory pointer (e.g. to work on some shared memory).

Strategy: manages allocation of sequential memory chunks called messages. is the total available space of the buffer. bytes in the beginning are occupied by this header structure. The remaining memory is either empty, or occupied by a single contiguous used block of messages ( ), or by two contiguous blocks after the content wraps over the buffer end. Possible layouts: [header] {head} -empty- // just started writing [header] -empty1- {head} -empty2- // read some first messages of the written [header] {head} -empty1- {tail} -empty2- // attempted writing new messafe after {head}, there were not enough space till the end of the buffer, so we wrapped head to the beginning (there's small -empty2- because we do not break messages when wrapping around the buffer, message memory is always contiguous) and then it goes all around

The available free space at this moment.

Maximum payload size (that's max free space minus the message header).

Reads the message, if any present, and invokes the callback. Returns whether there was any message to invoke the callback with.

Reads the message, if any present. If not, yields Null.

Tries to write message, returns False if there's no space left.

A stream that resides in memory and allocates more chunks of data instead of reallocating the large continuous chunk.

Chunk buffers (non-zero-length only — required for index two-way translation).

With multiple small calls to Read or Write, caches the last-used current buffer and avoids costly calls into a chunk list.

The buffer from the is currently in. "Before first byte" is preferred to "After last byte" (even if at end of stream). Could be equal to number of buffers (eg pointing beyond the end of list of buffers) — when exactly at the end of the stream.

Offset of the from the beginning of its current buffer (). Shouldn't be equal to current buffer length (should be zero in the next buffer instead).

Allocates the new stream which will grow as you write. When done writing, you can the stream to prevent subsequent modification by consumers. If you want multiple consumers to read the frozen stream without interrupting one another, give them individual lightweight instances produced with .

Clone ctor.

The unique identifier of this breed of cloned streams. New for each new stream. Same in all cloned instances.

Wraps with an immutable interface. Must be frozen already. The current position in the stream is NOT passed to the immutable instance.

Wraps user buffers with a readonly stream. No guarantees are provided for innutability of the buffers' contents, so the stream is neither nor can it ever be frozen.

Wraps user buffers with a readonly stream. Caller claims the buffers to be ever immutable, so the stream is assumed .

Fluent version of .

An optimized func for reading just one byte; without it, base impl might go into allocations on every read.

Makes a lightweight clone which only creates a copy of the wrapper class, but reuses the whole same buffers. The current stream must be frozen. This way you can have multiple readers over the same data without their interfering with each other's position and yet without wasting memory.

Returns the array contents, trimming any excess storage.

Works similarly to . Frees the unused buffers, but does not free the unused leftovers of the last buffer.

Gets the buffer and offset in it where the falls. Offset can be zero and never can be equal to the length of the buffer. At the very end, the buffer index is equal to the number of buffers. Returns -1 of OK and the total max length of the buffers-allocated space (including start offset) if the position does not fall within the allocated space.

Wrap the chunked memory stream as an immutable byte stream. Must be frozen.

Whether we're running on user buffers (as passed to ctor) and should not be modifying them.

has been called.

Tracking flag for clones.

Mapping from one family of objects into another and vice versa. Uses the runtime for storage. As compared to the BidirectionalMapOnCompactMap{TLeft,TRight}, this is a few times faster. With large amounts of memory it will use more mem (and might get into LOH).

Get the number of mappings. As we implement the identity mapping, the number of items on both sides is always in sync.

Adds a new mapping to the map. Both ends must be unique in their maps.

Removes mapping if exists. If left/right element doesn't refer to right/left then error will be logged without removing and exception throwing.

Adds a new mapping to the map. You should use whenever possible, as it throws on dpulicate keys.

Left key. Right key. Whether to ignore duplicate keys in left and right collections silently. Not recommended. The conflicting mappings will be dropped.

If there're multiple equal items in the list, which one of them should be taken for a hit.

If there're multiple equal items in the list, take any of them for a hit.

If there're multiple equal items in the list (must be contiguous in a sorted list), take the lowest-index one for a hit.

If there're multiple equal items in the list (must be contiguous in a sorted list), take the highest-index one for a hit.

Wraps an enumerable (or enumerator) with to be able to interrupt/ materialize enumerable when write lock is requested

Type of the items to be enumerated

A frugal version of a generic variable-size list. Properties: • Is a value type (non-POD though), thus merges into the memory of the owning type. • Stores first items within own memory. • Stores the remaining items, if any, in a dynamic list. If there aren't any more items, the dynamic list is not created. • Does not create any new objects when there are just 0,1... items in the list. Memory: pointers for first items, plus one pointer for the lazily-created list of remaining items items.

Boxes this value type and returns the custom box object which implements a readonly . The box PARTIALLY reflects modifications in the original structure. To create a full copy, use or .

Allows to enumerate the list in language constructs like C# foreach.

Creates a new with the items. Calling the ext method would just box the existing instance with a readonly interface.

Creates an empty list.

The type of elements stored in the list. An empty list.

Creates a list that contains the specified object.

The object to store in the list. The type of elements stored in the list. A list that contains the specified object.

Creates a list that contains the specified objects.

The first object to store in the list. The second object to store in the list. The type of elements stored in the list. A list that contains the specified objects.

Creates a list that contains the specified objects.

The first object to store in the list. The second object to store in the list. The third object to store in the list. The type of elements stored in the list. A list that contains the specified objects.

Creates a list that contains the specified objects.

The first object to store in the list. The second object to store in the list. The third object to store in the list. The fourth object to store in the list. The type of elements stored in the list. A list that contains the specified objects.

Creates a new list populated with the specified items.

The elements to add to the list. The type of element stored in the list. A list that contains the specified items.

Creates a new list populated with the specified items.

The elements to add to the list. The type of element stored in the list. A list that contains the specified items.

Creates a new list populated with the specified items, filtered down. Useful when you're trying to fetch the single item from the collection and deal with cases when there are none or a few, because this deals nicely with no extra allocations.

The elements to add to the list. Pass-filter for items. The type of element stored in the list. A list that contains the specified items. This is not the most useful overload, the best ones are those which take value types for collection as they prevent boxing as opposed to .Where().

The elements to add to the list. Pass-filter for items. The type of element stored in the list. A list that contains the specified items.

Initializes a new instance of the list.

The source list to initialize the resulting list with. The function to apply to each element from the source list. The type of element stored in the source list. The type of element to store in the target list. A list that contains the specified items.

Initializes a new instance of the list.

The source list to initialize the resulting list with. The function to apply to each element from the source list. An argument to be passed to the selector mapping function. The type of element stored in the source list. The type of argument to pass to the selector mapping function. The type of element to store in the target list. A list that contains the specified items.

Creates a list from the specified collection.

The collection of objects to copy to the list. The type of elements contained in . A list that contains the specified collection of objects.

A readonly helper to expose the and alike interface from . Boxes the structure explicitly. You SHOULD do C# foreach right on the list, which will cause the compiler to emit code which calls into the original struct public methods directly.

Does not share the enumerator class/struct with the list itself because that one does not implement the interfaces, which allows to skip on and try-finally sections in emitted code.

The minimal enumerator implementation for the . Only supports C# foreach, does not have even Dispose to save on try-finally sections.

Returns true if and only if is empty (has no elements).

Static overload to prevent runtime type checks.

Returns the only element of a sequence that satisfies a specified condition. If there're no such elements, throws an exception (hence difference with ). If there're multiple such elements, logs an exception and uses the first one.

The type of the elements of . An to return a single element from. The context for the exception message. Must be a complete sentence. Will be added to the message which says there're no/multiple items. The single element of the input sequence that satisfies a condition.

Returns the only element of a sequence that satisfies a specified condition. If there're no such elements, returns NULL (hence difference with ). If there're multiple such elements, logs an exception and uses the first one.

We put all of the bytes read from the underlying stream into cache to make this view seekable. This tells how much of the stream bytes have been taken to cache already.

Gets the immutable stream.

Gets if all the bytes from the underlying sequential stream have already been taken into the random-access cache.

Total length of the stream, if it's cheap to tell. With a sequential-only underlying stream, it is generally not available, so to tell the our clients on the interface we'd need to fully read and fully cache the stream, which will be expensive if you only need the length for diag. The length is cheaply known when: • We have already cached the whole underlying stream. • Stream owner has told us the length it knows from some other source (e.g. a ZIP entry stores its uncompressed length).

Gets the length, if known (), otherwise, reads the underlying stream to the end to know the length. . does this.

Can give you a stream clone if you only intend sequential access. • If reading the underlying stream has already cached most if it — gives a clone of the immutable stream view, to complete caching, regardless. • If the supplier of the original sequential stream knows how to make another one just like it — asks for it, and returns. That would be the real non-caching stream. • In all other cases — a clone of the immutable stream view, caching and all.

Lifetime of the stream access. NOTE: you do not need to dispose of the stream. Disposing of the stream might or might not have effect.

Base class for our streams which are guaranteed to be immutable and seekable (but might possibly be lazy), which makes a basis for the use of file bodies in the reliable builds. Our streams contract is that it does not obey (safe to be disposed once or multiple times without impairing operation), but takes a upon construction if required by the specific instance. Streams support shallow cloning, that's multiple stream reader views over the single instance, with independent positions.

An empty immutable stream.

Digest of the stream contents, lazily-calculated. The main reason for having it wrapped into a Lazy reference type is to have it shared (full-write) between shallow clones.

Optional. When creating a shallow-cloned instance, gives a pointer to the cloning source. This allows to reuse the lazy message digest. Failure to report the clone source when implementing your would not break anything, but will slow down access to message digest. This is critical for one of the main clients, Immutable File Items, because they'd return a new shallow clone on each file body property access.

Lazily-computed hash of the bytes in the stream. It is NOT guaranteed to be stable between runs, but hashing algorithm must be exactly the same for all implementations within the single process run.

Exposes the function which is used for computing over the file content.

Wraps user buffers with a readonly stream. Caller claims the buffers to be ever immutable, so the stream is assumed immutable.

Wraps an immutable byte array as an immutable byte stream.

Makes a lightweight clone which has an independent position in the stream and can run independent read/write operations, but shares the same media. This way you can have multiple readers over the same data without their interfering with each other's position and yet without wasting memory.

Ideally in .NET, immutable memory streams should be non-lifetimed and GC controlled. In reality, to optimize memory use, sometimes the immutable byte streams might have limited lifetime if they're being projected by a certain source rather than copied to GC-controlled memory. This method tries to ensure that the memory owned by this file item has no end of life. Returns a new instance only if a change were made. We suppose that implementations know when their memory might possibly become invalid. Note that a totally different implementation of a byte stream might be returned from this method.

Implements over a fixed native memory buffer. Surprisingly, there is no standard implementation like this yet.

Creates a new memory manager which reinterpret-casts the memory of this manager to another type. This is always an allocation, so don't put on hot paths. NOTE that unlike this would refuse to cast to an un-whole number of items, e.g. 3 bytes to 1.5 chars. NOTE that the new memory would inherit the original because it's the lifetime of the native buffer. If you want to prolong, contact the owner of the initial buffer and arrange for a new lifetime, creating a new memory manager from scratch.

Wraps a sequential stream with a view which supports seek operations. For that, it has to keep a copy of already-passed bytes, even if you skip them when seeking, so use only when needed (like, when you want to analyze a header of a sequential stream with a reader which requires seeking).

Data shared between all the clones of the immutable stream, pumping off the same underlying sequential stream.

Current position in this clone of the stream. This data is not shared. MIGHT be beyond the cache length because we do not pump on seek, only when we actually try to read. MIGHT be beyond , because many sequential streams do not tell their real length.

A lifetime for opening the main underlying sequential stream (the first call to ). Might be if you don't care. The lazy sequential stream to be wrapped. At this point, will be wrapped even if seekable. Set to True, if possible, to enable opening another instances of the underlying sequential stream, in case client wants to consume the stream sequentially without the overhead of caching it in mem. This is useful only for cases like bulk extracting entries. If is an error to return the same stream instance multiple times in this case. If False, you'd be only called once anyway. See . If the property of the underlying stream is irrelevant (which might be a case with a sequential stream), you must provide its value by some external knowledge, otherwise seeking based on end or getting the length would be a costly operation because it would have to read the stream fully. Leave empty to use from the underlying stream or read to end for learning the length.

We put all of the bytes read from the underlying stream into cache to make this view seekable. This tells how much of the stream bytes have been taken to cache already.

Gets if all the bytes from the underlying sequential stream have already been taken into the random-access cache.

MIGHT be expensive to calculate! Check to know if the length is immediately available. Otherwise, would need to fully consume the underlying stream to tell.

Ensures we can read bytes from the current . Must be protected with lock at caller side.

Recommended amount. Must have as many bytes available in the cache, unless the input stream runs out of bytes. NULL is a special value, means we need to pump it all and have the full content in cache. Bytes actually available, after pos and to the end of the current cache, but at most .

The common data shared between all the clones. This object is also reused as the Operations Lock shared by all the clones. Main goal to have this as an object: we can't just copy all data because we want to release (from all clones) the sequential stream when it gets exhausted, which means we need some kind of an object box around it anyway, let's keep all data in there.

Bytes which we pump from the sequential stream get cached here, for random access. Operations locked via the data object.

As passed by creator.

Opens the main underlying stream. Maybe opens a clone of the underlying stream.

When is read to the end, it's released, NULLed, and this gets True (under lock).

The main underlying sequential stream. Lazy-created to enable mass-creation of immutable file item promises with low overhead. For example, the zip entry inflater eagerly allocates its working buffers, so with mass-creation for all the entries this makes quite a number. Gets NULLed after exhaustion (to release its resources, incl inner buffer). Operations and NULLing locked via the data object. States: • Non-NULL: partially cached, OK. • NULL and : fully cached, stream released, OK. • NULL and NOT : aborted by termination, BROKEN.

Lazy-reads the length from the underlying stream, if it tells anything. Might throw or tell zero. Or potentially any bullshit. Only asked if we don't know and need to know the prospected length.

Stores custom length as supplied, for asserting when we do know the real length.

Readonly representation for Can be used in public API

Represents a string-like object over a managed memory buffer presented as a byte array, written in the UTF-16LE encoding.

Creates a string source over a byte array.

The array. The index to the first byte of the string, in bytes. The length of the string in bytes.

A value type which implements a set of -like accessors. The collection interface itself is not implemented to avoid accidental boxing. This can be used to represents a specialized view on a larger collection or a data source, or a result of dynamic calculation, which does not allocate memory per-instance. The serves as a common backend for a set of such collections (or even is a singleton), while the reference-type and value-type parameters in the collection source instance allow to define the context to make the collection source owner serve a specific collection.

POD data member.

One of the reference data members.

Wraps an actual collection object with a collection source.

POD data member.

One of the reference data members.

Renders collection source contents for the debugger.

Wraps an actual collection object with a collection source.

Wraps an enumerable with a collection source so that it's not committed to a collection but enumerated anew on each request.

Counts items by iterating the collection. Revert to this impl if you can't count the items faster.

An empty placeholder which allocates memory for POD data of collection source owners.

Represents an empty string.

An interface to switchable implementations behind the .

Returns a which is guaranteed to be hosted in the managed memory, i.e. its lifetime won't terminate. Required if you plan on using the string longer than the lifetime it's been produced under. Native strings will be rendered as runtime strings. Non-native strings, e.g. strings or substrings, will be returned AS IS.

Processes a string as a fixed pointer to the char array. This char array MIGHT NOT be zero-terminated!! It MUST NOT be modified. It might be a subrange of some other runtime string object, or a pointer to a native memory area, or some stack/reusable buffer.

A string in the native memory. Cannot be directly treated as an LPCWSTR because for it zero-termination is not guaranteed.

Stringsources a native memory range. Checks the lifetime before accessing the memory range (not safe from races though, rule this out with external means of control).

Stringsources a native memory range. Has NO means for checking that the mem is still valid, so don't use unless really have to.

Represents a string which has not yet been calculated as a runtime string object. Allows for most string-related operations without allocation of a real runtime string. Like with HSTRING

This is the original StringSource implementation, backed by an owner. Modern impl is a shallow wrapper for , kept for the case we might have more sophisticated owners, such as concatenaring or transforming, etc.

Gets a source for an empty string. This is equivalent to a NULL value for this structure.

POD data member.

One of the reference data members.

Gets whether the string is empty.

Renders the runtime string object for this string source. This specific operation is what a tries to avoid by providing a string-like API to some non-allocating object.

Wraps a real collection into a collection source.

Wraps a runtime string object as a string source.

Represents a string which has not yet been calculated as a runtime string object. Allows for most string-related operations without allocation of a real runtime string. Like with HSTRING

After Spans were introduced, its implementation has been swapped with a single of . Let's keep the typed wrapper for now, in case we would want more sophisticated string sources than just memory.

Represents a string which has not yet been calculated as a runtime string object. Allows for most string-related operations without allocation of a real runtime string. Like with HSTRING

After Spans were introduced, its implementation has been swapped with a single of . Let's keep the typed wrapper for now, in case we would want more sophisticated string sources than just memory.

Gets a source for an empty string. This is equivalent to a NULL value for this structure.

Gets whether the string is empty.

Renders the runtime string object for this string source. This specific operation is what a tries to avoid by providing a string-like API to some non-allocating object.

Renders the runtime string or substring object for this string source. This specific operation is what a tries to avoid by providing a string-like API to some non-allocating object.

Gets whether the string is empty.

Returns an array of string sources that contains the substrings in this string that are delimited by elements of a specified UTF-16LE character array. Parameter specify whether to return empty array elements.

Returns an enumerable of sting slices that contains the substrings in this string that are delimited by one or more characters in . An array of UTF-16LE characters that delimit the substrings in this string, an empty array that contains no delimiters, or null. to omit empty array elements from the array returned, or to include empty array elements in the array returned.

Renders the runtime string object for this string source. This specific operation is what a tries to avoid by providing a string-like API to some non-allocating object.

An empty placeholder which allocates memory for POD data of string source owners.

Reads from the reader end of the pipe which has been opened with Overlapped IO enabled. The read is asynchronous without holding up any threads, using OS ThreadpoolIO.

Either placing a read async call, or analyzing its results and whether it's sync or async, or running the code inside the callback.

Set to True when executing callback code. Most importantly, we must not wait for a callback when inside a callback. Changed under the lock only, allows to tell if we're taking the lock in some nested code of the callback.

Not processing or awaiting, usually because the lifetime has been terminated or pipe broken or some error has occurred. Means there's no pending wait, we're not analyzing the pending read results, and we're not about to do a new pending read.

Initiates async reads from the pipe, and proceeds doing that until terminated or pipe is broken.

Lifetime for the reader. Might block upon termination until the ongoing async operation can be safely interrupted. Must not be terminated from within a callback. File handle to the reader end of the pipe. MUST be opened with async support, e.g. with CreateNamedPipeW or with CreateFileW. Reader callback. Must not do complex operations, as might occur on the OS IO pool thread and under a lock. The buffer is temporary for the callback duration only. MUST NOT terminate lifetime in it. Optional. Notifies when reading the pipe breaks. Same callback limitations apply: OS thread, under lock. MUST NOT terminate lifetime in it.

Gets whether the lifetime has not yet been terminated and the pipe has not yet been closed on either end.

Initiates pipe connect (if a read has failed because no clients have connected yet). MUST be under Busy Lock.

Initiates the next read from pipe. MUST be under Busy Lock.

Called whenever we have an IO result. Unified handling for all cases. Which are: (1) On ReadFile function immediate return result. (2) On ConnectNamed Pipe immediate return result. (3) Upon a successful result of either above, the unwrapped result from within (called recursively after unwrapping). (4) From an async IO Complection Callback (which already has the result unwrapped). Triggers other IO operations as needed (connect pipe, read loop, etc). MUST be called under the Busy Lock.

The IO Result we're switching over. The context we've been called from. If called with a ready successful result, then need to pass the number of bytes from it. The context of how the operation has been initiated (read or not), and if we're the chosen party to handle its result (first to be called on the sync/async reply).

Means we should yield this thread, and the chain of operations will be continued elsewhere (from an async callback, for example, or it's shut down completely).

Means the caller should initiate the next IO operation in the chain immediately. We do not call it right here because the stack would grow on async results then.

We want to know if we've initiated an IO operation and not completed it yet (sync or async). All access must be protected by the owner's Busy Lock.

An overlapped IO operation has been initiated, and has not yet completed (or been acknowledged for). TPIO has been started, an overlapped IO call has been placed. This state means that either: • The operation went async, we're expecting a callback. The callback will give us the result and “eat up” the TPIO. • The operation has succeeded synchronously (in FILE_SKIP_COMPLETION_PORT_ON_SUCCESS mode), and we're in between the IO call and the handling code. Will need to cancel the now-unneeded TPIO. • The operation has failed (with a code other than ERROR_IO_PENDING), and we're in between the IO call and the handling code. Will need to cancel the now-unneeded TPIO.

Called from lifetime termination handler when shutting down the reader. MUST be called under owner's Busy Lock. Gets if we need to cancel anything.

Called just after a call to an overlapped IO operation, telling its result. MUST be called under owner's Busy Lock. Checks if we are the ones to handle the operation result (rather than callback). Checks if TPIO should be canceled.

Called before initiating any overlapped IO operation. MUST be called under owner's Busy Lock. It is an error if is True. Sets the state, starts the TPIO.

Called from within the completion callback for an overlapped IO operation. MUST be called under owner's Busy Lock. Checks if we are the ones to handle the operation result (the callback rather than the code which initiated an IO operation and might have had the reply synchronously). TPIO need not be canceled if we're in the callback, we've used it up.

Of multiple parties possibly handling the result (code right after the overlapped IO operation, and callback), the one which is calling should process the success result.

The IO operation were a read, so should be reading bytes (and zero means EOF in this case).

Basically, (1) raw IO function call ioresult and (2) completed async call overlapped ioresult have the same errors but a few peculiarities: • (2) Completed cannot have the PENDING status. • On success, (1) needs to get the overlapped ioresult and switch over it again, while (2) already handles the result.

Mostly used for diag.

Based on the , decodes text out of the raw bytes, and splits by lines.

Initiates async reads from the pipe, and proceeds doing that until terminated or pipe is broken.

Lifetime for the reader. Might block upon termination until the ongoing async operation can be safely interrupted. Must not be terminated from within a callback. File handle to the reader end of the pipe. MUST be opened with async support, e.g. with CreateNamedPipeW or with CreateFileW. Reader callback. Called outside of any native callbacks, so it can be any much complex, but for the last call when EOF is encountered or lifetime is destroyed, which has to be sync.

Initiates async reads from the pipe, and proceeds doing that until terminated or pipe is broken.

Base API for Shell Locks — Content Model Reader-Writer Lock.

True if read access is allowed in the current thread.

JetBrains.Application.IShellLocksEx.AssertReadAccessAllowed(JetBrains.Application.IShellLocks)

Indicates that the current thread owns the read lock

True if write access is allowed in the current thread.

JetBrains.Application.IShellLocksEx.AssertWriteAccessAllowed(JetBrains.Application.IShellLocks)

Indicates that the current thread owns the write lock

True since start of the first until release by the last or since write lock is first acquired by and until it is released by .

This property can return 'true' for some time after write lock was actually released, it's not in sync with the actual reader-writer lock.

An interruption source for WriteLock. It will raise interrupt flag when write lock is being requested.

A gentle interruption source for WriteLock. It will raise interrupt flag when write lock is being requested (either sync or async)

Fetches read lock - the lock which is used to control read-access to IDE data (such as PSI, documents, project model, etc.) and is obtained by threads that perform read-operations.

Read lock cannot be acquired when the write lock is acquired by another thread and execution will be blocked until the write lock is released. You do not need to acquire read lock in the UI thread (since write operations cannot be performed in any thread different from the UI thread). Use method to release read lock. NOTE: the best way to hold read lock for a block of code is to use JetBrains.ReSharper.Resources.Shell.Shell.ReadLockCookie JetBrains.ReSharper.Resources.Shell.Shell.ReadLockCookie

Fetches write lock - the lock which is used to control write-access to IDE data (such as PSI, documents, project model, etc.) and is obtained by threads that perform write-operations.

Write lock cannot be acquired when the read lock is acquired by another thread and execution will be blocked until the read lock is released. Acquiring of the write lock is allowed only in the UI thread (and so you cannot perform any write operations from non-UI thread). Note that you do not have to obtain the write lock explicitly in most of cases. All low-level write methods (such as PSI or document modifications) obtain write lock automatically. You may need to obtain write lock if your subsystem (similar to PSI or documents) has its own data to be modified in write operations only. Use method to release write lock. NOTE: the best way to hold write lock for a block of code is to use JetBrains.ReSharper.Resources.Shell.WriteLockCookie JetBrains.ReSharper.Resources.Shell.WriteLockCookie

Releases read lock. For more information about read lock see .

Releases write lock. For more information about write lock see .

Tries to fetch read lock - the lock which is used to control read-access to IDE data (such as PSI, documents, project model, etc.) and is obtained by threads that perform read-operations.

Tries to fetch write lock - the lock which is used to control write-access to IDE data (such as PSI, documents, project model, etc.) and is obtained by threads that perform write-operations.

Synchronizes lifetime-driven activities on multiple threads. If you use your component lifetime directly, it might be terminated in the middle of some background activity. You should rather create this object on your home thread and use its to run background-thread activities (possibly on multiple threads). It is guaranteed that as the outer lifetime starts termination, this particular lifetime will live thru until your background action is completed.

Non-Null to specify the thread to which the object termination is affined.

Terminates under a writer lock. All other activity goes under a reader lock.

Works just like 's flag, gets True when termination has just started.

Gets the lifetime whose termination is synchronized by this object. It's not safe to call lifetime's scheduling methods unless you're running within some of the Execute* functions.

Gets the lifetime whose termination is synchronized by this object.

Executes the action unless the lifetime has already been terminated. Free-threaded calls are only safe within this method.

Whether the lifetime is still alive (action might be prevented, aborted or completed when False; it's definitely been completed if True).

Executes the action unless the lifetime has already been terminated on the main thread.

If the lifetime is still alive, executes the action and returns its result. Otherwise, returns null.

Synchronizes this action with lifetime termination on another thread. For terminations on the same thread, there're obviously no guarantees, as we cannot “wait” until it gets clear. But regarding termination on other threads, it's guaranteed the lifetime state is consistent and won't change within the duration of this action (either fully alive or fully terminated).

There's no flag to tell you if termination is in progress right now (but not yet complete). will be True when either termination is running or fully completed. If you need to allow some actions to execute within termination, but not with a fully dead lifetime — you must create a nested lifetime which will either be all good or all dead at that point, and use that for determination.

The outer (unsynchronized) lifetime must be terminated on the same thread as the object has been created. Use with component containers.

A fully free-threaded scenario, termination allowed on any thread. Note that in this case you MUST make sure the lifetime is not terminated while this object is still being created.

Local extensions to the Async Tasks. Some of them would be available out of the box with Netfx 45.

Task is faulted because of PCE

Try to find out OperationCanceledException in AggregateException. If no PCE but some other exception exist, return it.

Return value that can be updated based on possibleAggregateException AggregateException or null

Creates a started tasks which will get a completed state after the specified amount of time.

Proceeds with those task results which have not faulted while computing. Faults are logged and isolated. Resulting task fault policy: never faults, even if all input task fail. Resulting task cancellation policy: only cancels when ALL the input tasks have been canceled.

Runs an async while loop for the condition.

If in the critical code we're afraid that certain tasks might never end, this imposes a time limit on them, completes the await and drops the remaining activity free (with reporting an error). WARNING! This does not cancel the underlying task! It's up to you to pass it a proper /. This method is to ensure that even if the task gets stuck forever and fails to obey the cancelation (in a reasonable time), your code will still be able to proceed.

The task we wanted originally to await. Will return it in the fast case. Will be included with the failure message to identify the point. The full failure message also reports the actual time limit. Should be a complete sentense. Example: "Timed out processing the external changes.". The maximum amount of time to be awaiting for the task. This value will be included with the failure message. Logs time limit violations into this logger (or into the default logger if omitted). Level for messages which go into the logger. Would be errors by default. Returns the task result, if we awaited it successfully (for an overload with a result). Promotes the underlying cancelation/fault exceptions. If the underlying task isn't canceled in time and the time limit is hit, returns a canceled task.

A side-task to report an error in case the time limit has been hit — if the time-limited task gets canceled, and the user task is still running.

Makes sure that when you await the task, your awaiting code will be executed really asynchronously, not within the same call stack. This prevents two sync cases: (1) If the task is already completed, normally your code would be executed without any awaiting at all, all in one function. (2) When the task completes at last, your code might be executed inline with its completion, on the same call stack as the completion code. This might lead to unexpected deep recursion or unwanted execution under someone's lock (if, for example, that were a :: under a lock).

A method with LINQ's -like usage pattern which acts like PLinq's in that it executes mappers in parallel on the thread pool. Difference with LINQ: parallel execution, output items not in the same order as input. Async. Difference with PLinq: uses our task thread pool, shares with other tasks, does not overcommmit CPU regardless of how many of them you call. Batches execution of multiple cheap items on the same task unit to reduce scheduling overhead, but yields from time to time to allow other tasks execute. Shares our limited-to-numer-of-physical-threads task pool with other tasks, yields to let execute other tasks from time to time.

Name intentionally different from the other overload, otherwise it tends to treat tasks as just synchronous types.

Lowest level for background task.

Low level for non-urgent tasks.

Most common priority in system. Used in . When you don't need fast response, use this activity.

Intermediate level. Until this priority (inclusively) tasks are executed synchronously in Unit Tests.

For urgent tasks. Starting with this priority tasks are executed asynchronously (if not invoked with RunSynchronously()) in Unit Tests.

Highest priority

Allows to limit the number of async activities to be executed in parallel, with asynchronous waits for the available resources.

The current count of free objects, modified under .

The queue of waiting parties when is zero and there's still demand, modified under .

Awaits for the semaphore resources to be available and claims one resource, then invokes the and executes its chain of tasks, then releases the semaphore and completes the returned task with the result of the 's task.

Awaits for the semaphore resources to be available and claims one resource, then async-returns. Releases the semaphore when the lifetime terminates. If the lifetime terminates while awaiting, releases immediately and throws. TODO: ideally, should propagate lifetime to awaiting for semaphore, but that needs thorough writing

Waits to take the semaphore, asynchronously, and yields a token to be used with the using(){} construct to release the semaphore. This overload supports the async/await syntax.


            using(await sema.UsingSemaphoreAsync())
            {
              …
            }

Indicates that this class/method is safe for multithreaded usage. If class marked with "ImmutableAttribute" thread-safety is implicit. If certain methods of class are thread-unsafe (e.g. iterators in synchronized dictionaries), you can annotate this methods with

Indicates that class/method requires additional external synchronization

This mark is used by our tools like dotTrace and dotMemory to mark stack traces which format differs a little from the format of a stack trace in the Exception and could also starts with some product specific data. String ended with this mark recognized by Stack Trace Explorer as a stack trace and is shown by it automatically. See usages for details.

Represents a concurrent property with a value of type . The primary purpose of this interface is to linearize all events to avoid concurrent execution of subscriptions.

The type of the value.

Gets the current value of the property.

Subscribes to receive updates of .

No concurrent invocations (per subscriber): a single subscriber’s callback never overlaps with itself. Across subscribers: different subscribers may be invoked in parallel and not in subscription order. Coalescing: intermediate updates may be skipped; each subscriber will eventually observe the latest value. Lifetime: when ends, the subscription is disposed and no further callbacks occur. Controls the subscription’s lifetime. Callback invoked with the updated value.

Gets or sets the current value of the property. Setting Value is equivalent to calling .

Sets a new value unconditionally, and notifies listeners if there is no other notification occurring at the same time. This method is functionally equivalent to but does not check the current value before setting.

The new value to set.

Atomically sets the value to if the current value is equal to , and notifies listeners if no concurrent notification is in progress. This method ensures that if multiple threads set values concurrently, only one thread will trigger event callbacks at a time. Intermediate values might not be observed by listeners. For instance: The value changes from A to B, then back to A. Some subscribers might miss the intermediate change to B. Despite this, subscribers are guaranteed to eventually observe the latest value. Note that the callback may not execute on the same thread as the setter.

The expected current value. The new value to set if the current value matches . true if the value was updated successfully; otherwise, false.

Validates collections by preventing certain values from being added or removed. Note that for the validator to attach, the original values must all pass the validation.

Makes a readonly collection. All the legitimate modifiers must pass the as an argument. If the is invalid, an exception is thrown.

Ensures the is modified only on the given .

Makes a readonly collection. All the legitimate modifiers must pass the as an argument. If the is invalid, an exception is thrown.

Makes a readonly list. All the legitimate modifiers must pass the as an argument. If the is invalid, an exception is thrown.

Ensures the is modified only on the thread this function was called on.

Gets whether anyone is sinking this signal at all. If not, you can skip preparing the event args and firing the event altogether.

A simple base implementation for objects which handles most of the members but for the critical ones. Does not support undelying properties for signals and before-change eventing.

Take out the fallback logger (when not given externally). Shouldn't have a static field in the Property class itself, because there would be multiple instances. Shouldn't be calling into the logger every time, since it's a generic type and it goes thru the GetTypeNameWithoutGenericArgs allocating path.

Collection of reasons used to allow/ suppress something.

Type of reason. Normally string is used

Name of the instance. Used for debugging/ logging purposes

Property indicating if there's any active reasons. Fired on any thread.

First reason in the list. Used for better diagnostics. Fired on any thread.

Adds reason for the

Period of time the takes place Reason itself

Returns all the reasons active for the moment.

Active reasons

Identity function that always returns the same value that was used as its argument.

Thrown when a suggested value fails to pass the validation.

Represents a simple thread-safe cache that stores items by key until there is any active "usage". Each accessor should provide usage-time to get any item by key. Cache guarantees item is stored in cache until all related lifetimes (item is requested with) are terminated.

The type of keys used to access items in cache. The type of items stored in cache.

The root lifetime of the cache itself.

Represents a union of lifetimes that is "alive" until all s of the union are terminated. Exposes a common lifetime for all united lifetimes. NOTE: TotalLifetime will be terminated immediately (without waiting all prolongations) if "Source" lifetime will be terminated. So "Source" lifetime as a guard-lifetime, eg. shell or solution one

Represent an enumerable part of the array without creating new instance of the colleciton and copying data to it

Initial array. Represents the index in the array at which part begins. The part elements number.

Special ctor for .

Creates chunk array of given .

The count of array elements The mode how ChunkArray works for details

Creates chunk array from .

Creates chunk array from with optimal number of (re)allocations.

Resizes chunk array (actually creates new one and performs shallow copy of original content) similar to .

IMPORTANT! DO NOT USE original array after resize.

Guaranties that any data are not allocated in Large Object Heap. Can lead performance losing because of using ChunkArray as internal data structure. If an array element is bigger than 84500 bytes it is allocated in LOH in any case.

Tries to keep user and internal data out of Large Object Heap but if array size is too big allocates the internal array of chunks in the LOH. If an array element is bigger than 84500 bytes it is allocated in LOH in any case.

If is false and is returns the same instance, if no - makes a copy

List split to chunks to avoid allocations in LOH or to avoid allocating an array bigger than 2GiB if manual chunk size is specified. The size of a chunk is automatically calculated depending on the size of

The number of elements that the new list can initially store. If the capacity will be set to a chunk size. The maximum size of a chunk in bytes. The real size will be equal to the nearest lesser 'pow' of 2. The default value is 84500 bytes to prevent allocating chunks in LOH. If true such operations as , , are allowed, they are dangerous because since contains huge elements amount they can be very slow. Also contradicts purpose because array to copy into will be allocated in LOH. The number of elements that the new list can initially store. If the capacity will be set to a chunk size. The maximum size of a chunk in bytes. The real size will be equal to the nearest lesser 'pow' of 2. The default value is 84500 bytes to prevent allocating chunks in LOH. Initializes a new list that contains elements copied from the specified collection The number of elements that the new list can initially store. If , at least one chunk is created. Initializes a new list that contains elements copied from the specified collection and has sufficient capacity to accommodate the number of elements copied. The number of elements that the new list can initially store. If , at least one chunk is created.

Removes all elements from the

is set to 0, and references to all references to objects contained in the collection are also released. Capacity remains unchanged. To reset the capacity of the , call the method. This method is an O(n) operation, where n is Count.

Removes elements from the in a specified range

In opposite to this method keeps unchanged. This method is an O(n) operation, where n is Count.

Sets the capacity to the actual number of elements in the , if that number is less than a threshold value.

If false and is only a little bit bigger than , does nothing.

Extends the list to have elements.

All existing elements stay unchanged and new ones will be initialized with the default value of .

DO NOT USE IT ChunkList is introduced to avoid allocations in LOH and is used to hold very big number of items, to store this data will be allocated in LOH. Unfortunately this method is already used in the code

DO NOT USE IT ChunkList is introduced to avoid allocations in LOH and is used to hold very big number of items, removing an item will be quite a slow operation. Unfortunately this method is already used in the code

DO NOT USE IT ChunkList is introduced to avoid allocations in LOH and is used to hold very big number of items, inserting an item will be quite a slow operation. Unfortunately this method is already used in the code

The minimum number of elements that the new list can initially store, the real capacity depends on the calculated chunk size. If '0' one chunk of automatically calculated size is created. The maximum size of a chunk in bytes. The real size will be equal to the nearest lesser 'pow' of 2. The default value is 84500 bytes to prevent allocating chunks in LOH. The minimum number of elements that the new list can initially store, the real capacity depends on the calculated chunk size. If '0' one chunk is created. If true such operations as or are allowed, they are dangerous because since contains huge elements amount they can be very slow. Also contradicts ChunkStack purpose because array to copy into will be allocated in LOH. The maximum size of a chunk in bytes. The real size will be equal to the nearest lesser 'pow' of 2. The default value is 84500 bytes to prevent allocating chunks in LOH. The minimum number of elements that the new list can initially store, the real capacity depends on the calculated chunk size. If '0' one chunk is created.

Gets the number of elements contained in the .

The number of elements contained in the .

Gets a value indicating whether access to the is synchronized (thread safe).

if access to the is synchronized (thread safe); otherwise, . In the default implementation of , this property always returns .

Gets an object that can be used to synchronize access to the .

An object that can be used to synchronize access to the . In the default implementation of , this property always returns the current instance.

Removes all objects from the .

Determines whether an element is in the .

The object to locate in the . The value can be for reference types. if is found in the ; otherwise, .

Copies the to an existing one-dimensional , starting at the specified array index.

Copies the elements of the to an , starting at a particular index.

The one-dimensional that is the destination of the elements copied from . The must have zero-based indexing. The zero-based index in at which copying begins. is . is less than zero. is multidimensional.-or- does not have zero-based indexing.-or-The number of elements in the source is greater than the available space from to the end of the destination .-or-The type of the source cannot be cast automatically to the type of the destination .

Returns an enumerator for the .

An for the .

Returns an enumerator that iterates through the collection.

An that can be used to iterate through the collection.

Returns an enumerator that iterates through a collection.

An that can be used to iterate through the collection.

Sets the capacity to the actual number of elements in the , if that number is less than 90 percent of current capacity.

If false and the Capacity of the underlying data structure is only a little bit bigger than , does nothing.

Returns the object at the top of the without removing it.

The object at the top of the . The is empty.

Removes and returns the object at the top of the .

The object removed from the top of the . The is empty.

Inserts an object at the top of the .

The object to push onto the . The value can be for reference types.

Copies the to a new array.

A new array containing copies of the elements of the .

Enumerates the elements of a .

Releases all resources used by the .

Advances the enumerator to the next element of the .

if the enumerator was successfully advanced to the next element; if the enumerator has passed the end of the collection. The collection was modified after the enumerator was created.

Gets the element at the current position of the enumerator.

The element in the at the current position of the enumerator. The enumerator is positioned before the first element of the collection or after the last element.

Gets the element at the current position of the enumerator.

The element in the collection at the current position of the enumerator. The enumerator is positioned before the first element of the collection or after the last element.

Sets the enumerator to its initial position, which is before the first element in the collection. This class cannot be inherited.

The collection was modified after the enumerator was created.

HashSet wrapper which exposes only read operations . Use for better GC optimization.

A writable array accessor that can be converted into an instance without allocating extra memory. If we have the previous results array, we can create a new builder over it, and if running the builder results in exactly the same collection, then the original one will be returned without allocating extra memory.

Valid until the builder has been created. Negative means default.

Valid only when is NULL. Holds the original underlying collection if so. All of the operations, as long as they are making the same collection as this one, make no allocations. If it keeps to the end and the count matches, then the original array is returned AS IS. As soon as any operation tries to set a conflicting value, or the final count does not match, gets allocated, takes the already “written” prefix from this collection, and this one is forgotten.

Currently “written” length of the .

Reuses the existing array, if given and possible. Capacity applies when we decide we need to create a new builder.

Gets or sets the length of the internal array. If a new builder has been created, gets or sets from the builder directly. Otherwise, gets either the underlying array capacity or the capacity for the new builder; sets the capacity for the new builder.

Gets or sets the number of items in the array.

The number of items in the array.

Gets or sets the item at the specified index.

The index of the item to get or set. The specified index is not in the array. The item at the specified index.

Adds the specified item to the array.

The object to add to the array.

Adds the specified items to the end of the array.

The items to add to the array.

Adds the specified items to the end of the array.

The items to add to the array.

Adds the specified items that derive from the type currently in the array, to the end of the array.

The items to add to end of the array. The type that derives from the type of item already in the array.

Adds the specified items to the end of the array.

The items to add to the array. The number of elements from the source array to add.

Adds the specified items to the end of the array.

The items to add to the array.

Adds the specified items to the end of the array.

The items to add to the array. The number of elements from the source array to add.

Removes all items from the array.

Determines whether the array contains a specific value.

The object to locate in the array. if the object is found; otherwise, .

Copies the current contents to the specified array.

The array to copy to. The index to start the copy operation.

Gets an object that can be used to iterate through the collection.

An object that can be used to iterate through the collection.

Determines the index of a specific item in the array.

The item to locate in the array. The index of if it's found in the list; otherwise, -1.

Determines the index of the specified item.

The item to locate in the array. The starting position of the search. The index of if it's found in the list; otherwise, -1.

Determines the index of the specified item.

The item to locate in the array. The starting position of the search. The number of elements to search. The index of if it's found in the list; otherwise, -1.

Determines the index for the specified item.

The item to locate in the array. The index at which to begin the search. The starting position of the search. The equality comparer to use in the search The index of if it's found in the list; otherwise, -1.

Inserts an item in the array at the specified index.

The zero-based index at which to insert the item. The object to insert into the array.

Gets a read-only reference to the element at the specified index.

The item index. is greater or equal to the array count. The read-only reference to the element at the specified index.

Determines the 0-based index of the last occurrence of the specified item in this array.

The item to search for. The 0-based index where the item was found; or -1 if it could not be found.

Determines the 0-based index of the last occurrence of the specified item in this array.

The item to search for. The starting position of the search. The 0-based index into the array where the item was found; or -1 if it could not be found.

Determines the 0-based index of the last occurrence of the specified item in this array.

The item to search for. The starting position of the search. The number of elements to search. The 0-based index into the array where the item was found; or -1 if it could not be found.

Determines the 0-based index of the last occurrence of the specified item in this array.

The item to search for. The starting position of the search. The number of elements to search. The equality comparer to use in the search. The 0-based index into the array where the item was found; or -1 if it could not be found.

Removes the specified element.

The item to remove. if was found and removed; otherwise, .

Removes the item at the specified index from the array.

The zero-based index of the item to remove.

Reverses the order of elements in the collection.

Sorts the contents of the array.

Sorts the elements in the entire array using the specified .

The to use when comparing elements. is null.

Sorts the contents of the array.

The comparer to use for sorting. If comparer is , the default comparer for the elements type in the array is used.

Creates a new array with the current contents of this .

A new array with the contents of this .

Hints on what size the collection is expected to have. Fluent, mutable. Does not alloc anything immediately until we start creating the new builder. Would save mem/copy if we fall off the existing array and have to create a new builder and you exactly predict its writing size. Otherwise, will alloc, but won't fail.

Allows to set a nondefault comparer. Fluent, mutable.

Returns an enumerator that iterates through the array.

An enumerator that iterates through the array.

Returns an enumerator that iterates through the array.

An enumerator that iterates through the array.

Gets a value that indicates whether the is read-only.

if the is read-only; otherwise, .

Creates a new empty (!) builder which has the original array as a backing collection and keeps it as long as you're adding the same items. If you are creating the same array once again, there will be no new array allocated.

Implementation of IList/IReadOnlyList from array and the amount of first items actually used to store the data. Provides support for turning various array-based collections into IList/IReadOnlyList instances with allocation-less implementation of enumeration.

Use this only for building array instances

Base for all space-optimized hash-maps with only 2 bits overhead for each entry. Implements so called "open-addressing" hash-maps.

key class value class Class of internal storage. Can be plain array of TData or e.g. packed array for memory optimization. Entry in storage.

Removes all specified values for given key. Effectiveness of removal depends of implementation of - for hashset, time-complexity will be linear O(n), where n - number of values in map, corresponding to .

Collection of distinct (as per ) elements with O(1+maxLoadFactor) asymptotic time for item's addition, removal and searching and O(1/maxLoadfactor) space usage. Actual number of additional heap space for each element (not considering loadFactor's reseve) is 2 bits (comparing to 64 bits in ). So for each element stores 32 bits for item's reference and 2 bits for state (OCCUPIED, FREE, REMOVED). This set is little bit slower than , so main use case is when you need to retain big set with small items (relative to number of bytes held by item) in memory for a long time (e.g. caches) and you want to economize memory usage.

Type of item

In-place quick sort with random pivot and without recursion.

Sort is in-place, use it carefully if concurrent access to is possible.

Due to performance reason the specific implementations for concrete types are provided:
*
*
*

See benchmarks in class comments.

In-place quick sort with random pivot and without recursion.

Method is introduced for performance reason, it returns instead of and keep all subsequent calls "class" not "interface"

In-place quick sort with random pivot and without recursion.

Method is introduced for performance reason, it returns instead of and keep all subsequent calls "class" not "interface"

In-place stable (merge) sort. Complexity = O(N log N) Memory = O(N)

Sort is in-place, use it carefully if concurrent access to is possible.
Allocates additional chunked array of the same size (no LOH allocations).
The only estimated progress is reported, not necessary reaches 100%.

Due to performance reason the specific implementations for concrete types are provided:
*
*
*

See benchmarks in class comments.

In-place stable (merge) sort. Complexity = O(N log N) Memory = O(N)

Sort is in-place, use it carefully if concurrent access to is possible.
Allocates additional chunked array of the same size (no LOH allocations).

Due to performance reason the specific implementations for concrate types are provided:
*
*
*

See benchmarks in class comments.

In-place stable (merge) sort. Complexity = O(N log N) Memory = O(N)

Method is introduced for performance reason, it returns instead of and keep all subsequent calls "class" not "interface".

In-place stable (merge) sort. Complexity = O(N log N) Memory = O(N)

Method is introduced for performance reason, it returns instead of and keep all subsequent calls "class" not "interface".

In-place stable (merge) sort. Complexity = O(N log N) Memory = O(N)

Method is introduced for performance reason, it returns instead of and keep all subsequent calls "class" not "interface".

In-place stable (merge) sort by keys. Complexity = O(N log N) Memory = O(N)

Sets temporary store (either ChunkArray or ChunkList) in context of current thread.

IMPORTANT! Caller MUST prevent provided store from being GC-ed, because internally temporary store weak referenced.

This is advanced technique used for example by parallel sorter.

Allows to override per-item comparers. NULL means use default comparer. If you want all NULLs, reuse the shared instance at .

Something like , but without the associated overhead of allocations and span-creating logic.

Returns a prime number which is >= desiredCapacity and very close to desiredCapacity (within 11% if desiredCapacity >= 1000).

If this immutable stream is but a view over a sequential stream, attempts to create a direct clone of the sequential stream for best-performance sequential reading (without memory caching overhead to implement seekability). Otherwise, just reads the immutable byte stream as it is.

Represents the exception that is thrown when you try to change the value of a read-only entity.

Dangerous! Takes an existing stream and guises it as if immutable. Make sure the data in the stream is really not modified, and all the clones yield the same data. This class assumes you can produce as many independent reading streams as needed, so it makes a new instance for each clone, and maps position directly to the implementation.

Represents a dictionary to map keys to collections of values. This dictionary is a implementation of `Dictionary{TKey, List{TValue}}` that is optimized: 1. Not to allocate lists on the heap for each key; 2. To use contiguous memory (arrays) to store both keys and values - this makes this dictionary pooling-friendly. Up-to-date implementation and extended docs are here: https://github.com/controlflow/multivaluedictionaryslim Trade-offs: 1. Generally it consumes (and wastes) more memory. Individual `List{TValue}` instances grow when needed, while this dictionary grows the whole array for values. 2. This dictionary also uses 1 `int` per each `TValue` stored (for linked list). Probably not a problem until you store a LOT of values for just a few keys. 3. Values are stored as a linked-lists - so no list operatios support, only enumeration + count. 4. It is more likely for values array to make it into LOH. 5. Key removal/values clear is a O(n) operation if is a reference type, because of the need of linked list traversal to clear the managed references.

Type of keys Type of values

0-based index of next entry in chain: -1 means end of the chain (no more entries with the same hash code). Also encodes whether this entry _itself_ is part of the free list by changing sign and subtracting 3, so -2 means end of free list, -3 means index 0 but on free list, -4 means index 1 but on free list, etc.

0-based index in list where the first value corresponding to this is stored.

0-based index in list or -1 for incomplete (empty) entries. At this index the value at this position is a of values.

Simple data structure to allow reference type object pooling to avoid memory traffic. For most of the memory traffic issues around collections use just make use of pooled collections like or . How to use: * Use to do the allocation via factory provided to constructor. * Use to return object back to the pool or when you decided not to allow later reuse of the object (object became to big?). To monitor memory leaks uncomment DETECT_LEAKS and TRACE_LEAKS in this file.

The object type you need to pool

Defines a fixed-size collection with the same API surface and behavior as an "SZArray", which is a single-dimensional zero-based array commonly represented in C# as T[]. The implementation of this collection uses segmented arrays to avoid placing objects on the Large Object Heap.

The type of elements stored in the array.

Calculates the maximum number of elements of size which can fit into an array which has the following characteristics: - The array can be allocated in the small object heap. - The array length is a power of 2.

Calculates a shift which can be applied to an absolute index to get the page index within a segmented array.

The number of elements in each page of the segmented array. Must be a power of 2. The shift to apply to the absolute index to get the page index within a segmented array.

Calculates a mask, which can be applied to an absolute index to get the index within a page of a segmented array.

The number of elements in each page of the segmented array. Must be a power of 2. The bit mask to obtain the index within a page from an absolute index within a segmented array.

Lightweight Dictionary{TKey,TValue} that do not stores hash code, assumes hash code and key equality computations are fast. Only keys implementing IEquatable{T} are supported.

Lightweight HashSet{T} that do not stores hash code, assumes hash code and equality computations are fast. Only values implementing IEquatable{T} are supported.

Represents collection of items that doesn't create heap objects unless items are added. Should only be used in rare scenarios where it's critical to reduce the amount heap allocations to get the T[] array or IList/IReadOnlyList instances of the size unknown in advance. The indexing and enumerations operations over this collections are not efficient in terms of CPU, so it's better to stick with simple .Add() + .ReadonlyList()/.ToArray() scenarios. The type is made 'ref struct' to avoid storing it inside the field and capturing it into closures, however it is still possible to pass and return it by value which you should avoid give the size of the struct.

Gets the number of elements contained in the .

This is basically a lossy cache of strings that is searchable by strings, string sub ranges, character array ranges, pairs of not yet concatenated strings, pointer to utf8 bytes etc.

Hash code of the entry

Full text of the item

The offset bias value used in the FNV-1a algorithm See http://en.wikipedia.org/wiki/Fowler%E2%80%93Noll%E2%80%93Vo_hash_function

The generative factor used in the FNV-1a algorithm See http://en.wikipedia.org/wiki/Fowler%E2%80%93Noll%E2%80%93Vo_hash_function

0 return means "do not intern this string, only materialize"

Implements a byte stream over a block.

A strongly-typed wrapper for untyped user data which is just an object. You need this when passing user data along the call chain without messing up the objects.

Implementation of that holds value forever until method is called.

Base class for both and

Implementation of that hold value on weak reference. Additionally, value is put into . So weak reference will survive garbage collections until its value is evicted from cache. Cache is being touched not every time you invoke but every [cacheTouchFrequency] time. This allows to mix LRU and LFU policies together and inrease performance.

type of value Cache can contains more general type than Type of producer function's parameter

Cache can contains more general type than

Internal helper class for cache statistics gathering. To collect statictics, compile with JET_MODE_STATISTICS #define.

Fixed-size cache with only one element for bucket (hashcode % length) retained. http://en.wikipedia.org/wiki/CPU_cache

Trying to get element from cache. If nothing found, creates from provider.

Any inheritor of or itself Key in cache Function that generates value in case when key isn't in cache Value either from cache or generater by producer

Trying to get element from cache. If nothing found, creates from provider. This method is useful in case when you don't want to produce additional closure and lambda for functions with 2 parameters

Additional producer's parameter type Any inheritor of or itself Key in cache Additional producer's parameter Function that generates value in case when key isn't in cache Value either from cache or generater by producer

Wrapper over object. Typical usage is .

type of object

Set object's value

Resets object's value to default

Get current value in wrapper. If it's null (e.g. weak reference evicted) returns null

Cached value with nonparameterized producer

type of object

Get current value and if it's null then produce value (using producer func)

Cached value with parameterized producer. Use it in case you don't want to create tons of closure.

type of object type of addtitional paramater to producer function

Get current value and if it's null then produce value (using producer func with parameter)

Version of GetOrCreate that returns boolean value which designates whether value was created by producer or obtained from cache

gotten or created result Invokes after values is created and is set into cachedValue true if value was created by producer, false - value was in cache already

Get current value, waiting if current value is being created by "GetOrCreate" method

Creates wrapper that contains weak object inside. To prevent fast weakref eviction, newly created objects are placed into . Cache is touched after each invocation of . If weak reference is evicted (that means object is evicted from cache too) and one invokes , producer function is used to create object.

object's type type of objects in cache, can be more general than function that creates object cache that enlarges weakref lifetime Optional. If present, object is set to this value. Otherwise, object is set to null and will be initialized by producer after first use of Newly created wrapper with weak reference

object's type producer parameter's type type of objects in cache, can be more general than function that creates object cache that enlarges weakref lifetime Optional. If present, object is set to this value. Otherwise, object is set to null and will be initialized by producer after first use of Newly created wrapper with weak reference

Creates wrapper around object with hard reference.

Optional. Initial value of hard reference. Null by default. Newly created wrapper with hard reference

Creates wrapper around object with hard reference.

Optional. Initial value of hard reference. Null by default. Newly created wrapper with hard reference

Returns true if cached object has value "right now" (no need to invoke producer).

type of cached object object's wrapper true if return true

Sets value of object via functor only in case it's null ( returns false). This method is thread-safe.

type of cached object type of functor - inheritor of object's type (to support functor's covariance) object's caching wrapper value producer, is invoked only when current value is null

Sets value of object via functor only in case it's null ( returns false). This method is thread-safe. Functor is parametrized with additional parameter to avoid construction of closure (like it would have been with )

type of cached object functor's additional parameter type type of functor - inheritor of object's type (to support functor's covariance) object's caching wrapper value producer, is invoked only when current value is null functor's additional param

Cache represented by fixed-size dictionary. The behavior is the same as but dictionary doesn't grow infinitely. When cache is full, newest elements is put into it, evicting old one (latest or least frequently used, depending on policy).

Usually cache gets provider (func : TKey - TValue) by constructor, but this interface contains methods that allow to specify arbitrary provider

Interface supports writing "through" cache (like CPU writes to RAM through its L1-L2-L3 cache)

Usually the place from where provider takes values. Like RAM in CPU - Cache - RAM interop

Cache that has sole purpose to increase the lifetime of weak reference. Used in pair with . You MUST dispose it by lifetime or other way

Notify this cache that item was accessed somehow. Cache can react to this event by relocating item is LRU queue, set last access time, increase use count, etc.

Remove item from cache

Clear cache, remove all item.

Returns true if cache contains given item.

Returns current number of elements in cache

Manually starts eviction procedure. Cache could evict entities by its own rules, (e.g. evict all items with last access time more than 30 sec)

Number of elements evicted

Fixed-size cache for clients which use to store values. Every time outer JetWeakReference accessed , client must invoke method. This promotes given value to the head of the LRU queue. If queue is full and promoting element is new (queue hasn't cointain it before), least recently used element is getting removed from the queue and number of hard links to this value is decreased by one. User can start timer thread that will evict entries with too old last access time. WARNING!!! You MUST dispose this object, because it has reference on itself by Timer thread.

Object's type. lifetime is going to be increased by this cache

Creates new cache. Timer is started only when is positive.

Lifetime of this cache Maximum number of elements in cache Optional. Optional (default is zero). After given number of milliseconds, items in cache are concidered outdated and can be replaced either by timer thread or manual invocation of method Number of items that will survive eviction even if they are outdated

Unlimited cache that evicts their items by inactivity time using a timer It stores and updates access time for each item on TryGetFromCache() and AddToCache() methods

Called after the specified key is evicted from cache. Called from timer thread.

Lifetime for managing timer Eviction attempts interval. Min is 100 ms Max age of item. If item is older it will be evicted. Min is 100 ms. Must be greater than custom comparer

Murmur Hash v3, which is a public domain algorithm.

Return leftmost index of found item or binary complement (~) of insertion index

non-decreasing sorted array lower index of search (inclusive) high index of search (inclusive) value to search

Return leftmost index of found item or binary complement (~) of insertion index non-decreasing sorted array value to search

Remove duplicates if array is sorted and returns length of new array

new length

O(n)

Returns an array which has the NULL items filtered out. If there were none such, returns the original array.

Returns an array which has the NULL items (of a nullable value type) filtered out. Lifts the nullable modifier.

Returns an array which has the NULL items filtered out. If there were none such, returns the original array.

Returns an array which has the NULL items (of a nullable value type) filtered out. Lifts the nullable modifier.

Reuses the builder's internal array if its size fits (like ), or makes a new one if not. UPD: in the new Immutable Array native API, it's now !

A specialized ext method to flatten an array of arrays. Why not use SelectMany on IEnumerable: no boxing, single allocation of the target array of the right size. Why not name SelectMany: would be a mess in completion when you import the wrong extension method and ain't getting one from LINQ.

Immutable array's NULL state is not equal to NULL and cannot be easily checked if we have it in nongeneric context, so we try enumerating, when enumeration fails we try to tell if it were because of the NULL state.

Gets the index of the search hit, should there be any. In case of a search miss, throws.

If the search found an item, returns that item. Otherwise, throws.

If you're maintaining a sorted array, use this index for inserting new elements.

If you're maintaining a sorted array, use this index for inserting new elements. Makes stable order if you're doing binsearch with .

Gets whether the search found any results.

The target, if the search had a hit. Otherwise, the nearest item below the target. If the first item in the list is above the target, throws an exception.

The target, if the search had a hit. Otherwise, the nearest item below the target. If the first item in the list is above the target, returns that item anyway. Throws on an empty list.

The target, if the search had a hit. Otherwise, the nearest item below the target. If the first item in the list is above the target, returns -1.

The target, if the search had a hit. Otherwise, the nearest item above the target. If the last item in the list is below the target, throws an exception.

The target, if the search had a hit. Otherwise, the nearest item above the target. If the last item in the list is below the target, returns the number of items in the list (the first free index).

The target, if the search had a hit. Otherwise, the nearest item above the target. If the last item in the list is below the target, returns that item anyway. Throws on an empty list.

The target, if the search had a hit. Otherwise, the nearest item below the target. If the first item in the list is above the target, throws an exception.

The target, if the search had a hit. Otherwise, the nearest item below the target. If the first item in the list is above the target, returns that item anyway. Throws on an empty list.

The target, if the search had a hit. Otherwise, the nearest item above the target. If the last item in the list is below the target, throws an exception.

The target, if the search had a hit. Otherwise, the nearest item above the target. If the last item in the list is below the target, returns that item anyway. Throws on an empty list.

Inserts an item into a sorted array so that to maintain the sorting order.

The index the item was inserted at (equals to ).

Searches a one-dimensional sorted for a value using the binary search algorithm. The desired item is identified by its so-called key given in , and a transformation is defined as for getting a key out of each list item. The comparison (and list sorting requirement) applies to these keys derived from the items. Optionally, the comparer could be overridden. This is recommended for custom value types to avoid boxing, unless they're . The advantage of this method over the one using a locator, , is that it can work on cached delegates/comparers and does not require creating a closure for each new location session. Also, there's no locator left-right argument confusion.

Type of the actual items in the list. Type of the so-called key by which the items are sorted and located in the list. This could be either an actual field/property of the item, or a completely synthetic value calculated on the item. The list of items to search. Must be sorted by their keys. Key we're looking for. If it is equal to a key of some item in the list, that item is returned as a search result. If no items correspond to the key, the result points “in between” array items, see return value members for telling this cases apart or using the found location, for example, . Starting index of the list range to search in. 0 is the default. Length of the list range to search in. -1 is the default and means that the whole list must be searched. A transformation which produces a key for any of the list items. Items are sorted by these keys, and keys are used for locating items. This could be either an actual field/property of the item, or a completely synthetic value calculated on the item. In performance-critical scenarios, cache this delegate. Normally it's a static method and thus does not require a new closure each time. A custom comparer over item keys, if needed. If omitted, the standard comparer is used. If there're multiple equal items in the list, which one of them should be taken for a hit. The search result which can tell you if any item was hit, at which index to insert the new item, what's the closest index before/after the search target, and so on.

Searches a one-dimensional sorted for a value using the binary search algorithm. This overload does comparison right on the items. If the list is sorted by just one property of the item, use the overload with item-key metaphor. Optionally, the comparer could be overridden. This is recommended for custom value types to avoid boxing, unless they're . The advantage of this method over the one using a locator, , is that it can work on cached delegates/comparers and does not require creating a closure for each new location session. Also, there's no locator left-right argument confusion.

Type of the actual items in the list. They're the sorting keys of the list as well. The list of items to search. Must be sorted by their keys. Item we're looking for, which itself is also the sorting/search key. If it is equal to some item in the list, that item is returned as a search result. If no items are hit, the result points “in between” array items, see return value members for telling this cases apart or using the found location, for example, . Starting index of the list range to search in. 0 is the default. Length of the list range to search in. -1 is the default and means that the whole list must be searched. A custom comparer over items, if needed. If omitted, the standard comparer is used. If there're multiple equal items in the list, which one of them should be taken for a hit. The search result which can tell you if any item was hit, at which index to insert the new item, what's the closest index before/after the search target, and so on.

Searches a one-dimensional sorted array for a value using the binary search algorithm. This overload does comparison right on the items. If the list is sorted by just one property of the item, use the overload with item-key metaphor. Optionally, the comparer could be overridden. This is recommended for custom value types to avoid boxing, unless they're . The advantage of this method over the one using a locator, , is that it can work on cached delegates/comparers and does not require creating a closure for each new location session. Also, there's no locator left-right argument confusion.

Searches an entire one-dimensional sorted for a value using the specified comparer.

The type of the elements of the list. The sorted list to search. The comparer to use when comparing elements. Locator should return: -1 when its argument is less than expected, 0 when equal, 1 when greater The index of the specified value in the specified array, if value is found. If value is not found and value is less than one or more elements in array, a negative number which is the bitwise complement of the index of the first element that is larger than value. If value is not found and value is greater than any of the elements in array, a negative number which is the bitwise complement of (the index of the last element plus 1).

Searches an entire one-dimensional sorted for a value using the specified comparer.

Searches an entire one-dimensional sorted for the index of a specific value.

The type of the elements of the list. The sorted list to search. The item to find.

Searches an entire one-dimensional sorted for a value using the specified comparer.

The type of the elements of the list. The sorted list to search. The comparer to use when comparing elements. Delegate should compare its parameter to the item you're looking for. Locator should return: -1 when its argument is less than expected, 0 when equal, 1 when greater

Looks up an item in a binary-search-ready (sorted) list which is being used as a dictionary (values stored in the list are associated with some kind of keys which you use for comparing items in the list). Returns the found item. If not found, creates a new item, insers into the list on the proper position to maintain sorting, and returns this new item.

Sorted list. The transformation for getting a key ot of an item stored in the list. If the item is not found, this functor is called to create a new item. The key whose item you would like to find in the list.

Looks up an item in a binary-search-ready (sorted) list which is being used as a dictionary (values stored in the list are associated with some kind of keys which you use for comparing items in the list), and removes it. Returns whether the item was found.

Sorted list. The transformation for getting a key ot of an item stored in the list. The key whose item you would like to find in the list.

Clone of for the case.