JetBrains.Platform.ComponentModel

Forces the compiler to add assembly references.

Gets the binder for the specific assembly.

Logic for binders, when they should complain on a missing assembly, and when they should not.

Helper for binding part catalog assemblies to assembly items, with for loading into Runtime.

Avoid requesting too many realizations for the same assembly.

Gets the assembly items known to this binder.

Only if assembly names are strictly equal.

If there is a strictly equal assembly name, uses that one. Otherwise, looks up the newest assembly (biggest version) with the same simple name.

Always looks up the newest assembly with the same simple name, even if we have an older version which exactly matches the request.

Filled on start with what we know initially, then completed on demand.

Filled on demand.

Filled on start, after that, accessed under lock-on-itself. Sorted by file name without ext case-insensitively. When entries are used, their path is set to NULL. When all the paths are used, the list is emptied.

Fallback to GAC, thread-safe.

Creates the disk-based assembly resolver. Gives the full list of resolvable assemblies on custom paths, plus possibly adds the GAC.

Original assemblies. At least disk paths MUST be given for every item. Names are optional. Whether to fallback-resolve into GAC when running out of , and how exactly. NULL means don't. NOTE: backwards-compatible option is . Don't fail if these assemblies are missing when trying to resolve them. Allows to redirect certain assembly versions: if asked for assembly version X, load version Y instead.

Helper for . Reads actual assembly names for all paths still left in the . Clears the list. Assumed to have a lock on that list.

When we first need name->path mapping, fills the dictionary with currently-known path->name mappings. NOTE that it's only those we know / touched, and most of them might still sit on .

The full name of the assembly as it were looked up (the key in the map is a simple name).

Disk path where the assembly were found (either added by path, or looked up in GAC). NULL when caching a failure.

Helper for binding part catalog assemblies to assembly items, in case we're running off the runtime assemblies.

Allows to unify assembly files, as realized on disk, by their unique assembly name. This is essential when you're loading runtime assemblies from them, otherwise your runtime types won't match.

Realizes your assembly item on disk, or extends the lifetime of an already-realized assembly item with the same name and returns its path.

Will exist at the given path for at least this lifetime. Don't delete yourself, might be shared. Assembly name and content. Path to the disk file for assembly.

Specifies the explicit subfolder name to place the file into. The file name is still taken from the item.

Registers a user-realized assembly item. Fails if already present.

The master unification manager which can share with a slave instance (e.g. running in another appdomain).

In master instance, writes the current realizations. Reading them with allows to reuse unified paths for allemblies already realized by the master instance.

In master instance, loads what's been yielded in a slave instance for later release by the master instance.

Loads the realizations already known in some master instance and saved with . Won't be freed by slave instance upon termination. In slave instance, if some realizations were made while running the slave instance, defers their release (and deletion) for the master instance. Example: slave instance running in appdomain, realizing and executing assemblies, can't release them because they're locked by the appdomain, but the master instance can after the appdomain is unloaded.

The first one is the DLL path, the rest are aux paths.

Allows to unify assembly files, as realized on disk, by their unique assembly name. This is essential when you're loading runtime assemblies from them, otherwise your runtime types won't match.

For assemblies which has been passed thru unification, and for which we know the mapping of the assembly name onto disk, installs an assembly resolver into the current appdomain.

Realizes your assembly item on disk, or extends the lifetime of an already-realized assembly item with the same name and returns its path.

Will exist at the given path for at least this lifetime. Don't delete yourself, might be shared. Assembly name and content. Path to the disk file for assembly.

Specifies the explicit subfolder name to place the file into. The file name is still taken from the item.

Registers a user-realized assembly item. Fails if already present.

Master shutdown, releases what's come from slave.

Reverts assembly realization when its locks are gone, or when the object ends. Has an option to tolerate locked files, e.g. for the Slave mode.

Default mode.

Slave mode. Means we load some perdefined

Watch for assembly resolve events, if fired for one of the given assemblies, realize it using the assembly unification and load.

The master unification manager which can share with a slave instance (e.g. running in another appdomain).

Allows to specify assembly version redirections for , for solving cases when an assembly points to another one but not of the version which we have available.

Knows how to bind an assembly to various real-life stuff.

Gets the name of the assembly which this binder binds.

If the assembly already resides on disk, returns its disk path.

Loads the metadata reader for this assembly. If you got a row of assemblies and a for them, it's better to use the master binder to create a , then call on it to load the assemblies by name, on the same loader in a row. This provides for the best perf and also manages metadata access lifetimes correctly.

Metadata loader's lifetime.

Loads the runtime assembly.

Gets the assembly contents as a stream.

Like an , but for a group of assemblies rather than for a single assembly.

Gets the collection of assemblies which are referenced from within the product assemblies but are non-critical and might be missing in certain local machine configurations. For example, full app packages would have references to all VS version assemblies, but only a machine with such VS installed would have them actually available for resolve. For an assembly in the list, it's not an error to be resolved into a NULL value. The lookup only favors assembly Simple Name and Version. Culture or signature are ignored when checking.

If the assembly already resides on disk, returns its disk path. Otherwise attempts to write the assembly to a disk location and return its path.

Loads the runtime assembly.

Gets the assembly contents as a stream.

Gets the immediately-available bindings of the assembly, without creating any secondary representations. I.e. if we have an assembly as an in-memory stream only, would write it out to disk and return the path, while this method only returns a stream. For an assembly that isn't available, the Result monad would have a failure; reading its raw value would give all possible representations as NULL. If called multiple times, the existing bindings aren't supposed to disappear, but new bindings might become available.

Tells how to bind metadata assemblies by name based on the .

Can create the real runtime instance of an attribute based on its catalog record.

Creates a group that passes an item only if all filters in the group pass it.

A filter that can be applied to a part catalog to limit the set of parts returned from the querying methods.

Applies the filter to a list of parts.

Gets whether the specific part type is passing the filter.

A filter which can be calculated on part catalog type traits, if the catalog knows how to track them. All common filters should support this to show good perf.

Gets the names of the traits that this filter requires.

ANDs a group of filters, providing for the Intersect operation.

Returns all of the filters originally submitted for this component, with other intersect-filters flattened into a plain list.

Gets a subset of that does not implement .

Gets the list of traits collected from those filters in that implement .

Creates a group that passes an item only if all filters in the group pass it.

Typed wrapper for the name of a part catalog trait.

The list of individual bool-result operations on traits whose results are ANDed.

Gives the number of traits taking part in all operations, for preallocing data structures.

Describes one operation on traits. The equality is a fast-check for whether this struct is NULL, for storing in FLLists.

Asserts there are traits, they're all in the same namespace, and gives that ns.

The item must have at least the given traits. Submitting an empty group makes a pass-all filter.

The item might only have the given traits off their namespace (but not required to); having any other traits from the same namespace is a no-match. All traits in this group must be in the same namespace. Submitting an empty group is an edge case (because there's no way to get the intended namespace without at least one trait), and the operation result is define to be a no-pass filter (rejects all parts).

The item must have at least one of the traits. Submitting an empty group is an edge case (can't run the any-of operation without items), and the operation result is define to be a no-pass filter (rejects all parts).

Gets the parts in this set. Previously, a set could have a live collection of part catalogs, but effectively this were not properly supported by the runtime, so now it's just the one catalog always. The wrapping interface is used for creating typed wrappers (Environment, Shell, etc catalog sets).

The one and only part catalog in this set. The parts set is constant and cannot change during runtime.

Gets the attribute argument value of any type by boxing it into an object. Part catalog types and arrays are handled correctly. NULL is also a valid value.

Gets the primitive value of an attribute argument, in case it's really a primitive value. If you plan on reinterpret-casting the return value, specify to ensure that it won't lose data. If omitted, the primitive value will be returned as is.

For an attribute argument of type , returns the source for that string.

For an attribute argument of type , returns the catalog type for that type.

Gets the type of the attr arg value.

This is the shortcut API for Assemblies.SelectMany(PartMembers) which tries to perform a single lookup instead of combining collections. Gets all of the part members in this catalog — all part members in all cataloged assemblies.

This is the shortcut API for Assemblies.SelectMany(PartTypes) which tries to perform a single lookup instead of combining collections. Gets all of the part types in this catalog — all part types in all cataloged assemblies.

Gets the list of cataloged assemblies. See on what are these.

Returns an interface to this catalog filtered by some criteria. The filtering only applies to parts, i.e. part types from cataloged assemblies, as returned from . Typical criteria are: has attribute, is in module zone.

Knows how to bind part catalog assemblies to various real-life stuff.

Gets the full name of the assembly without allocating heap memory.

Gets whether this assembly were originally intended for cataloging, were fully inspected, and has its part types, referenced assemblies, custom attributes and so on fully available. Besides these, the catalog will also have all the assemblies mentioned in process of cataloging (e.g. to return something from ), and those do not have these parameters defined.

For an assembly, gets the part members in this assembly — those that qualify for the part, i.e. got the or its derivatives on themselves. This assembly might also have non-part members known to this catalog, at least as constructors. Their 's will return this assembly, but this members list does not include them.

For an assembly, gets the part types in this assembly — those that qualify for the part, i.e. got the or its derivatives on themselves or one of their members. This assembly might also have non-part types known to this catalog, e.g. as part base/member/param types and so on. Their will return this assembly, but this types list does not include them.

For an assembly, gets the list of its assembly references.

Gets the simple name of the assembly without allocating heap memory.

Allocates the runtime object for the assembly name of this assembly. For operations which only need the assembly name text, use or .

For an assembly, gets the custom attributes of this assembly which are derived from the .

For an assembly, gets the custom attributes of this assembly which are derived from the and from .

Gets the real runtime object for this assembly. Uses .

For an assembly, gets the custom attributes of this assembly which are derived from the and from .

A custom attribute in the part catalog, either on a type or on an assembly.

Gets the arguments accessor.

Whether we know which .ctor was encoded for creation of this attr (e.g. there's no such info when getting it from Reflection rather then by reading metadata).

The type of the attribute.

Gets the arguments which were assigned upon creation of this attribute. This includes constructor positional parameters, field assignments, and property assignments.

The signature of the .ctor which is encoded for creation of the attr instance, if known. An empty array means the attr is to be created with an empty .ctor. If the .ctor is not known (see ), throws an exception.

Tries creating an attribute runtime instance if we got enough information. Should be OK if the attribute originates from a metadata reader and has , but with runtime type attributes this only works if a parameterless attribute .ctor is available.

Queries one of the by name.

The set of attribute arguments records the set of values which are applied in the code to the attr. These include: ctor positional parameters, ctor named parameters, fields, and properties. This property tells in which way an arg were assigned to the attr, so this can be used for constructing an attr runtime instance.

Gets the array value of the attribute argument, throws for any other specific type, including a NULL value.

Gets the primitive value of the attribute argument coerced to the requested type, if coercing could be done without losing data.

Gets the value of the attribute argument of any type boxed as an object. This method won't fail for any data type, but incurs boxing.

Gets the primitive value of the attribute argument coerced to the requested type, if coercing could be done without losing data.

Gets if the attribute value is NULL.

Gets the attribute primitive value, if it actually is of a primitive type, in its raw form of the eight little-endian bytes. All other primitive-value methods coerce this value to a specific type.

Gets the primitive value of the attribute argument coerced to the requested type, if coercing could be done without losing data.

Gets the string value of the attribute argument, throws for any other specific type, including NULL.

Gets the type value of the attribute argument, throws for any other specific type, including NULL.

Gets the primitive value of the attribute argument coerced to the requested type, if coercing could be done without losing data.

N/A disposition, for example, for an array element whom together make an array value for an argument.

Gets the string value of the attribute argument (or NULL), throws for any other specific type.

Gets the type value of the attribute argument (or NULL), throws for any other specific type.

Gets the typed value of the attribute argument, avoiding any boxing.

Gets the array value of the attribute argument, throws for any other specific type, including a NULL value.

Gets the primitive value of the attribute argument coerced to the requested type, if coercing could be done without losing data.

Gets the value of the attribute argument of any type boxed as an object. This method won't fail for any data type, but incurs boxing.

Gets the primitive value of the attribute argument coerced to the requested type, if coercing could be done without losing data.

Gets if the attribute value is NULL.

Gets the attribute primitive value, if it actually is of a primitive type, in its raw form of the eight little-endian bytes. All other primitive-value methods coerce this value to a specific type.

Gets the primitive value of the attribute argument coerced to the requested type, if coercing could be done without losing data.

Gets the string value of the attribute argument, throws for any other specific type, including NULL.

Gets the type value of the attribute argument, throws for any other specific type, including NULL.

Gets the primitive value of the attribute argument coerced to the requested type, if coercing could be done without losing data.

Indexer helper for attribute arguments.

Gets the arguments which were assigned upon creation of this attribute. This includes constructor positional parameters, field assignments, and property assignments.

Looks up arguments by name.

Indexer helper for attribute arguments.

Gets the arguments which were assigned upon creation of this attribute. This includes constructor positional parameters, field assignments, and property assignments.

Looks up arguments by name.

Renders the attribute type and all known arguments into the exception data.

Find argument by its name, given by the expression. NOTE that it's recommended to pre-calculate the name from expression (call on it) and use the string parameter, for speed.

Looks up an argument by its element type (must be unique among other arguments). Often this is more reliable than looking up by name, because there's no early-bound way to supply a constructor paramtere name for example.

TODO: consider if this should be moved into tests or into internal product actions

Gets the hash code of a part catalog type. To ensure interoperability in hash maps, calculation of hash codes must be consistent across different storage implementations.

Gets the assembly for this type. For a Part type,this would be a Cataloged assembly. For any other, a placeholder assembly which basically only knows its name.

Gets the base types of this type which includes base classes and interfaces, but does not include the type itself.

Raw access for serialization etc. A backend for certain type-related properties of this type.

The type is actually a single-dimensional array with zero lower bound. Other cases are not supported yet. NOTE(H): If you ever need to support these, which requires a hierarchy of different type classes nesting each other, I'd rather recomment dropping this special class altogether and using the interfaces family with a separate implementation which can be filled from runtime types, from metadata, or from cache. Call to get the type of items in this array.

This is a generic type declaration, an open generic which is not specialized with any parameters.

This is a generic type specialized with some generic actual parameters, look in for their values.

The type is a reference (as in ref/out parameters), a.k.a. ByRef type. Call to get the referenced type.

For a type which is a Part type, gets its members which are Part members, i.e. have the or one of its derivatives on them.

Binds to the runtime type.

For a type which is a generic type parameter reference, gets the type which declares the generic formal parameter. Note that this might be any class containing the usage (immediate, outer, outer-outer, etc). For a method parameter, I believe the choice is limited to the containing method.

For an array type, returns a type of the array items (without the array rank). Much like getting the only generic parameter of the for its item type.

For a generic type specialization (), gets the full type name of the matching generic type definition, e.g. System.Collections.Generic.IList`1, which can be matched with the CLR non-specialized type.

For a type which is a Part type, gets the custom attributes on this type which are derived from the .

For a type which is a Part type, gets the custom attributes on this type which are derived from the and from .

For a reference type, returns the type being referenced.

For a type which is a Part type, gets the custom attributes on this type which are derived from the and from .

Compares if two PCTypes are the same instances, does not go in details on which types they actually do represent. This might result in getting false negatives, but should be fast enough for caching.

The kind of the , if it's a regular type, or an array of types, generic, etc.

These are not flags, even though values are assigned bit-independently for convenience.

A type declaration or a type usage which has no additional info to the type declaration (not generic, not reference, not array, etc).

This is a generic type declaration, an open generic which is not specialized with any parameters. No additional methods available.

This is a generic type specialized with some generic actual parameters, look in for their values.

The type is a reference (as in ref/out parameters), a.k.a. ByRef type. Call to get the referenced type.

This type is a reference to the type of the class generic parameter.

This type is a reference to the type of the method generic parameter.

This object is a member of the type returned from this property.

Gets the custom attributes on this member which are derived from the .

Gets the custom attributes on this member which are derived from the and from .

Which kind of member a is.

These are not flags, even though values are assigned bit-independently for convenience.

When we need to represent an already-loaded runtime type as a , this storage serves ad-hoc wrappers over Type operations. NOTE that not all cataloging APIs might be implemented on such types, only those which were of interest for such "mock" type facades. Feel free to add the missing pieces if they become needed.

Binders map, concurrent, defer creation from startup because it's JIT-heavy.

Pessimistically RW locked with because it needs to update this map and the table in sync, to add the table index to this table.

Read lock-free, mutated under writer lock.

Wraps an already-loaded runtime type as a . NOTE that not all cataloging APIs might be implemented on such types, only those which were of interest for such "mock" type facades. Feel free to add the missing pieces if they become needed. This operation is rather cheap, especially on subsequent calls.

Immutable context for resolving in unknown (dynamic) context. Avoids memory traffic on GetComponent calls without context.

Gets the component whose interface type is . Returns Null if there is no such component, or there are multiple components

Create an instance of the value. Called only once, so no need to worry about concurrency

Values from dependencies

Can be called in parallel from multiple threads

Component descriptor for on-demand components with custom factoring.

A runtime is given. Its parameters are bound and the member is invoked (a method or a property getter).

If the member is an instance member, might specify the instance for calling the member on.

The member which factors the component.

Create an instance of arbitrary type , selecting best constructor and providing parameter values from container

Type to instantiate Container to get values for parameters from New instance of type

Create an instance of arbitrary type , selecting best constructor and providing parameter values from container

Container to get values for parameters from Type to instantiate New instance of type

Invoke a function using reflection and supplying parameters' values from container

Container Function Return value of the function

Holds information about a method bound to a list of descriptor to supply as parameters

Creates an instance from the resolved binding. Method should be .

Resolved binding New instance

Creates a binding to a constructor of the specified type using the specified resolver

Type to create binding for Context for parameter resolution Resolved binding

Creates a binding to a method of the specified type using the specified resolver

Type to create binding for Context for parameter resolution Name for diagnostics Resolved binding

Finds method in candidates list which can be satisfied by resolver

Candidates to select from Resolution service, can find descriptor by type Name for diagnostics Resolved binding

Gets the cached value resolve context into the owning container on behalf of this component.

Special handling for the case when the method is VOID and we cannot have an instance. The calling code still expects some object instance.

Total components count including components which not presented in

The pure composition time excluding all gaps.

The pure composition time on primary thread excluding all gaps.

Sum of ctor own invocation times including components which not presented in

Component statistics. For composed container contain only components with CtorStep.OwnTime >= or StrategyStep.TotalTime >=

The total period from the StartTime until the container is composed. As the composition is not continuous, could be much greater than pure composition time.

Can create instances of classes (or call lambdas with parameters) with the power of our Component Container — by injecting required dependencies into constructor or method parameters.

Call static methods against an , or use instance methods on this class if you have a wrapper already.

Can create instances of classes (or call lambdas with parameters) with the power of our Component Container — by injecting required dependencies into constructor or method parameters.

Call static methods against an , or use instance methods on this class if you have a wrapper already.

Creates an object instance of type , injecting it with custom arguments and components from the parent container.

Type of the object to create. Defines the lifetime for the object that will be created. The object gets it in the constructor. The parent component container to define the set of components that could be imported in the object constructor. Additional custom actual parameters to be passed to the object constructor. These take precedence over parent container components. Note that currently there is no indication of unused parameters. The new instance.

Creates an object instance of type , injecting it with custom arguments and components from the parent container.

Defines the lifetime for the object that will be created. The object gets it in the constructor. Type of the object to create. The parent component container to define the set of components that could be imported in the object constructor. Instantiation value for object creation. Additional custom actual parameters to be passed to the object constructor. These take precedence over parent container components. Note that currently there is no indication of unused parameters. The new instance.

Creates an object instance of type , injecting it with custom arguments, but does not chain this to the parent component container.

Defines the lifetime for the object that will be created. The object gets it in the constructor. Type of the object to create. Additional custom actual parameters to be passed to the object constructor. These take precedence over parent container components. Note that currently there is no indication of unused parameters. The new instance.

Invokes a method with a live result (it gets its own lifetime, based on the lifetime you pass in and lifetimes of any components it also imports). The imported stuff is safe to use as long as you're not exceeding your lifetime.

The limiting lifetime for all the stuff being executed. The parent component container which will resolve all method parameters except for the ones you pass manually in . The method to invoke, either as a method, or a property, or an instance constructor. The instance, for an instance method. NULL for a static method. Custom actual parameters to be bound to the method. The order is not important, but the types must be unique. Instantiation flags for calling method

Invokes a method transiently (without any lifetime control). The method should not initiate any long-running activities, otherwise the entities passed into the method might get invalid.

Creates an object instance of type , injecting it with custom arguments and components from the parent container.

Defines the lifetime for the object that will be created. The object gets it in the constructor. Type of the object to create. The parent component container to define the set of components that could be imported in the object constructor. Initialization strategy for component composing. Task priority for . Instantiation value for object creation. Additional custom actual parameters to be passed to the object constructor. These take precedence over parent container components. Note that currently there is no indication of unused parameters. The new instance.

When listed as a base interface on a component, instructs the component container to create an instance of that component just after an instance of the component is created, either in the same container or in an upper-level container. Child containers are not monitored.

The component whose creation is monitored.

Interface for abstract component container

Creates value resolution context for requesting descriptor.

Requesting descriptor or a dynamic request for unbound lookups. IValueResolveContext for instance lookups

Extension interface to provide extra items into component container

Components added to the container by the value resolver

Creates value resolver that will be registered in the component container

Lifetime of the container for which value resolver is created Part catalog filtered by zones Component container being extended

. The components will be arranged in ascending order by int priority values.

. The components will be arranged in descending order by int priority values.

. The components will be arranged in ascending order by double priority values.

. The components will be arranged in descending order by double priority values.

Interface for component attributes to get ordered collections

Components that implement this interface will be auto created during startup

Additional services on a value descriptor which tells when it's been created and allows to plug into the creation pipeline.

Gets if the value creation has already been initiated (and possibly completed). A companion for to handle cases when it won't fire.

Gets if the value creation has completed successfully, and can be obtained with a no-cost sync call (or as an already-completed task). A companion for to handle cases when it won't fire.

Advises the event of the value creation, which fires when the value has been factored (and is available for querying), but the creation pipeline task has not yet completed. Inserts into that pipeline. Does NOT fire if the value already exists (and will never fire in such a case).

Hack to provide in nested container ability to get owner instance.

Owner of nested container. Available only after owner's initialization and doesn't force component creation. DO NOT STORE THIS VALUE, it will be destroyed before components from nested container.

Nested container owner type

default impl. Does not register serving any requests by itself, but allows to learn the request upon which autocreation should be triggered.

null, IComponentDescriptor or

A registration yielded by a component which has an .

Gets the request upon serving which the component should be autocreated.

Registers for all based types and interfaces of the given type (inclusively).

If contains a lazy type, extracts the type it lazily creates (its generic parametrization type). In case it looks like lazy but is not lazy (e.g. from newer system libraries), issues an exception. If it's just clearly a non-Lazy type, yields NULL.

Services for the container.

If contains a type wrapped in , extracts the type it holds (its generic parametrization type). Otherwise yields NULL.

The target descriptor which we're making optional. NULL means the optional value will also be NULL. If non-NULL, then it must provide some actual non-NULL value.

Lazy-created when first requested, by querying for the value of the descriptor, if such is present.

Base class for component containers. Provides storage for components and initialization services

Container ID

Current lifetime state for this container

Registered descriptors and their lifetimes

Composed components map

Creates new instance of

Identifier string for this container

Initializes the components in the container.

The container has just been created and is not ready for creating the components yet. Call to proceed.

The container is running. The first pack of components has been created.

has been called on the container, and it's currently in the process of tearing down the components.

The container has destroyed all of the components and is functional no more.

Composing process lifetime Container id

When there are no containers in the composing state

Request to suspend all uncompleted LaterAsync stages of all containers

When are no LaterAsync suspend requesters

Strategy for containers without ContainerSync components. Temporary solution to prevent call inside Compose of such containers.

General interface to get enumerable of components. Smart-lazy, DeadlockSafe elements will be instantiated only during enumeration.

Helper to get and other components collections

Ordered collection of components. Order should be described by special attribute of components. Attribute should implement , , or .

Ordered collection of components. Order should be described by special interfaces of components.

, , or

Similar to but with multithreaded (when possible) instantiation of elements during the first enumeration

Interface to get list of already instantiated components

Actually this collection of has the same behavior as but with explicit laziness of items

Some

Actually this collection of has the same behavior as but with explicit laziness of items

Some

Actually this collection of has the same behavior as but with explicit laziness of items

Some Component attribute to use for sorting

A wrapping interface for importing components without requesting their immediate instantiation.

The component type (or any of the underlying wrappers, like ).

Enforces the component instance be created and returned immediately. If the instance has already been created, then the ready instance is just returned. If not, the instance is created immediately on the same thread, if threading affinity allows, or creation is synchronously scheduled on the requested thread. The latter is very deadlock-prone. You should not call this for primary-thread-affined components on background threads.

A wrapping interface for importing components without requesting their immediate instantiation.

The component type (or any of the underlying wrappers, like ).

Returns the component instance if the instance has already been created. If not, null will be returned.

Gets whether the component value has already been fully created and is safe to get from the synchronous function. would also be True.

A service method to support await keyword right on the expressions, without explicitly calling for .

Starts creating the component instance asynchronously, if this is the first time the value has been called for. Returns the task to be awaited. On subsequent calls, returns the same task (either completed or not).

Creates an instance from an already existing object instance. This object is named and strucuted so that to intentionally hide from the code smart completion, because in most cases it should not be created this way.

Wraps a lazy object instance into the interface.

Wraps an object instance factory into the interface.

Wraps an already existing object instance into the interface.

Provides by

Wraps an already existing object instance into the interface.

Wraps an optional component instance in an explicit fashion. To get a component which is OK to be missing, request specialized with your type. The wrapper value you get is always non-Null, and you can inspect if the contained component instance is present or not.

Gives information on who's requesting for value resolve, and in what context.

If requesting on behalf of some component, stores its descriptor.

Gets whether the request is placed on behalf of a component descriptor. is available if so.

Gets whether the request is dynamic, i.e. there's no specific component known on behalf of which the request is made.

Gets if it's known on behalf of which entity the request is made.

Gets the route the request has traveled.

Gets the originator if is . Throws otherwise.

Gets if it's known on behalf of which entity the request is made.

Dunno what this means.

Request is made on behalf of a component. Within a component conatiner, this will result in a dependency tracked.

Request is made in context of no component.

Gets the route the request has traveled.

This is the outermost resolver entity to serve the request — closest to the requester, hence endpoint. All the final wrappings should be done on this stage.

The request has been delegated to an inner resolver, don't do endpoint wrappings.

In a scenario when a product assembly is loaded as a dependency of a plugin assembly we need to specify the product assembly location explicitly (as it cannot be resolved in the plugin folder).

Reads the part catalog in search of components, filters them by the filter and selector, and creates descriptors for use with the container.

Additional step of initialization on PrimaryThread. Component will be available in container only after execution of this method.

Additional step of initialization on AnyThread. Component will be available in container only after execution of this method.

Uses factory pattern for applicability check. (instantiate part is not null means applicability) Doesn't instantiate parts for overridden components.

Component's lifetime can be terminated during activation

Expands with catalogs-specific stuff.

Opens a session for binding to assemblies with Jet Metadata Reader. Under the hood, maintains a for the session, and attaches all opened metadata access to it.

The binder from whom the session were created, governs resolving assemblies from names.

The metadata loader which loads the assemblies (you must respect its threading limitations). For loading and resolving references, uses 's skills.

Binds an assembly to its metadata access. Basically, just uses the pre-configured , who already knows how to resolve into the , to load by name. Threading limitations of the and the apply.

Metadata has references to well-known types (see primitive types in ) by just their type code and no assembly specification, so serves as the resolver for such types. Initially, it caches them all as Unresolved, but then it looks into any assembly you load into it if it has these types inside, and if by chance you load the system assembly before you first need such a type, then they are resolved okay, otherwise they are Unresolved. Whoa. Set this to True when loading a system assembly.

Opens a session for binding to assemblies. The bound readers are lifetimed, and since they need to resolve to other readers and reuse them, some sorta session is needed to keep the cache and track their common lifetime.

When called for the same assembly multiple times, we want to know it's the same assembly before opening a new with proably a new copy in memory. Note that _might_ think it's the same, but how would we know, the stream would be new every time.

A result monad with one more option: the method takes a filter, and the filter has prevented us from completing the operation. This is a special non-failure condition which we need to tell apart from a failed result, and also to avoid extra allocations of exceptions and stack traces on this path.

Has passed the filter, so the underlying Result monad is available (with ), as either successful value or an error.

Has a successful value, i.e. is passing the filter, and the underlying Result monad is not an error.

Second-level cache. If assemblies whose names are different (by what says) resolve into the same stream, and it's an which knows its digest, then we'll share them. TODO: see if it's slow to calc digest for e.g. assemblies from compressed entries.

Second-level cache. If assemblies whose names are different (by what says) resolve into the same disk file, we'll share the .

First-level cache by name. Only works if names match (in terms of ), regardless of what has.

Cache for arbitrary stuff.

Does not load the assembly anew, only if it has already been resolved in this session. Beware that in a parallel environment it's not very deterministic, whether someone has already loaded the assembly or not.

The filter ONLY applies when we follow type forwards. It is assumed that the input names have already been checked by the caller (caller typically does this even before dispatching where to look for those names). If a type forward into another assembly is encountered, used for loading the assembly.

Only supports simple names (representing typedefs). Supports both top-level and nested types.

Tries to get the typedef of the base type. The monad states here: * Filtered out. * Failed with an error. * No value because there is no base type. * A valid base type.

Lightweight decoding by only reading typedefs/typerefs, tunneling thru any type construction, discarding any generic specializations, and not resolving any assemblies.

Renders details about the handle and its origin when logging diagnostics.

Error reading metadata.

Positive value is array rank. Negative value is modifier encoded using constants defined in .

To avoid the need of allocating a string for all declaring types (example: A+B+C+D+E+F+G), length of the name is stored and the fullName passed in ctor represents the full name of the nested type. So when the name is needed, a substring is being performed.

The assembly-qualified name of the type; e.g., "System.Int32, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089".

If returns null, simply returns .

Returns assembly name which contains this type, or null if this was not created from a fully-qualified name.

If this type is a nested type (see ), gets the declaring type. If this type is not a nested type, throws.

For example, given "Namespace.Declaring+Nested", unwraps the outermost type and returns "Namespace.Declaring". The current type is not a nested type.

The full name of this type, including namespace, but without the assembly name; e.g., "System.Int32". Nested types are represented with a '+'; e.g., "MyNamespace.MyType+NestedType".

For constructed generic types, the type arguments will be listed using their fully qualified names. For example, given "List<int>", the property will return "System.Collections.Generic.List`1[[System.Int32, mscorlib, ...]]". For open generic types, the convention is to use a backtick ("`") followed by the arity of the generic type. For example, given "Dictionary<,>", the property will return "System.Collections.Generic.Dictionary`2". Given "Dictionary<,>.Enumerator", the property will return "System.Collections.Generic.Dictionary`2+Enumerator". See ECMA-335, Sec. I.10.7.2 (Type names and arity encoding) for more information.

Returns true if this type represents any kind of array, regardless of the array's rank or its bounds.

Returns true if this type represents a constructed generic type (e.g., "List<int>").

Returns false for open generic types (e.g., "Dictionary<,>").

Returns true if this is a "plain" type; that is, not an array, not a pointer, not a reference, and not a constructed generic type. Examples of elemental types are "System.Int32", "System.Uri", and "YourNamespace.YourClass".

This property returning true doesn't mean that the type is a primitive like string or int; it just means that there's no underlying type. This property will return true for generic type definitions (e.g., "Dictionary<,>"). This is because determining whether a type truly is a generic type requires loading the type and performing a runtime check.

Returns true if this is a managed pointer type (e.g., "ref int"). Managed pointer types are sometimes called byref types ()

Returns true if this is a nested type (e.g., "Namespace.Declaring+Nested"). For nested types returns their declaring type.

Returns true if this type represents a single-dimensional, zero-indexed array (e.g., "int[]").

Returns true if this type represents an unmanaged pointer (e.g., "int*" or "void*"). Unmanaged pointer types are often just called pointers ()

Returns true if this type represents a variable-bound array; that is, an array of rank greater than 1 (e.g., "int[,]") or a single-dimensional array which isn't necessarily zero-indexed.

The name of this type, without the namespace and the assembly name; e.g., "Int32". Nested types are represented without a '+'; e.g., "MyNamespace.MyType+NestedType" is just "NestedType".

Represents the total number of instances that are used to describe this instance, including any generic arguments or underlying types.

This value is computed every time this method gets called, it's not cached. There's not really a parallel concept to this in reflection. Think of it as the total number of instances that would be created if you were to totally deconstruct this instance and visit each intermediate that occurs as part of deconstruction. "int" and "Person" each have complexities of 1 because they're standalone types. "int[]" has a node count of 2 because to fully inspect it involves inspecting the array type itself, plus unwrapping the underlying type ("int") and inspecting that. "Dictionary<string, List<int[][]>>" has node count 8 because fully visiting it involves inspecting 8 instances total: Dictionary<string, List<int[][]>> (the original type) Dictionary`2 (the generic type definition) string (a type argument of Dictionary) List<int[][]> (a type argument of Dictionary) List`1 (the generic type definition) int[][] (a type argument of List) int[] (the underlying type of int[][]) int (the underlying type of int[]) The total number of instances that are used to describe this instance exceed .

The RoslynParsedTypeName of the object encompassed or referred to by the current array, pointer, or reference type.

For example, given "int[][]", unwraps the outermost array and returns "int[]". The current type is not an array, pointer or reference.

Returns a RoslynParsedTypeName object that represents a generic type name definition from which the current generic type name can be constructed.

Given "Dictionary<string, int>", returns the generic type definition "Dictionary<,>". The current type is not a generic type.

Parses a span of characters into a type name.

A span containing the characters representing the type name to parse. An object that describes optional parameters to use. Parsed type name. Provided type name was invalid. Parsing has exceeded the limit set by .

Tries to parse a span of characters into a type name.

A span containing the characters representing the type name to parse. An object that describes optional parameters to use. Contains the result when parsing succeeds. true if type name was converted successfully, otherwise, false.

Gets the number of dimensions in an array.

An integer that contains the number of dimensions in the current type. The current type is not an array.

If this represents a constructed generic type, returns an array of all the generic arguments. Otherwise it returns an empty array.

For example, given "Dictionary<string, int>", returns a 2-element array containing string and int.

Creates a new object that represents current simple name with provided assembly name.

Assembly name. Created simple name. The current type name is not simple.

Creates a object representing a one-dimensional array of the current type, with a lower bound of zero.

A object representing a one-dimensional array of the current type, with a lower bound of zero.

Creates a object representing an array of the current type, with the specified number of dimensions.

The number of dimensions for the array. This number must be more than zero and less than or equal to 32. A object representing an array of the current type, with the specified number of dimensions. rank is invalid. For example, 0 or negative.

Creates a object that represents a pointer to the current type.

A object that represents a pointer to the current type.

Creates a object that represents a managed reference to the current type.

A object that represents a managed reference to the current type.

Creates a new constructed generic type name.

An array of type names to be used as generic arguments of the current simple type name. A representing the constructed type name formed by using the elements of for the generic arguments of the current simple type name. The current type name is not simple. false means the input was invalid and parsing has failed. Empty input is valid and returns true.

Limits the maximum value of node count that parser can handle.

Setting this to a large value can render susceptible to Denial of Service attacks when parsing or handling malicious input. The default value is 20. Positive length or negative value for invalid name

Are there any captured generic args? We'll look for "[[" and "[" that is not followed by "]", "*" and ",".

A signature type provider which ignores all type specification construction but pulls out the basic type definition or reference, i.e. gets the open generic type etc.

A monad with the typedef.

Context of the target type. If we know the TypeDef of the type. Only valid if non-NULL and is NULL. If we know the TypeRef of the type. The idea is that we do not want to pull type ref assembly resolve context into here (+ all the filters) since that would make the extractor a non-static instance, so leave resolve for the caller. Only valid if non-NULL and is NULL. Non-NULL if there was some problem getting the type (not just omitting the generic specialization, of couse, but something which makes it unreliable / unusable). The idea here is that we only actually need the outermost open generic type def, and anything happening while reading its generic specification would be discarded, so track errors with the type and decide in the end.

A monad with the typedef.

Context of the target type.

If we know the TypeDef of the type. Only valid if non-NULL and is NULL.

If we know the TypeRef of the type. The idea is that we do not want to pull type ref assembly resolve context into here (+ all the filters) since that would make the extractor a non-static instance, so leave resolve for the caller. Only valid if non-NULL and is NULL.

Non-NULL if there was some problem getting the type (not just omitting the generic specialization, of couse, but something which makes it unreliable / unusable). The idea here is that we only actually need the outermost open generic type def, and anything happening while reading its generic specification would be discarded, so track errors with the type and decide in the end.

null means "parent container is obtained from context", see JetBrains.Application.DataContext.ApplicationDataConstants.ComponentContainerForFactoring null means "parent container is obtained from context", see JetBrains.Application.DataContext.ApplicationDataConstants.ComponentContainerForFactoring

The default properties for legacy components which expect adherence to the old behavior. Default values for all member enums must match this state, so it's a NULL value for the struct.

Can be accessed from any threads but only by async request To be assumed for components which do not provide their own properties.

The less limited option (except deadlock safety). To be assumed for components which do not provide their own properties.

The less limited option. To be assumed for components which do not provide their own properties.

Reads (and caches on the static class) the default instantiation for a -derived attribute from the attr placed on this -derived attribute class. Is very specific at that: no derived attributes, no defaults, no omissions, no reading from ctor. MUST be an explicit attr.

Marked constructor parameter type as deadlock-safe. Constructor parameters of this type are not analyzed by safety checks.

Indicates that this class/interface and its inheritors are deadlock-safe for a specified component container. This means they can be safely injected into components created by that container.

We can mark types (typically interfaces) as deadlock safe for all containers (ComponentContainerType.All) This means that any container has an object of the given type, whereas inheritors will not necessarily be available in all containers (Marking type as deadlock safe for ComponentContainerType.Environment also means safety for all containers, but inheritors of this type must also be safe for environment) 1. ISolution is deadlock safe for solution instance components (and therefore for solution components) 2. Components created in Sync/Async stage of environment container composition are deadlock safe for shell components (and therefore for solution instance, solution components) 3. IThreading (and thus IShellLocks) is deadlock safe for environment components (=> for shell/solution instance/solution components) 4. IPartCatalogSet is deadlock safe for components from all containers, but ShellPartCatalogSet is safe for shell (and next) components

PLEASE, try to use (or ) for new components that are requested by other components, with for components that should provide some features themselves (workers) and may be not referenced by others. The legacy default for old components without the specified is only because we need to check if they require primary thread or if they can be deferred. These values make sense for async strategies, while the default strategy will create all components at time, but you can still provide correct instantiation value and prepare it to switch to async strategies (e.g. switch from manual container creation to injecting of ).

Deadlock safe components () that are created on demand only and doesn't have any deadlock unsafe dependencies in constructor. These components can be requested from any thread by , or injected into other components.