JetBrains.Platform.Shell

All our application hosts of all versions use the same directory. This is how our Global Settings are stored — visible to all applications in real time. This would be the default choice for most use cases. An exception to this is Rider because it shadows all the directories into a sandboxed location, which breaks sharing, even when is used.

Each application host would have its own directory, and it would be used by all versions of the application. A host isn't directly a product, but the app which starts the environment and runs products within. For standalones, this is the standalone app (oftens a 1:1 mapping to a product). For Visual Studio hosted apps, this is the Visual Studio itself, differentiated by its hive (technical Major+Minor version, Root Suffix, and Instance ID, see VsHive). Consider using this folder only if your data is strictly per-app, like maybe recent exceptions. Stuff like settings and licensing info should generally be shared throughout all hosts.

Each Wave will have a separate folder, but it will be shared among all the application hosts. This is a rather exotic layout, and you probably do not need it.

Each application host (see for details) will have a separate folder for every Wave (see for details). Historically, before SharedSettings, this was the most popular choice. Many caches still use this scheme, assuming data formats in different waves might be incompatible. However, in reality we have breaking changes in data formats even within the same wave, not only in EAPs but even between public minor releases from the same wave, so data format versioning mechanisms must be in place anyway. And if so, there's no need to explicitly partition them by wave and host. Consider if you can use or instead, erasing incompatible data or encoding data format version in its path.

Defines the application package in the JetMetadata of a Nuget package. Companion artifacts: , .

A companion for , gives extra info on whether the package itself should be considered a compile-time-only package, and not used at runtime.

Whether this subplatform reference should be used only on these runtimes, or NULL if everywhere.

A companion for , gives extra info about which references are runtime-only in it. A possible candidate for merging into the apppackage itself.

Names for build runner related command line switches.

Module zones with which a certain type is marked.

Namespace for all module zone based traits.

for .

Factory methods for standard catalogs.

Loads assembly files from streams with our fast metadata reader.

The list of assembly names for assemblies which should be included with the catalog (and scanned for types). Knows how to bind assembly names for reading, including the listed names and their references.

Loads assembly files from disk with our fast metadata reader.

Loads assembly files from streams with our fast metadata reader.

Catalog tables in loaded form.

Catalog tables loaded into memory by allocating native mem and putting there the dump and applying zero-load reinterpret-casts.

Catalog tables in loaded form.

Catalog tables loaded into memory by allocating native mem and putting there the dump and applying zero-load reinterpret-casts.

Calculates the zone mapping for a catalog.

For a type, gets either the list of module zones required for it (might be empty), or NULL if there're no wherever in its hierarchy, which makes it ineligible for instantiation. For bulk calls which involves getting the transitively closed zones list, consider .

For a type, gets either the list of module zones required for it (might be empty), or NULL if there're no wherever in its hierarchy, which makes it ineligible for instantiation. Effectively operates the transitively closed zones list, but might take some time on the first call.

Gets whether all zones marked over the given are among the .

Declared zones within a single assembly.

Lazy-calculated mapping of unique transitively-closed zone lists for trie nodes, only the most common node with the same zone set is mentioned, its same-list children assumed but not added. The keys are all strings to which new zoning requirements are attached (either namespaces or type names). If a namespace is zoned, it will be listed here, but not its child namespaces or types, they'd be listed only if they got new zones attached. The list is sorted ordinally by these strings. The values are the transitively-closed lists of zones attached (this includes all zones propagated from parent namespaces and all base/required zones of those zones). The zones array is sorted ordinally by zone part type full names.

The trie path is the class fullname. There are nodes for classes and namespaces. Each node might have a list of zones applied to it. For a class, its effective zone list is the union of all lists on its node and its ancestors up to the root.

Enumerates all zone markers in this assembly, class or namespace.

Currently, the zone marker kind is not tracked and it not returned.

For a full name of a type, gets either the list of module zones required for it (might be empty), or NULL if there're no wherever in its hierarchy, which makes it ineligible for instantiation. This list includes all zones required by parent names of this name (e.g. outer namespaces). This list might not include base classes of the required zones, even though they are also required, because it is enough to require the derived zone.

An optimized version for bulk-querying transitively-closed zones lists on types. Zones, together with the prefixes of the at which the specific zone is applied. No deduplication, no transitive closing.

For a full name of a type, gets either the list of module zones required for it (might be empty), or NULL if there're no wherever in its hierarchy, which makes it ineligible for instantiation. This list includes all zones required by parent names of this name (e.g. outer namespaces). This list includes all base classes of the required zones. This list is sorted ordinally by the zone name. Has a noticeable first-call cost; after that, is very fast.

Looks if the class has the , which means the specific class, or the whole namespace is marked as belonging to that zone. See attr doc for details.

Mostly for exploring the tree in the debugger, as this isn't visible from outside.

For a class which has a or similar semantic, collects all of the zones required on this class. This includes parameters and base type specializations.

If this node zone list differs from the parent's zone list, ie new zones are added by this level.

Mostly for browsing in the debugger.

A class fully-qualified name, for a class zone marker. A namespace name, for a namespace zone marker.

The zone applied by the zone marker.

A class fully-qualified name, for a class zone marker. A namespace name, for a namespace zone marker.

The kind, if known.

The zones applied by the zone marker. Empty means it just marks as zone-eligible without requiring any zones. A NULL means the structure has not been initialized.

The struct has not been defined.

Kind of the marker is not known here.

A class marker.

A namespace marker.

This class gives standard folder locations for apps running in hosts. They define if they should be shared between major product versions or be per-wave, and whether they should be shared between different hosts (that's different installations of independent products, not the products themselves, because they might all be running within Visual Studio). If you need folders for static non-shell-aware data, like in Utils, the compatible folder locations are in . Guaranteed to return the same path in all JetBrains products.

Core images to be used for branding of supplementary tools an technical hosts which do not have their own branded images supplied.

This class gives standard folder locations for apps running in hosts. They define if they should be shared between major product versions or be per-wave, and whether they should be shared between different hosts (that's different installations of independent products, not the products themselves, because they might all be running within Visual Studio). If you need folders for static non-shell-aware data, like in Utils, the compatible folder locations are in . Note that base path may vary in different products. I.e. Rider can override base path for TempFolder and LocalAppData.

One application package (subplatform, plugin, etc).

Gets the expiry date.

The birth date of the package. Used for the lower copyright year and so on.

Gets the date and time when the current package was built.

Name of the company which has produced this unit. As plugins are becoming first-class packages in the app, not all the packages will be produced by JetBrains. This is the human-readable version, without "Inc" or "s.r.o." or else.

Name of the company which has produced this unit. As plugins are becoming first-class packages in the app, not all the packages will be produced by JetBrains. This is the full legal version with all the "Inc" and "s.r.o." and else.

IApplicationHost.CompanyNameHuman

The list of files included with this package.

ID of this application package. Corresponds to the Nuget package ID.

Gets the IDs of the referenced application packages.

Gets the subplatform name of the subplatform which has produced this package.

Gets the product full version.

Base directory into which the package is locally installed. Package files are placed at under it. Note that packages might either share the same local install folder, or have it different.

Base interface for application traits, so that you could easily check which you're defining on your products and which you're not.

Branding for windows and other UI controls. Supplies the application-specific icon, the title prefix, etc. Historically, the IApplicationDescriptor was used for this, but in a shared-shell world it's not an option.

Gets the name of the company providing the main product identified by .

The user-friendly name of the product in the short form (no company, no version). The default choice if you want to mention the product name in UI.

There're three forms of the product name:

(1)

The short technical name which follows the identifier syntax. Use for IDs, filenames, Registry access, prefixes/disambiguations, etc. Example: “Receptor”, “DotMemory”.

(2)

The short UI name for use in display strings. Still does not include the version number. The default choice if you want to mention the product name in UI.
(NOTE: there's a special function for making window titles like “Receptor – Downloading”). Equal to by default, but might differ in some products
(e.g. DotMemory's technical product name is “DotMemory”, while its display product name is “DotTrace Memory”). Example: “Receptor”, “DotTrace Memory”.

(3)

The expanded marketing product name for detailed UI strings which also includes the marketing version, beta/EAP/RC designation, etc. Its use is narrow (for about-boxes and alike), just compare:
• “Receptor 7.0.2 Limited EAP – Code Cleanup” vs. “Receptor – Code Cleanup”
• “Reset all Receptor 7.0.2 Limited EAP settings” vs. “Reset all Receptor settings”. This is the only property which exposes the marketing version of the build which, if it has more than two components, does not directly match the technical version. For example, “Receptor 7.0.2” has the service pack number of 2, while the technical version build component (the third number) is roughly the number of the nightly published. Example: “Receptor 7.0.2 RC”, “DotTrace Memory 1.0 Public EAP”. — None of these include the Company Name, use to concatenate if needed for display.

Gets the icon to use as product window icons, such as in dialogs. The icon might change with time, for example when theme is switched. An IconId cannot be used here because an icon is a rich format including multiple device images for the same icon.

Prepends a caption string with the product name, separated with an en-dash.

The original caption to prepend with the product name.

Base attribute for self-chooser markers.

Looks up the -derived attributes of type , looks up the single item which has the only parameter set to the .

Looks up the -derived attributes of type , looks up the single item which has the only parameter set to the . is faster for use on startup.

Looks up the -derived attributes of type , looks up the items which have their two parameters as a range which fits the against the .

Marker to help choose the host zone by CLR implementation in an automatic fashion.

Marker to help choose the host zone by CLR version without referencing all instances (which is not possible from the base class).

Marker to help choose the host zone by CPU Architecture in an automatic fashion.

Marker to help choose the host zone by OS Platform in an automatic fashion.

The ARM64 (aka AArch64) CPU. In effect on ARM64 systems.

The ARM CPU. Haven't seen such in wild life, but MSFT is onto that, let's reserve the zone.

UI-interactive products with Avalonia framework.

Common root for CLR implementation-specific zones (Framework, Mono, Core).

Common root for CPU-specific zones.

The base type for so-called Environment module zones. These zones define the difference between VS / test / standalone / cmd environments which is not specific to the product, but to the common component implementations which serve running in that specific environment. When the host is started, it's given the one Environment zone which would be active in the Environment container. Only environment zones and other host-specific zones () could be activated in the Environment container. After that, the set of the environment zones cannot be changed when starting the Shell container.

Base interface for module zones which are available right out of the JetBrains host runtime startup (the most low-level thing which starts the Environment container) and apply to the Environment container as active zones. Only module zones derived from this type could be activated in the Environment container. The set of the active module zones derived from this type cannot change afterwards within the host lifetime. Only non- zones might be additionally activated.

The internal-only visibility zone. These items are only active when running in Internal mode.

Gets activated in the host when is .

If active environment zones of your app have this zone, the app would always report exceptions with the Exception Reporter (when Shell is fully running) or a message box (on early startup / late shutdown phases). For the most correct behavior (on early startup), make sure the main environment zone of your app (the one you request for the Launcher with .WithStartingShell*<Zone>(), or specify with .InEnvironmentZone() when starting the JetHost manually) has this interface in its implemented/base interfaces, otherwise the early startup might not detect it.

Gets activated in the host when is True.

Gets activated in the host when we work on .NET Framework.

Common root for OS-specific zones.

All products allowed to connect outer world (internet)

The default visibility zone. These items are active in both Public and Internal zones.

An interface to mark some class as requiring a zone. Applies either to a component class, or to a special marker class which marks the whole namespace it's placed in.

The zone.

Mark components which depend on external services JVM process with this zone.

The CLR zones root. Available when running on CLR version 2+.

UI-interactive Avalonia-only.

Commandline standalone products.

Components for UI-interactive standalone IDE-like products with multiple tool windows.

All products running in a standalone fashion — not under VS nor unit testing.

UI-interactive standalone IDE-like products with tabwell-based main window.

Base sone for UI-interactive standalone shells. They might have custom UI instead of the standard main window with the tab well.

All products which are allowed to show graphical user-interactive interface.

Gets activated in the host when is False.

Gets activated in the host when is True.

UI-interactive products with WPF framework.

The x64 (aka AMD64) CPU. In effect on AMD64 systems when running in CPU-native processes (without WoW6432, which would show up as ).

The x86 (aka IA32) CPU. In effect on x86 systems and inside WoW6432 processes on AMD64 systems.

The base interface for all zone axes. Is not a zone on itself.

Stateless algorithms on zones application, relations, dependencies, and so on.

A fast-lookup collection of zones.

Transitively closes the zones list, considering their bases and requirements.

Whether dictionary values would be non-NULL, set FALSE to save cpu/gc. Keys: transitively closed zones set. Values: if , the requirement path from the key to one of the zones in the original list.

A version of which also transitively closes the zones list and explains where each zone is getting from (there you can also tell apart non-transitively-closed zones). Much much slower than , only use when you need diagnostics.

On a zone from the part catalog, gets its flags from the attribute declaration.

Is this zone an environment zone?

Zone sets are expected to be sorted ordinally by the full name of the zone part type. The result is expected normally to be empty or small.

Describes one instance of the zone coming from some zone marker.

The name at which this zone marker is applied. Might be the exact (eg explicit class zone marker on a class), or its parent namespace (a namespace zone marker which implicitly zones all of the classes in that namespace).

Traces the zone in question to the zone which is explicitly required by the zone marker. At least one item long (when the zone is explicitly required by the marker). The first zone is always the . The last zone is always the zone which is explicitly listed in the zone marker.

Is marked explicitly with that zone (not with smth that requires/inherits it).

For a zone applicable to some part name (a dot-qualified name), explains how this zone got applied to it.

The FQN to which the zone application is explained. Typically, the diagnostics is collected for a class, so that would be the class name.

Marked with this exactly zone on this exactly level (no inheriting, no nothing).

The multiple origins how the got applied to the . That could be: (1) Explicit on this name: there's a zone marker right on the (class zone marker if it's a class, namespace zone marker if it's a namespace), and this zone marker requires the exact type. (2) Implicit on this name: the marker is right on the name, but it requires some other zone X which in turn transitively requires the (with or base types). (2) Explicit on parent name: there is a namespace zone marker on a parent namespace of the which requires the exact type. (3) Implicit on parent name: a combination of the prev two. Explicit or implicit: see the length of chain. This name or parent name: see if equals to .

The single zone whose origin is explained here. The is zoned with this zone, explicitly or implicitly.

For a Module Zone, gives if it's a special Host Zone, Environment Zone, etc.

Declares a new zone. If the marked class/interface derives some other zone, then it's a value in the existing axis. Otherwise it's a root of the new axis.

Means that the zone is automatically enabled on startup once its dependencies are enabled.

This attribute allows to mark classes as belonging to Zone Axes. A Zone Axis is declared with , after which one or more classes might be marked as belonging to that Zone Axis. A class is the only unit to which the Zone Axis actually applies. • • • Which classes are affected by a specific instance: If the attribute is applied to just a regular class, e.g. a component, then just this class is marked with the respective Zone Axes. If the attribute is applied to an empty class named ZoneMarker, or whose name ends with _ZoneMarker, then it's a syntax sugar for marking all of the classes under the current namespace by applying a single marker. This applies to classes from the same assembly, from the same namespace as the marked ZoneMarker class, and in all the nested namespaces. • • • Which Zone Axes are applied with a specific instance: First, you can specify the list of Zone Axis types as the attribute constructor parameters. Then, the class which is marked with the attribute might implement any number of interfaces (including those from its base classes), whose type parameters should be instantiated to the Zone Axis types. The total set of Zone Axes of the attribute is a union of all these, both for regular classes and for ZoneMarker classes. An empty set of the Zone Axes is a special case. It does not restrict the class to any zones, but marks an opt-in to the zoning system, which is required to make the class pass any of the zoning filters. A class to which no zone markers apply is invisible to the component container. • • • The total set of Zone Axes to which a certain class belongs is a union of: — Zone Axes applied by the on this class itself. — Zone Axes applied to all the ZoneMarker classes in the namespace of the class. — Zone Axes applied to all the ZoneMarker classes in any parent namespaces of this class (within the same assembly).

Lists the Zone Axes. Only Zone Axis types registered with are allowed in this list.

Some of the zones required by the marked class. Note that zones might also be required by base interfaces of the class, .

Represents an -derived interface without loading the runtime type, in part catalog terms.

Creates a zone part object from a runtime type.

The module zone type. The part catalog to create the module zone type in a much more efficient manner. It's recommended to supply it in any perf-sensitive scenarios.

Creates a zone part object from a runtime type.

The module zone type. The part catalog to create the module zone type in a much more efficient manner. It's recommended to supply it in any perf-sensitive scenarios.

When running a build for , specifies which objective to invoke on the binary stage. The source stage always runs for .

All build runner related artifacts, this includes Build Runner Core and Build App, in EXE and Nuget and Script References forms.

Republish the Platform Core Shell nuget, for use in references where applicable (eg initially the sdk task body).

Republish the Wave nuget, for use in references where applicable (eg initially the sdk task body).

All files for the Build Runner Core: the Single-exe, the Nupkg with Single-Exe, and the build script assembly references.

Mount as .

A single-.exe with the Build Runner Core assemblies.

Non-GAC assemblies of the Build Runner Core, which is Build Engine (executor) + Shell (entry point and collector infrastructure) + their dependencies.

The set of assemblies which are intrinsically available for use in build script files, that's Build Interface and its refs (this list only includes non-GACs).

A single-.exe with the Build Runner Core assemblies.

A single-.exe with the Build Runner Core assemblies, packed into a Nuget

Makes a nuget package with non-GAC DLLs which are intrinsically available for use in build scripts, which is Build Interface DLL plus all its references.

Allows to specify tags for marking running/completed builds with.

Causes an empty build, but that build causes the fresh self-bootstrapped Build Runner Core be compiled in the process (if outdated), and so warms-up the cache.

Means the marked artifact should be suggested as a build entry point. // TODO: probably, a temporary solution.

The third component of the full version number. (the first two components identify binary compatibility and are specified in the component being built, while the last two are merely incremental)

The “pre-release metadata” component of the semantic version spec, one after a hyphen.

The fourth component of the full version number. (the first two components identify binary compatibility and are specified in the component being built, while the last two are merely incremental)

Unless specifically provided, makes it from the current date-time. SPECIAL HANDLING for INCREMENTAL MODE: the date-based versions are very rough when run locally, changing them often would prevent incrementality.

If the product version has only at most two first components set (Major.Minor), supplement the lowers (Build.Revision) and prerelease metadata with the current build version. If is omitted, return AS IS.

The time of the build, in UTC, in the form of an artifact. For use in package metadata and in product info.

For linking as the after-compile stage. // TODO: probably, a temporary solution.

Specifies the GUID to be used for Visual Studio CommandID for the actions in this subplatform.

Gets the VS Command Group GUID to be used for regular actions in this subplatform when they are turned into VS commands.

For subplatforms for which a custom hard-coded GUID is not set, generates a new dynamic GUID deterministically for use on action commands.

Generates a new dynamic GUID deterministically for use on subplatform's command groups.

The allowed charset for the content name (actually specified on server side, here's a snapshot at some moment of time; update to actual server value if it changes).

When replacing the content name chars which don't fit into the charset, use this string instead of each contiguous pack of invalid chars.

See https://ant.apache.org/manual/Tasks/checksum.html

Only the checksum itself. Example:


            4d75b8402a758db4a96274cf3fa16dbb5f96a9f3edcbd3832d0430f803c2de62
            0c4fddb07efff34d186271b283ba299f0330f5436f98b8053d8d83e99747fc21
            8a6572e910a9bfefbf7ff2696b752b3162ce6062296264dda7eddce9c09ab553

The format of GNU textutils md5sum/sha1sum/sha256sum/sha384sum/sha512sum. Binary mode only. Example:


            4d75b8402a758db4a96274cf3fa16dbb5f96a9f3edcbd3832d0430f803c2de62 */etc/man.conf
            0c4fddb07efff34d186271b283ba299f0330f5436f98b8053d8d83e99747fc21 *dotnet70-arm64/dotnet
            8a6572e910a9bfefbf7ff2696b752b3162ce6062296264dda7eddce9c09ab553 *.local/share/mc/history
            ///

The format of BSD md5 command. Example:


            SHA256(/etc/man.conf)= 4d75b8402a758db4a96274cf3fa16dbb5f96a9f3edcbd3832d0430f803c2de62
            SHA256(dotnet70-arm64/dotnet)= 0c4fddb07efff34d186271b283ba299f0330f5436f98b8053d8d83e99747fc21
            SHA256(.local/share/mc/history)= 8a6572e910a9bfefbf7ff2696b752b3162ce6062296264dda7eddce9c09ab553

Gets whether it's possible to sign with this server at this moment.

Checks if the file fits for signing.

If the signing service is available, sends the file for signing and receives the signed version. If the signing service is unavailable, throws an exception.

Verify the signature of the file. The platform specific method, be careful!

If the file has no signature yet, sends the file for signing and receives the signed version when possible. If the file has a valid signature already, keeps the file AS IS. The signature might be third-party rather than JetBrains. If the signing service is unavailable, throws an exception. See for more automatic and failsafe operation.

If the signing service is available, sends the file for signing and receives the signed version. If the signing service is unavailable, throws an exception.

Returns the original content if the signing server has not been specified for this build (e.g. this is a local build).

A special debug mode flag. Allows to run scripts locally which would assert that signing server info is present without issuing lots of errors.

Default value: OFF.

Forces the signed code's kill flag to be set when the code begins execution. Code with the kill flag set will die when it becomes dynamically invalid. It is therefore safe to assume that code marked this way, once validated, will have continue to have a valid identity while alive.

Forces the signed code's hard flag to be set when the code begins execution. The hard flag is a hint to the system that the code prefers to be denied access to resources if gaining such access would invalidate its identity.

Marks the code as capable of hosting guest code. You must set this option if you want the code to act as a code signing host, controlling subsidiary ("guest") code. This flag is set automatically if you specify an internal guest requirement.

Forces any validation of the code to consider expiration of the certificates involved. Code signatures generated with this flag will fail to verify once any of the certificates in the chain has expired, regardless of the intentions of the verifier. Note that this flag does not affect any other checks that may cause signature validation to fail, including checks for certificate revocation.

Forces the signed code's library validation flag to be set when the code begins execution. The code will only be able to link against system libraries and frameworks, or libraries, frameworks, and plug-in bundles with the same team identifier embedded in the code directory. Team identifiers are automatically recorded in signatures when signing with suitable Apple-issued signing certificates. Note that the flag is not supported for i386 binaries, and only applies to the main executable. The flag has no effect when set on frameworks and libraries.

Enable the Hardened Runtime. See https://developer.apple.com/documentation/security/hardened_runtime On macOS versions >= 10.14.0, opts signed processes into a hardened runtime environment which includes runtime code signing enforcement, library validation, hard, kill, and debugging restrictions. These restrictions can be selectively relaxed via entitlements. Note: macOS versions older than 10.14.0 ignore the presence of this flag in the code signature.

Identifies a signature as signed by the linker. Linker signatures are very similar to adhoc signatures, except: linker signatures can be replaced without using the --force option. linker signatures are never preserved regardless of the use of the --preserve-metadata option. linker signatures will usually not contain any embedded code requirements including a designated requirement.

(DEPRECATED for signing as of macOS 13.0) When signing a bundle, specifies that nested code content such as helpers, frameworks, and plug-ins, should be recursively signed in turn. Beware: All signing options will be applied, in turn, to all nested content. This is almost never what you want. Nested code content is a special term that only applies to macOS style bundles with a Contents folder. Only bare Mach-Os and well structured bundles qualify as nested code content. Non-bundle directories in nested code content locations will cause an error when signing. The codesign tool will only discover nested code content in the following directories: Contents Contents/Frameworks Contents/SharedFrameworks Contents/PlugIns Contents/Plug-ins Contents/XPCServices Contents/Helpers Contents/MacOS Contents/Library/Automator Contents/Library/Spotlight Contents/Library/LoginItems If any code (Mach-Os, bundles) are located outside the above listed locations they will not be signed by the --deep option Using the --deep option on an iOS style bundle without a Contents folder will not cause an error but will only sign the main binary of the bundle. When verifying a bundle, this option specifies that any nested code content will be recursively verified as to its full content. By default, verification of nested content is limited to a shallow investigation that may not detect changes to the nested code. When displaying a signature, this option specifies that a list of directly nested code should be written to the display output. This lists only code directly nested within the subject; anything nested indirectly will require recursive application of the codesign command.

When signing, take the file at the given path and embed its contents in the signature as entitlement data. If the data at path does not already begin with a suitable binary ("blob") header, one is attached automatically. If the signature has no entitlement data, nothing is written (this is not an error).

When signing, causes codesign to replace any existing signature on the path(s) given. Without this option, existing signatures will not be replaced, and the signing operation fails.

Sign the code at the path(s) given using this identity.

During signing, specifies a set of option flags to be embedded in the code signature. The value takes the form of a comma-separated list of names (with no spaces). Alternatively, a numeric value can be used to directly specify the option mask (CodeDirectory flag word).

Flavor parameter that allows to override sign server behavior (like switch to some other certificate).

Identifies the sign server which serves the authenticode signing request without exposing the private keys.

GPG key id to be used for signing by new sign server.

Resigns a delayed-sign assembly with a valid signature.

The assembly. Must be delay-signed, i.e. have the signature RVA in its CLI header, but no "Strong name signed"(0x8) flag, and "Has public key" flag and its RVA in the Assembly metadata table. Strong name key pair for signing, in the same format as the SNK file. The public key must match the one in the Assembly metadata table of the assembly. The private key must match the public key.

A freshly-compiled file output from the Subplatform Compile stage. Will be turned into a SubplatformFileForPackaging automatically, or might be also put to use by some side steps. Don't consume unless pretty sure of what you're doing. Yield instead of a if you consider your step to be a compilation-related one (but this is purely optional).

Now the only non-SDK projects are Avalonia targets which (unlike Avalon and ResX) seem to fare well with NetCore, so use it always, for uniformity and for better perf.

Looks at the set of projects, whether just the managed compilers would be enough to build them, or not.

Allows to link your execution before compiling subplatforms. // TODO: refactor? maybe we might want to generate more files instead?

Defines what actually means when running the compilation.

Embedded files from third-party packages.

Yield this artifact to request embedding contents of a certain Nuget package into the subplatform package being compiled. Some native tools are distributed this way: they're pre-compiled into nuget form, and they're embedded to be always next to the managed DLLs which would be using them.

By default, the stuff is embedded right into the content folder of the package. This option allows to embed into a sub-path under the content folder.

Nuget package which should be embedded into the subplatform.

Nuget package which should be embedded into the subplatform. Optional. If omitted, will be looked up in the central file.

The target subplatform of the embedding.

Handles tasks.

This only requests for retrieval, embed would happen later.

The main application package artifact. Can't be fast, needs real info. Lightweight meta creates an imitation for it.

Companions to , as FAST components (get into lightweight meta).

Produces the part catalog which is to be embedded into the generated subplatform package as a component.

Packages the catalog as the primitive pre-shell object which could be understood by all possible consumers.

The assembly item to use as a resolvable reference. "Kind" part of the origin text (not tostringed or concatenated to avoid doing this unless we need to report a dupe). "Name" part of the origin text. Optional priority, lower comes first, to specify that certain assemblies are less important (e.g. refasm) and should not make a conflict.

The assembly item to use as a resolvable reference.

"Kind" part of the origin text (not tostringed or concatenated to avoid doing this unless we need to report a dupe).

"Name" part of the origin text.

Optional priority, lower comes first, to specify that certain assemblies are less important (e.g. refasm) and should not make a conflict.

Packages identified by these artifacts will be excluded from Assembly Master Binder resolve when building catalogs for subplatform assemblies. This might be required as a dirty hack when you are taking assemblies from packages and planting them manually into the subplatform package. The marked package must be a development-only reference (such references are not present at runtime; for a normal shippable reference, excluding it from cataloging is questionable). DO NOT USE this without prior discussion. All current uses are a mistake which should have been handled otherwise.

Specifically handles creation of subplatform packages.

Asserts that all of the items which have been supplied for packaging are attributed to actually-present subplatforms-on-sources. Otherwise they'd just to to /dev/null which is not a big problem on itself but their production might be costly and would be run in builds which do not need it. So let's ensure the producers only do them when needed.

A placeholder build helper to ensure some helpers are always registered for the interface, and resolve succeeds for them.

Runs a nested build which works off sources. Sets up parameters for the nested stage run correctly.

Allows to have a go on files which are to be packaged into a subplatform, after they all are produced, but before they are packaged.

Executed in ascending order.

Applies the transformation by modifying the list of files. You should not modify the file contents directly, but by removing the item and inserting another one for the same path you can effectively modify the file contents. Yield Null if you don't want to modify.

Mocks Launcher in a compile-time-build-script-accessible form.

Mocks Launcher::ConsoleMainMethod in a compile-time-build-script-accessible form.

Mocks Launcher::MainMethod in a compile-time-build-script-accessible form.

The original ID of the Nuget package.

The display name for presenting end-user info on this library. Prefers the Nuget package title, or reverts to the Package ID if the former is not available.

Allows certain subplatforms (such as root packages of projects) to specify a custom license agreement for the Nuget package rather than the default ReSharper SDK license agreement.

BE VERY CAREFUL TO MODIFY THIS CODE BECAUSE EVERY CHANGE SHOULD BE APPROVED THE LEGAL TEAM!!!

A dictionary that stores SPDX expressions matching our licences

A dictionary that stores licenses explicitly assigned to packages

A dictionary that stores copyrights explicitly assigned to packages

A dictionary that stores Uris matching our licences. Used to convert well-known Uris to licenses

A dictionary that stores license file hashes matching our licences

A dictionary that stores explicitly assigned copyrights to license file hash

A dictionary of all available licenses

Class that holds all license information

License enum value

License kind: standard or custom

Name of the license (without copyrights templating)

Full text of the license. Valid for custom licenses.

Comment to the license full text.

SPDX expression for standard licenses

Basic license Uri (without copyrights templating)

Indicates if license full text is loaded. Full text can be provided during custom license creation or can be loaded from package.

Indicated that copyright is mandatory for this license

Get license Uri with embedded copyright

Get license name with embedded copyright

THIS IS THE CLOSED LIST OF LICENSES!!! PLEASE DO NOT ADD NEW LICENSES HERE WITHOUT APPROVING THE LEGAL TEAM!!! PLEASE ASK THE RESPONSIBLE PERSON BEFORE MODIFICATION IF YOU DON'T UNDERSTAND SOMETHING COMPLETELY OR DOUBT SOMETHING!!!

A strongly-typed resource class, for looking up localized strings, etc.

Returns the cached ResourceManager instance used by this class.

Overrides the current thread's CurrentUICulture property for all resource lookups using this strongly typed resource class.

Looks up a localized string similar to DEVELOPER EXPRESS INC ASPxGrid and Editors(tm) SUITE SOFTWARE COMPONENT PRODUCT ASPxperience(tm) SUITE SOFTWARE COMPONENT PRODUCT ASPxPivotGrid(tm) SUITE SOFTWARE COMPONENT PRODUCT eXpress Persistent Objects XtraBars(tm) SUITE SOFTWARE COMPONENT PRODUCT (Trial) XtraCharts(tm) SUITE SOFTWARE COMPONENT PRODUCT XtraEditors(tm) LIBRARY SOFTWARE COMPONENT PRODUCT XtraGrid(tm) SUITE SOFTWARE COMPONENT PRODUCT (Trial) XtraLayout(tm) SUITE SOFTWARE COMPONENT PRODUCT (Trial) XtraNavBar(tm) SUITE SOFTWARE C [rest of string was truncated]";.

Looks up a localized string similar to # MICROSOFT SOFTWARE LICENSE TERMS # MICROSOFT EXPRESSION BLEND SOFTWARE DEVELOPMENT KIT FOR .NET FRAMEWORK 4.0 --- These license terms are an agreement between Microsoft Corporation (or based on where you live, one of its affiliates) and you. Please read them. They apply to the software named above, which includes the media on which you received it, if any. The terms also apply to any Microsoft * updates, * supplements, * Internet-based services, and * support services for this software, unle [rest of string was truncated]";.

Looks up a localized string similar to License text was taken from https://visualstudio.microsoft.com/license-terms/expressionblendsdk/ on 12.09.2024 by Konstantin Kretov.

Looks up a localized string similar to # MICROSOFT SOFTWARE LICENSE TERMS # MICROSOFT .NET LIBRARY --- These license terms are an agreement between you and Microsoft Corporation (or based on where you live, one of its affiliates). They apply to the software named above. The terms also apply to any Microsoft services or updates for the software, except to the extent those have different terms. --- **If you comply with these license terms, you have the rights below.** **1. INSTALLATION AND USE RIGHTS.** You may install and use any [rest of string was truncated]";.

Looks up a localized string similar to # MICROSOFT SOFTWARE LICENSE TERMS # MICROSOFT SQL SERVER 2017 SHARED MANAGEMENT OBJECTS --- These license terms are an agreement between Microsoft Corporation (or based on where you live, one of its affiliates) and you. Please read them. They apply to the software named above, which includes the media on which you received it, if any. The terms also apply to any Microsoft * updates, * supplements, * Internet-based services, and * support services for this software, unless other terms accomp [rest of string was truncated]";.

Looks up a localized string similar to License text was taken from https://learn.microsoft.com/en-us/sql/relational-databases/server-management-objects-smo/smo-license-terms?view=sql-server-ver16 on 12.09.2024 by Konstantin Kretov.

Looks up a localized string similar to # MICROSOFT SOFTWARE LICENSE TERMS **MICROSOFT VISUAL STUDIO 2017 TOOLS, ADD-ONs and EXTENSIONS** --- These license terms are an agreement between Microsoft Corporation (or based on where you live, one of its affiliates) and you. They apply to the software named above. The terms also apply to any Microsoft services or updates for the software, except to the extent those have different terms. --- **IF YOU COMPLY WITH THESE LICENSE TERMS, YOU HAVE THE RIGHTS BELOW.** **1. INSTALLATION AND USE RI [rest of string was truncated]";.

Looks up a localized string similar to License text was taken from https://visualstudio.microsoft.com/license-terms/mlt552233/ on 12.09.2024 by Konstantin Kretov.

Looks up a localized string similar to License: Custom License MICROSOFT SOFTWARE LICENSE TERMS MICROSOFT WINDOWS API CODE PACK FOR MICROSOFT .NET FRAMEWORK ___________________________________________________ These license terms are an agreement between Microsoft Corporation (or based on where you live, one of its affiliates) and you. Please read them. They apply to the software named above, which includes the media on which you received it, if any. The terms also apply to any Microsoft • updates, • supplements, • Internet-based services, [rest of string was truncated]";.

Looks up a localized string similar to License text was taken from https://github.com/aybe/Windows-API-Code-Pack-1.1/blob/master/LICENCE on 12.09.2024 by Konstantin Kretov.

Looks up a localized string similar to # MICROSOFT SOFTWARE LICENSE TERMS **MICROSOFT WINDOWS SOFTWARE DEVELOPMENT KIT (SDK) FOR WINDOWS 10** --- These license terms are an agreement between Microsoft Corporation (or based on where you live, one of its affiliates) and you. Please read them. They apply to the software named above, which includes the media on which you received it, if any. The terms also apply to any Microsoft * APIs (i.e., APIs included with the installation of the SDK or APIs accessed by installing extension packages o [rest of string was truncated]";.

Looks up a localized string similar to License text was taken from https://learn.microsoft.com/en-us/legal/windows-sdk/license on 12.09.2024 by Konstantin Kretov.

Looks up a localized string similar to This license is valid for businesses and organizations. For individuals or specific types of customers, the license can be different..

Looks up a localized string similar to # SOFTWARE LICENSE AGREEMENT **for yFiles WPF** Dated June 01, 2017 This Software License Agreement is a legal agreement ("Agreement") between you or the entity you represent (referred to as "you" or "Licensee" as identified in more detail on the applicable license order) and yWorks GmbH ("Licensor" or "yWorks"). By downloading, installing, or using the yFiles WPF software (together with its accompanying documentation and support material, collectively "Software"), you indicate that you read and a [rest of string was truncated]";.

Looks up a localized string similar to License text was taken from https://www.yworks.com/products/yfiles-wpf/sla on 12.09.2024 by Konstantin Kretov.

Provides a task scheduler that ensures a maximum concurrency level while running on top of the ThreadPool.

Whether the current thread is processing work items.

The list of tasks to be executed.

The maximum concurrency level allowed by this scheduler.

Whether the scheduler is currently processing work items.

Initializes an instance of the LimitedConcurrencyLevelTaskScheduler class with the specified degree of parallelism.

The maximum degree of parallelism provided by this scheduler.

Queues a task to the scheduler.

The task to be queued.

Informs the ThreadPool that there's work to be executed for this scheduler.

Attempts to execute the specified task on the current thread.

The task to be executed. Whether the task could be executed on the current thread.

Attempts to remove a previously scheduled task from the scheduler.

The task to be removed. Whether the task could be found and removed.

Gets the maximum concurrency level supported by this scheduler.

Gets an enumerable of the tasks currently scheduled on this scheduler.

An enumerable of the tasks currently scheduled.

JetBrains-specific names of MSBuild file entities, as an addition to values.

Parameters names on parameters passed within Task Items via ProxyToSolutionCompiledTask. These values are written into metadata.

A parameter name give key-value pairs of strings (in a form of Name=Value in the item spec) which should be compiled into assembly attributes to specify custom metadata values (originally, by emitting an attribute, because it's a suitable string key-value attribute available without any extra references).

SDKMini specific property. Specifies the assembly description which goes both into emitted managed assembly attributes and into VERSIONINFO native resource. Optional. If set, it's an error to have a managed property manually declared. If not set, VERSIONINFO will have some defaults generated based on the subplatform/assembly.

A parameter name to transfer the artifact values (plural) to the SDK build.

A parameter name to transfer the artifact value to the SDK build.

Standard prop, CPU choice.

A parameter name to give a rel hint to product binaries dir.

A parameter name used by .

SDKMini specific property. Specifies the assembly title which goes both into emitted managed assembly attributes and into VERSIONINFO native resource. Optional. If set, it's an error to have a managed property manually declared. If not set, VERSIONINFO will have some defaults generated based on the assembly name.

A parameter name to transfer the artifact values (plural) to the SDK build.

A with .

See docs in . Used in managed project stuffing. Produced only when running a non-incremental (isolated) build driven from ABuild. Specifies the folder which holds the binary reference files to be used instead of the project references.

Specify whether it should be signed on build agents always.

Allows to mark a project which compile into managed assembly, but this assembly should not be visible to the running product as managed product assembly with possible components inside. Technically, project output will be packaged with role rather than . As a result, it won't be listed with as an assembly (won't have an assembly name on a file), catalogs won't be build for them, components won't run from them, and so on.

Special property for set obj and bin folder for C++ projects.

macro value on the which we generate. With no property value, has the default behavior. Or could be set to any desired True/False value on projects.

NOTE: Currently not emitted, example emit: yield return new GeneratedMsbuildProperty(MsbuildFileJet.Properties.JetRemoteCacheUrl, distributedCacheParams?.RemoteCacheUrl ?? "", subandproj); NOTE: preferrably, DO NOT emit the common property, better emit a single property per each feature which wants to see it, this way it's better to track dependencies

Prefix for per-VS-version props which tell the VS install dir on this machine, in XXYY format, e.g 1200. For instanceid-aware VSes like 15 it appends the instance ID to the version, but also picks a random any of them for publishing as the bare version without the instanceid suffix.

Set to the name of the profile for which the targets file has been emitted.

For , name of the emitted MSBuild target which removes task items with project references before the call into /, to avoid warnings on missing projects if they are missing, or avoid use of actual local projects if they are present, but not included with the current profile.

DefaultProjectConfigurationName. In main solution projects, their only project config.

Within an item whose parameter name is in , a name of the metadata which has the 4-component version number to be used with all assemblies. Expected to be defined when emitting the SDK Parameters.

Task items for non-DLL files in the subplatform package targets file, path is in .

In-package path to the JetMetadata file of a subplatform package, a task item in the subplatform package targets file.

The full list of references in the targets file we emit into the produced subplatform packages.

Classic projects are stuffed by emitting a side-Targets file which gets included into the project. This includes both statically-defined parameters to set up MSBuild and dynamic parameters which depend on the current profile settings. SDK-based do not have a side-Targets file. Their statically-defined parameters are defined right in the SDK, and dynamic per-profile parameters are written into the common settings file which is read by the build task of the SDK. For uniformity, this settings file is formatted as an MSBuild file, and all parameters are task items of this item name. These task items are formatted ready for passing as parameters to a ProxyToSolutionCompiledTask, including a on them.

Lists dirs which should be deleted to invalidate MEF.

A task item for our in-solution generator custom task.

In the Nuget Package Version Locks file (see ), an imitation of an MSBuild task item which maps the key (usually, a package ID) in the item spec to the .

A task item for our in-solution generator custom task.

When referencing a Nuget package with , allows to exclude certain DLLs in it from referencing. Given as a separate task item for now.

Allows to add custom Win32 resources. Identity: points to file with resource data. Name metadata: resource name (ordinals prefixed with a hash). Type metadata: resource type (ordinals prefixed with a hash, RT_xxx standard resource names allowed).

In the file, an attribute on an entry (imitates setting MSBuild file metadata on a task item) which makes . Might be either unset, or a valid value string representation.

1) Custom meta on for our SDK Mini. 2) In the file, an attribute on an entry (imitates setting MSBuild file metadata on a task item) which makes . Might be either unset, or a valid value string representation.

When passing all task params in a TaskItem, this metadata holds the parameter name in that item. By the ProxyToSolutionCompiledTask / Satellite MSBuild task convention.

In the file, an attribute on an entry (imitates setting MSBuild file metadata on a task item) which makes . Might be either unset, or a comma separated list of .

Same as prop name, but for metadata.

Path on the task items in the subplatform package targets file.

When writing out file to a custom location (e.g. when compiling), passes the specific path to this file to MSBuild.

Like , but as a single number for linear order. Format: Major*1000 + Minor, e.g. 3005 for v3.5.

See https://github.com/Kitware/CMake/blob/master/Source/cmState.cxx#L815 See https://github.com/Kitware/CMake/blob/master/Source/cmState.cxx#L818

Rel-to-product-home path to the directory with native package references, those directly used from native projects for includes and libs. This MUST be in sync with JB_PACKAGES_DIR definition in the Common.DirectoryStructure.cmake file, which is the only entry point for this location on the C++ projects' side. Note that individual tools which are called by the C# build infra or whose paths are passed to CMAKE explicitly aren't included here, they sit in their own directories. Should keep things separate whenever possible.

null - use instead.

Note: Only MsBuild!!! Note: Only MsBuild!!! Note: Only MsBuild!!! Note: Only MsBuild!!! Note: Calculate overridden PATH to isolate tools. Very important on agents!!!

Native stuff needs their native packages local-restored ONLY when (a) C++ dev mode (b) actually compiling the natives (not hitting the distro cache). This helper does the extraction on-demand.

Get the current platform solution for all suitable architectures and configurations in packages splitted into and . The subplatform names has following format: <prefix>\<platform>\<subplatformType>\<postfix>.

Runs a nested build which works off sources. Sets up parameters for the nested stage run correctly.

Generic. Goes to the main package, .

Managed assembly (.dll or .exe). Goes to the main package, .

Native executable or shared library (.dll, .so, .dylib, .exe or w/o extension). Goes to the main package, .

Native link library file. Goes to the main package, .

PDB file. Goes to the separate .symbols package.

.targets or .props file to import in package main build files.

XmlDoc file for some managed assembly. Goes to the main package, .

A .targets or .props file which should be recognized as such by Nuget when processing the main package as a reference. Goes to the main package, Nuget's Build folder.

A component in the subplatform package components which holds the part catalog for the package managed assemblies.

The Platform project has been cleaned up of all the compilation warnings. Useless technical values have been suppressed, and useful ones have been fixed. Note that this is also possible to enable the warning for in-VisualStudio analysis yet disable it for compilation. To maintain this clean state, a validator is imposed.

Skips the compilation stage steps (those before obtaining the nuget packages) that rewrite compiled assembly before they're added to the package. An example of such rewrites are obfuscation steps. This interferes with the "Do not compile" local scenario because after the DLLs are extracted to Bin Dir from the compiled nuget packages, it would be used as if it were just compile and will get into rewrite for the second time.

When we're about to compile a subplatform (for example, get a nupkg for it by running a build with it as a for goal), tells which special requirements this subplatform has in this mode.

Components which are to be serialized into the package metadata.

Base class for different stages of components intended for being put into subplatform Nuget packages. The full family of these files includes: • — the most common one ("Common"). Yield this if not sure and want to add smth to a package. • — yield instead of the Common one if your yielding graph is FAST enough to be included with Prepare Working Copy. I.e. it shan't result in a compilation. These items are merged into the Common list automatically. — Scenarios: • Main, or Full. When producing Nuget packages for subplatforms, either to deploy, or to local-install. All producers for Common and Fast items are executed (all end up in the Common list), and fed into the package producing code. That's what also happens when you run the full version of the Extract to Bin Dir task. All the necessary compilations are invoked in the course. • Prepare Working Copy. Only FAST items are produced, and only them are written to the Lightweight Metadata Files (). This should be somewhat enough to develop and run tests, even though a full Local Install or Extract to Bin Dir is recommended. But FAST is FAST and can be done before opening the solution.

The component instance to be serialized into the package metadata.

The target subplatform.

Components which are to be serialized into the package metadata, and which can be produce fast enough to be run on the Prepare Working Copy stage.

Contributes the fast items to the full list of items.

Base class for different stages of files intended for being put into subplatform Nuget packages. The full family of these files includes: • — the most common one ("Common"). Yield this if not sure and want to add smth to a package. • — yield instead of the Common one if your yielding graph is FAST enough to be included with Prepare Working Copy. I.e. it shan't result in a compilation. These items are merged into the Common list automatically. • — a special flavor of files which are the compilation result. Needed for some hacking when you need to reference other compiled files before they're in the package. These items also are merged into Common. • — don't yield these. They're produced out of Common by applying handler. And that's what specifically gets added into the package. — Scenarios: • Main, or Full. When producing Nuget packages for subplatforms, either to deploy, or to local-install. All producers for Common, Fast and Compiled items are executed (all end up in the Common list), then transformers are applied, then the resulting Transformed list is fed into the package producing code. That's what also happens when you run the full version of the Extract to Bin Dir task. All the necessary compilations are invoked in the course. • Prepare Working Copy. Only FAST items are produced, and only them are written to the outdir. This should be somewhat enough to develop and run tests, even though a full Local Install or Extract to Bin Dir is recommended. But FAST is FAST and can be done before opening the solution.

A file which will be put into the Subplatform Binaries Package of the specified subplatform, which is the primary compilation output for that subplatform. You should yield this artifact if you want to add something to the package being produced for the subplatform. FAST mode: only yield this from steps which are fast to execute, so that this could be run as a part of the Prepare Working Copy task.

Contributes the fast items to the full list of items.

Package-embedded metadata which points to the original SCC revision which compiled this package.

Third-party license info for specified files in subplatform

In a subplatform package, there are assemblies, some of them referencing assemblies from dependency packages. If those packages are development-only (say, Visual Studio), such references might be missing on the target machine, and that's expected and non-critical for the means of cataloging and so on. This is a whitelist of assemblies which are allowed to be missing when resolving references. is a Subplatform Package Component (), embedded into the packages and then loaded at runtime by this name. is an artifact emitted at sources stage which is then turned into and written to the package, as well as used for other parties which want to know the list of assemblies-ok-to-be-missing.

The stuff to whitelist.

The target subplatform this applies to.

Data storage class, and a package component.

All native symbols.

All managed symbols.

Causes the subplatform packages compiled in presence of this artifact to be timebombed at the moment given by the time span in this object. Specifies the timespan between and . A NULL or nonpositive value (an empty string in string form) will result in no BB on packages.

The timespan between and . A NULL or nonpositive value will result in no BB on packages build in presence of this value.

That's what actually gets packaged into the subplatform nugget, after applying all of the transforms. Don't yield these directly, use instead.

Takes , runs on them, produces which will go into the nuggets.

NULL if you do not want to modify.

Asserts the list of managed assemblies in this package is not modified after your transform runs.

For a transform, asserts that subsequent transformations do not violate its expectations. Like, if it computes data from all assemblies in the package, subsequent transformations must not be adding new assemblies.

The output of some later transform which should be tested for being consistent with expectations of this transform. The transformer which did the transform we're inspecting. For using its name in the diagnostics.

Controls how the validate/autofix steps run. On the server, they should not be touching the sourcecontrolled files. On client, when run by command, they should apply fixes automatically where applicable.

If this artifact is set to True, the will not do its checks. This suppression is intended for server builds because, while locally it helps with fixing the local case mismatches, on the server it's (a) not needed due to a case-insensitive filesystem always, (b) not wanted to do WC modifications, (c) not consistent with the flag because the server does not have it and it would just issue an error without this flag.

If this artifact is set to True, sources will not be validated before being compiled into Nuget packages. Locally this speeds up repeated runs of packages generation. Shan't be set to True on the server.

Pulls various validations on the sources codebase — which don't require the compiled binary form, but require the source code to be available in the home dir.

Requests that compilation of certain subplatforms be clean.

Denotes a subplatform or a collection of subplatforms for which clean compilation without warnings should be ensured.

Let SDK-Mini projects know the prefixes.

The legacy FN for manual checking of the encodings, enforced BOMs.

Either pure ASCII or UTF-8 with a BOM.

A file without BOM with non-ASCII chars. Suspicious for a 8bit encoding, which means characters might be interpreted differently depending on the context: hg will think then utf8, C# will consider ANSI, either 1252 or 1251 or whatever else. The worst case scenario I've seen were a Japanese box on which some of the 1252-usual chars were illegal bytes breaking compilation. To deal with that, make it Unicode. Also might be a Unicode file without a BOM, but also to avoid ambiguity we'd like to enforce the BOM.

The file has zero bytes in it. Either a non-text file with a text extension. Or maybe UTF-16 without a byte order mark. See below for that.

A UTF-16 file with a BOM. Should better be changed to UTF-8. For instance, HG thinks such files binary (by the zero bytes) and fails with all diff/merge stuff, so any merge conflicts are a mess.

A UTF-32 file with a BOM. Should better be changed to UTF-8. For instance, HG thinks such files binary (by the zero bytes) and fails with all diff/merge stuff, so any merge conflicts are a mess.

Default files filter.

Allow-filters are applied to the file set first. Only matching files are let thru.

Deny-filters are applied to the allowed file set. Matching files are dropped out.

For the file with local name in directory , returns its casing as given in the index, matching case-insensitively, or an empty string if the file is not present in the index.

Creates a ZIP file, streaming fashion, without using intermediate storage. Makes sure all entries have their sizes assigned correctly. Assesses each entry if it's compressable and writes in storing mode if not.

Per-entry compression control.

Tests each entry content on whether compression would actually decrease its size, so it won't re-compress already-compressed entries (eg nested zips/opcs/nugets).

Stores all entries without compression. Efficient for in-memory direct stream access. Saves time if you know your stuff won't compress.

Forces compression on every entry.

A package result of the build which should go to deployment. This includes subplatform-compiled packages and Nuget references of subplatforms (those which are not development-only references).

Lists the subplatforms for which this package with these flags has been issued.

The package is retrievable from the external Nuget server and has been obtained from it (rather than calculated during the build), so there's no need in carrying it around.

The package has been built as a native image for the subplatform managed DLLs.

The end-user entry point artifact to create a packed installer and copy it to Bin folder.

The end-user entry point artifact for preparing the local working copy. Runs in a nested build with all the full context.

The main local entry point for running second-stage builds which require already-compiled packages produced in the source stage. Runs both stages of the build: first, the source stage to produce the packages (for artifact, with all options for Incremental Build or Dont Compile, if passed); then, the second stage for the given artifact).

Implements the local binstage entrypoint.

The entry point for running a source-stage build (i.e. right on BuildScript sources from the main solution, no product packages compiled yet). Runs the source stage on build script sources from across the whole solution (from under BuildScript folders in Subplatform and Project dirs, regardless of whether they're included with any project) for the given artifact. The difference beween running the build for with your target artifact in and running the build directly for your target artifact is that the standard build bootstrap code only cosiders build script sources under Platform Core, for speed and reproduceability and because bootstrap code does not have the yet to find all build scripts correctly, while already runs on the up-to-date Shell project build script code and loads build scrtips for the whole solution, so it's a way of running a build for an artifact which sits under another project.

Implements the local source stage entrypoint.

The end-user entry point artifact for preparing the local working copy + opening solution in Visual Studio.

The test entry point for fast debugging of build steps.

Prototype for splitting and running the build across the multiple hosts, as needed to have compilations run on specific runtime. For now, expects the full sources codebase to be available at every host.

Product home dir to build from. Links to results of prev layers. Based on this, decides which layer to build. Custom string artifacts to apply to the Compile stage. Artifacts applied to this build WILL NOT be applied to compilation automatically. Takes All Assemblies from the build pipeline, which means it's affected by and //. Allows thus limiting the graph, issues a warning.

Links to results of prev layers. Based on this, decides which layer to build. Custom string artifacts to apply to the Compile stage. Artifacts applied to this build WILL NOT be applied to compilation automatically. Tells for which objectives to run the binary stage of the postcompile build.

No stages have been skipped from prev layers. A new layer should be getting all of the results.

Number of prev layers in the set.

Common for bin/src

Paint graph nodes (subs) with layer numbers Platform core is layer #0 Any other node is a max of all parent dependencies, a parent dependency takes the same layer as parent if it can be built on the same host, or adds 1 if needs to switch host Then we get the number of layers we'd have, might need multiple kinds of hosts within each layer Assume we complete each layer first and then run the next layer with all build results from all previous layers NOTE: for now, we assume all neutral subs use WinNT

Entry point for the Binary Stage Post-Compile build. Also carries the outputs. They'd get written under the outdir of the build.

Entry point for the Compile build. Also carries the outputs. They'd get written under the outdir of the build.

Build nodes planned on this layer. They can run in parallel and do not depend on each other.

Input artifacts for a multi host build.

Results from prev layer builds.

Serializes to a file item.

Supply this input artifact to instruct the binary post-compile stage run a build for the target given here.

Name of the artifact which should be an objective for a multi-host build's binary post-compile stage.

Results from prev layer builds.

Dir with results from prev layer builds (checked recursively).

Single build node on a layer.

Requirement for running this node.

Subplatforms to be built on this node.

Set of layers planned for build. Each layer is run sequentially after prev layers and given all of their outputs. Nodes within a layer run in parallel.

Implementation for TeamCity build entry points. Has code which begins running on TeamCity and then executes the regular compile or binary stages. Knows how to pass artifacts out to furhter builds and how to get them from preceding builds in the chain.

When bootstrapping in the Platform Core chain starting build, makes a build runner executable which is fully compatible with the current sources, names it thus, and passes along the chain as an artifact dependency. All further builds run off it.

The build engine binaries and core build script are saved to this file by the bootstrapper build. The outermost isolated build session is run off this set for all other compilations and binary stages.

Default name of the output dir for the build which produces the isolated request () to write its outputs, unless overridden.

Default name of the output dir for the build which runs the build on the isolated request and makes the raw isolated result. By default, the dir is created under where the isolated request/bootstrap/runner is located, so it's under the .

When running inside a TC build, scans all snapshot dependencies, transitively, to fill . This is expected to run in a non-isolated build, which has access to .

Runs for , called by the second stage of the TC bootstrap build which should take the isolated request and execute a build for it. Runs a nested build on the isolated request (supposedly, for , but that does not matter much for this code).

Platform Core Compile, among other things, also does the regular Compile. Take the regular compile results and repost them as our result.

Platform Core Compile prepares build runner env for all other builds off the current sources, bootstrapped. This part makes the build runner, necessary config files, and preps the entry scripts.

Runs within the regular Compile stage after s have been produced, to pack them in a form for consumption in further builds in the chain (with unique produces as package bodies, and with retrievable packages listed as IDs for retrieval). This is the target artifact for Compile builds on the CI server.

Compile stage main results. Tells which packages are expected from previous builds as produces, mark them as passthru.

Publlishes a build number based on the current WAVE and current versuffix to TC. Remember to pass this versuffix to all nested builds, otherwise theirs might differ (will be generated from their own current time).

Operations on the root dir after running the build.

Along with the isolated request file, writes the bootstrapping code to execute it: the build runner core, and the cmd entry point.

Path to the runner core file, must have been given when starting the build. The expected request file name, no dir. The PHDA. The request is bound to this PHDA, write its name to the bootstrapper to then make sure it runs correctly.

Tells the build the full path to a Build Runner Core EXE (compatible with the current sources), so that the implementation could schedulle scripts executing it.

Invokes the callback for each OS, builds a multi-OS command file.

Like , but with the current directory separator char.

Stores packages obtained from the prev builds, after they're all downloaded and collected together.

The entry point for the CI server build which reads the settings from the server and prepares the request to run the build in a fully isolated manner.

Written to the isolated request by , lists which packages were obtained from previous builds as their produces, so that could list them as required pasthru packages.

Package IDs, sorted.

TC prop name which marks a build type as declaring that it MUST produce a compile result, and missing compile result is an error. This name MUST be in sync between the TeamCity configuration property and C# TeamCityTasks code.

ID of the specific build instance, e.g. 22357579. Used for identifying build in queries, like getting props and artifacts.

External ID of the build type, e.g. DotNetDiv_Wave11_Compile_DotMemory. Used for diagnostic display.

TeamCity properties, as they were reported on the build.

Full serialized isolated build request for .

See . This artifact is run as an inner build within it, to execute the actual isolated request file from disk.

Build result for the isolated request run in the Compile Platform Core build. The isolated request execution CMD file runs the bootstrap script on the older build runner version for BuildRunnerCoreCallResult, which makes an engine off the current sources and runs it for , which loads the prepared isolated request which runs for and returns its result. It should bootstrap, compile the Platform Core subplatform, produce it as a build result, make a bootstrapped build runner out of it, and prepare all files required for running builds in all the subsequent steps. Includes just like all other compile builds, but that's just one of the files here rather than the only file. is for non-core compile builds.

The result of a Compile stage. Normally, the stage produces a set of files. Publishing the full set of these files generates overhead on the storage and when subsequent builds retrieve previous build results over multiple paths. So the build should only publish what is uniquely produced in it, and omit anything which has been received either from Nuget server (precompiled dependencies) or from previous builds. These must be listed explicitly though, so that the consumer could validate that it has assembled the full set from all the original sources.

Identities of the output deployable packages which have been originally retrieved from the external Nuget server as ready binary packages. The content is not written for these, they should be re-retrieved when neeeded.

The packages which have been produced by this build. These are the only kind for which there is content and not just identities.

Identities of the output deployable packages which have been produced by some other build, and this specific build has received them in ready binary form. The content is not written for these, they should be obtained from dependee builds.

A wrapping for to represent it as a build output file for automatic registering as a build result. This is the build artifact, while is the data stored in it. Non-bootstrap compile builds produce this artifact (= all compile builds except for Compile Platform Core, see for those).

File name for serialized file items.

When running a build for , defines if we're making the request for the Platform Core and Bootstrap build rather than a regular isolated request. These differ in two ways: platform core does not have and cannot have parent builds; and the build runner files to run differ because in bootstrap it's a CMD and in non-bootstrap it's the bootstrapped exe.

When running a build for , specifies root directory (like for compilation or for tests) for the needs of preparing the request. The specific root dir to be written to the request is not specified in this context, and should be passed as a regular artifact.

When running a build for , specifies the objective to set on the isolated request. The isolated build would be run for these objectives.

Extracts info from our solution for a sparse checkout profile.

Minimal for running build scripts, has the Platform Core Shell sub and subplatform info for the whole profile.

The full version consists of three numbers and an optional suffix. Supported suffixes "EAP X [D]", "RC X" and "EXP X". ATTENTION: The is unsing in automation!!!

The parsed full version.

A description of an experimental build to be shown on Help/About dialog.

Full marketing version without any spaces, e.g. "2018.1.1EAP1D"

Current Wave technical number, e.g. 182.

Product icon for Control Panel. If the file exists in the product bin dir, it is used as product icon for Control Panel Add/Remove Programs.

VS host icon for Control Panel. If the file exists in the product bin dir, it is used as product icon for Control Panel Add/Remove Programs.

Helps with the code which MUST be executed on a STA thread within the build.

Gets the scheduler which you might use for placing tasks on a STA thread within the build. You MUST link these tasks to your build step task so that no execution were left behind your build step on that thread.

Yields asynchronous execution to a helper STA thread. That thread is created on-demand for the build to execute activities which cannot be run on an MTA thread (require a dispatcher or involve operating on interactive UI objects). Proceeds on the thread pool after executing the action.

Runs the CDB debugger to watch for second-chance exceptions in the own process and descendants.

Evades self-attaching a debugger for trapping second-chance exceptions within the test run with . Might be needed if it affects the tests (e.g. they want to use their own debugger) or if it slows down the process considerably.

Knows how to choose a .NET Core SDK package for the current runtime. Can install it and locate characteristic tools within. Instance members are for the current runtime. Static implementation members all take it as a param.

Gets if we have a .NET Core SDK for the current runtime. Most other members will throw if not.

Nuget package with .NET Core SDK for the current runtime, throws if N/A.

Downloads and local expands the .NET Core SDK package for the current runtime (or throws if N/A, see ). Locates and returns the path to the DotNet Host entry point executable.

Downloads and local expands the .NET Core SDK package for the current runtime (or throws if N/A, see ). Locates and returns the path to MSBuild in it.

Gets the NetCoreSDK suitable for the current runtime, if avail.

Gets the NetCoreSDK suitable for that runtime, if avail.

Gets the NetCoreSDK suitable for the current runtime, if avail.

The full procedure helper. For the current runtime, use instance properties.

Gets the artifact strings from the environment, which includes the env variables, TeamCity properties when running in TeamCity, or app properties when running user-interactively. This is the main channel which allows to conveniently transfer TC properties to the nested stages as strongly-typed artifacts.

Does and adds them to of this .

Gets the artifact strings (name-value pairs) which can then be applied to the nested build request as input artifact strings.

A part of the extensions to which requires references to Shell project.

Same as , but does not submit the new artifacts for inputs, assumes those are already in the request, and just have to be registered as build script binaries / looked up for the custom engine bins.

Submits the given artifacts for: 1) Input artifacts of the build request (in binary serialized form), . 2) Build script binaries from which runtime types for artifacts, steps, etc would be used — by referencing a copy from the input artifacts, to save space, . 3) Build engine custom binaries — by looking up relevant build engine files in the content, if requested, . The artifacts must comply with serialization layout for this to work (most easily, be derived from it).

For caches which depend on this SKIA rendering.

Identifies the tool server access info by giving the URI, and auth username + password. The serialized form would be Username:Password@URI. NOTE that this is NOT exactly the URI format for username and password, because the user info goes before the URI scheme and not after it, for simplicity of parsing.

The parsing overload.

Written into serialized host components. Defines the zone to run the host in.

Marks artifacts which help with skipping certain operations when local-building.

A Nuget package supplied to the whole build sequence for input.

Derives from to comply with serialization layout requirement for reuse as .

Json with information about all packages and products. Required for web installer.

Json with information about all packages and products. Required for check for updates only.

(DK) In fact the artifact is Optional-Single, it's made Plural to be able to return an empty collection.

The standard executable with packed content, like Build System, DotPeek Pack, or Installer Pack, as produced during the build.

Stuffs all main installer-portables-zips artifact file names with the current version number (unless preparing for RTM submission). This allows for tracking their exact versions after they get downloaded from TC, and mapping to their exact originating TC build.

Begins the file name with this string.

Begins the file name with the company name.

Opts out of adding the "Checked" suffix to the name in checked mode. Use for artifacts independent of assertion mode

Adds the file extension to the end. If you add a dot to the extension, it will still be handled correctly.

Adds one more component to the beginning of the file name (before the variable parts), in order of appearance. Multiple components are dot-separated.

Denotes that it's not a complete file name, and it should not have an extension added.

Renders the final string. It's presented as a rel-path to make sure it's a filesystem-valid file name. Includes custom names, suffices, extension, wave marketing name, checked suffix, and so on. For non-deployment builds, also adds ther TeamCity build origin string (TC build number in parentheses) before the file extension. This won't be included with the deployed file names.

Adds a custom suffix to the file name, dot-separated. This goes after the standard suffices; all custom suffices are written in order of appearance. The only things going after these are the extension and the autogenerated TeamCity build identity in parentheses.

Adds the marketing name with the current flavor suffix (from ), with spaces removed, to the file name, after the prefices.

10.1.EAP1

A file that might be added to deployment packages (like the installer, zips, etc) and identifies the identity of the packaging itself by getting unpackged to the installdir. The first line of the file should have the semver of the build which has done the packaging, which is equal to the TC build identity and thus can track the originating TC build of this specific installation. This identity is not important because a deployment package is almost fully identified with the set of packages comprising it and their identities (but for possible TC options change), but this gives little help with finding the exact originating TC build with its changes list and status and all, as packages are reused, while the packaging identity does not mean much about the contents, but points to the originating TC build.

The file for inclusion with the packages. Used by , call it (or ) instead of using this directly.

A relative path from VS InstallDir (the IDE folder) or VS local app data folder to the Extensions folder.

A relative path from VS InstallDir (the IDE folder) or VS local app data folder to the JetBrains extensions folder.

A relative path from VS InstallDir to the special file which has to be touched on VS11 to signal that configuration has to be rebuilt on doing devenv/setup.

Path to the MEF component model cache folder in local app data, relative to the VS local app data folder.

Gets the path to the folder into which the R# VSIX Manifest and PkgDef are installed in per-machine or per-user installation scenario. Per-machine: the path is relative to the VS installdir, which is what's written into Registry by VS, and it points to the "IDE" folder not the very VS installation root. Per-user: the path is relative to the VS LocalAppData hive-specific folder.

Define a folder Windows Shell context menu action.

False for right clicking on a folder. True for right clicking on a blank part of an open folder (folder background)

Friendly action name suitable to display to the user (e.g. "Open Folder as Project").

Optional additional command line parameter passed to the application.

Optional path to the file that contains the icon. If not specified, the application executable is used. If both and are null, the association has no icon.

Optional path to a file that contains the icon. If not specified, the application executable is used. If both and are null, the association has no icon.

Build .dmg file request.

.dmg file with product.

Target artifact for the Post Compile “Dmgs” stage. It produces .dmg files from the ones prepared in Post Compile “Installers, Portables and Zips” stage.

.sit file for building .dmg in later build steps on dedicated agents.

Tells the build the full path to folder with .sit files.

Causes the packages be extracted into the Product Binaries Dir. On the binary stage, extracts all of the input packages (product packages and their dependencies, usually). On the source stage, extracts input packages from the previous build results (typically, nothing, unless the profile has binary subplatforms).

impl.

These many write operations allowed at the same time.

Called on the binary stage, extracts all of the input packages (product packages and their dependencies, usually). For the source stage, is the counterpart. Previously, they used to be called both, this extracted inputs and that extracted references, but since inputs and references in case of B-subs intersect, this were causing conflicts.

Wire this step to the PWC, to get the contents of the BIN dir earlier. Note that this won't get the LevelDB and other stuff we're not taking as references but embedding (because they are not packages yet, just files to make our packages), see for that.

On first iteration, check if there's already a good file in that location. Do not do writes if we can skip. 1) Check file size. If bad, switch into write mode. 2) Decompress the first buffer and read bytes from disk and compare. If bad, switch into write mode using this buffer immediately. 3) Decompress the next buffer and read bytes from disk and compare. If bad, abort operation with should-retry code: we cannot start writing from the beginning because we do not have the buffer already and the decompression stream has gone past that data, should better restart the op, this time with . 4) If all buffers checked OK, do nothing (and do not advance the timestamp).

On first iteration we've found that we need to rewrite, but too late to start writing right there. Start a new writing, no checks.

Don't call again for this op.

Call again for this op with .

Defines a file type Windows Shell association.

Private is a file type introduced by our application (e.g. dotPeek's ".dpl" or dotMemory's ".dmw"). All the file type data could be deleted when the application is uninstalled. Non-private is a common file type (e.g. ".dll" or ".sln").

File extension (e.g. ".txt"). Must start with the dot ("."). "*" means all the file types in the system.

Optional friendly type name suitable to display to the user (e.g. "dotPeek Assembly List"). Could be a plain string or resource reference in form "@%SystemRoot%\shell32.dll,-154" (preceded by the @ symbol).

Optional friendly action name suitable to display to the user (e.g. "Open with JetBrains dotPeek").

Optional path to the file that contains the icon. If not specified, the application executable is used. If both and are null, the association has no icon.

Optional icon index inside the icon file defined by .

Provides with an ability to extract packages to custom folders under product bin dir.

The package identity.

The folder under product bin dir.

Controls how extracts packages when specified.

If is specified for a package, extract a copy to the bin dir. That's a default behavior not to fail local install of several products.

If is specified for a package, extract the package to the specified folder only. Used by the Installer, which installs products one by one.

A base interface for build helpers which add files to deployment packagings (installers, ZIPs, Rider packs, etc). Normally, deployment packagings are built from a set of Nuget packages coming from our compilatons and third-party dependencies. Visual Studio installations (and other local installs) can produce additional files into the bin dir when they are installing. This is somewhat analogous for pre-packaged shipments.

Calculates files for these deployment packagings. See helper for calling on a set of helpers.

Limiting lifetime for the operation. The list of the packages which go into the deployment packaging. Files.

Requests an App.Config file be picked for a project and packed for deploy and installed.

Given a build script class from the project whose app config is to be installed, requests installation of the app config if that project is in sources, or skips if the build script is running from binaries and should not yield any installation requests.

The executable of the installer bootstrapper, a single-exe responsible for downloading and executing installer form gallery.

The executable of the installer bootstrapper for Visual Studio Marketplace, a single-exe responsible for downloading and executing installer form gallery.

The executable of the installer, a single-exe pack with all the installer DLLs, but without any embedded Nugets.

The executable of the web installer, a single-exe pack with all the installer DLLs, but without any embedded Nugets.

A special version of with embedded marketing channel ID.

The executable of the installer, a single-exe pack with all the installer DLLs, and with pre-embedded Nugets which can be used as a gallery for the installation.

The executable of the installer, a single-exe pack with all the installer DLLs, and with pre-embedded Nugets which can be used as a gallery for the installation. This installer is used to install dot-products from Toolbox.

json files containing metadata for the installer for the needs of JetBrains Toolbox discovery

Target artifact for the Post Compile “Installers, Portables and Zips” stage. It regroups deployable packages produced by compilation into installers, single-exe tools, and ZIP packages for various distributions.

Should the local installer actions be system-wide or isolated.

Full local installation mode.

When set, the local installer will only execute file installs (putting aside Registry and Shell Links), and only those targeting the product binaries dir (skipping any VS/userfolder installs).

The install should go per-user, if there's an option. For example, the HKMU Registry hive should resolve to HKCU with this flag, and to HKLM without it.

The clean (not branded with any product nor stuffed with content, just as built) launcher executables. This is the base artifact for compile-time and post-compile-time artifacts, choose the specific one depending on where you are running.

Identifies the sources and tools from which a launcher is produced. Does NOT include the configuration, the whole launchers set has the same compilation ID. The launchers of the same config and with the same compilation identity are supposed to be equivalent (not necessarily byte equal because cpp compiler might not be deterministic, and sign server signing is definitely not).

Makes a string suitable for supplying as a value for an RT_RCDATA resource within an .rc resource file, inside the curlies (curlies not included).

The clean (not branded with any product nor stuffed with content, just as built) launcher executables. This is the artifact to be used at compile-time stages, where it either compiles from sources (if Core Shell is available in src), or is taken from the Core Shell binaries if it's been compiled before.

Takes and makes them into a package suitable for caching (as used by ).

Manages the Clean Launcher artifacts lifecycle. If we have the Core in sources, compiles Clean Launcher and makes it embedded into the Platform Core Shell package. If we have the Core in binaries, loads the Clean Launcher from the embedded files. This is this build-script and common part, and there's the post-compile part also.

When we have compiled launchers from a fresh compilation or from disk, make a caching nuget out of them. When we obtain launchers from a downloaded caching nuget, then we keep it as is.

for compile-time artifact.

Takes a compiled launcher body and reads the compilation identity from it.

Returns files and bytes for representing their hash. For most files, that's just their . In special cases of generated files, might be the identity of the generation source.

Gets rel-ro-product-dir path to launcher sources.

Checks if got launchers for all supported configurations in this set.

Should fully identify the resulting compiled native launcher by its inputs' content. Should not depend on timestamps. The output would not be deterministically derivable from this, unfortunately, because it is signed (with a timestamp) and this introduces randomness.

Writes given resources as managed assembly-level attributes.

Generates the compile-time launcher hosts which are to be embedded in the package, . Os integration is run at install-time, so schedule some data for it to execute.

Default naming scheme which should produce shorter and non-techy-looking file names, preferring shorter for GUI.

Tells how to name launcher files depending on their config.

Gets the suffix to add to the launcher file name to disambig different configs on disk. Must be defined and distinct for all configs.

Which CPU architecture, and is it for windows or console subsystem.

The main executable of the launcher.

The launcher's PDB, if applicable.

The launcher's .runtimeconfig.json file and .deps.json file, if applicable.

Declarations for the launcher-specific command line args. Syntax: (Prefix='/'|'-') (Namespace='Launcher') (NamespaceSep='::') (Name) (NameValueSep=':')? (Value)?. Example: /Launcher::Mode:InvokeMethod. Here Launcher is the namespace name, Mode is the command name, and InvokeMethod is the value (missing in some commands). The namespace allows launcher to tell apart command line args directed to the launcher from the other app commands; it also decreases the chance that the app would mistake launcher commands for its own commands.

Appends a launcher command line argument switch to the command line builder, with all proper escaping.

Concatenates the command line string. Does NOT do any escaping! To build a correctly escaped command line string, use and call .

The command line key name goes after the namespace and is separated from the namespace with a double-colon. Example: in /Launcher::Mode:InvokeMethod, the name is Mode.

In the mode which invokes a managed method, specifies the path to the assembly to load; the directory of the file would be used as by default, unless overridden with . Alternatively, see . In the mode which invokes something from a native file, specifies the path to that file.

The name of this key were introduced when only managed targets were supported, and could not be renamed for compatibility reasons.

Payload code is executed in the new appdomain. Allows to enforce which to use for the new appdomain.

Allows to specify binding redirects for the code that will be executed in the new appdomain. e.g. System.Runtime.CompilerServices.Unsafe, Version=6.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a[;*]

In the mode which invokes a managed method, specifies the name of an assembly to load (by simple or full name). Alternatively, see .

For , specifies the full name of the class which has that method.

Forces running on CLR2 even if CLR4 is available on this machine.

For , specifies the local name of the method to call.

The operating mode for the Launcher. See for command values.

Allows running on v4 Client Profile without requiring presence of the Full Profile. N/a for modern frameworks.

Requires the given .NET Framework version, or higher, to run. Shows an error if only an older netfx version is available.

Skips reading the command line arguments which have been stuffed into the Launcher. Otherwise they're applied automatically as if given on the command line.

Suppresses Launcher's interactive features, such as error or question message boxes, splash screens, and waiting for any key when payload is done.

Prevents from showing the splash screen on start.

The invocation target for the mode. See for command values. If omitted, assumes .

Unless running non-interactively, waits for any key to be pressed in the console after running the payload app. A non-console launcher ignores this parameter.

A manual override for of the started application to a custom folder. If you specify an to run, then it must be resolvable under that base dir. If product content pack has been expanded, normally its expansion dir would be the base directory, but this value overrides it. The app might not run correctly in this case. If you specify an ro run, by default its directory is used as the appdomain base directory, but this value would override the directory. The app might still run correctly if it arranges for loading its DLLs from proper paths.

Allows to override the perceived Target Framework of the running app, which is checked by certain system classes to modify behavior at runtime. Supposedly, if the app does not specify a recent enough target framework, it is not aware of the new behaviors and legacy behavior should be used. If omitted, tries to declare awareness of the most recent .NET Framework. Note that unlike this does not prevent the app from running in either case, but only affects the declared awareness of the app.

Instructs the launcher to expand the Product Content files (in ) to a temporary folder and use it as the base dir. The resource MUST exist in this case.

Overrides the stuffed/default Product Display Name for all messages and error reporting. Normally, the Product Display Name consists of the Company Name and the Product Name, space-separated. Launcher stuffing writes them separately into the resources. However, as they're always used together in the UI, and there's a use case of calling the launcher a totally custom tool name rather than company+product form, so this key allows to override the composite string as is, even with a single word.

Tries to prevent DLL preloading attacks (see https://docs.microsoft.com/en-us/windows/desktop/Dlls/dynamic-link-library-security). Turns on self protection against DLL injection attacks, unless the is specified.

If is specified, turn off self protection against DLL injection attacks. To be used as a workaround in case self protection produces false positives on user's PC.

If is specified, forces security log creation, and gives an ability to specify the log file name. By default security log is created only if a vulnerability is detected. By default the log is created in the TEMP folder and has the name "JetSecurityLog.timestamp.executable.txt" (e.g. JetSecurityLog.2019-05-10T18-50-24.JetLauncher32.exe.txt).

Switch GC to server mode.

The command line key starts with a namespace, after the prefix and before the namespace-to-name separator. Example: in /Launcher::Mode:InvokeMethod, the namespace is Launcher.

Launcher only reads keys in this namespace. The others are ignored and expected to be treated by the payload app itself. On the other hand, the presence of the namespace makes it unlikely that the app reads the key as its own.

Possible prefix chars.

Separators.

The command line argument value goes after the name and is separated from the name with a colon. Not every command has a value, some only have the namespace and the name. Example: in /Launcher::Mode:InvokeMethod, the value is InvokeMethod.

Keeps the launcher command line arguments which would be then stuffed into the launcher as pre-coded command line args.

Namespace is always assumed to be . Name is the map key. Value is the map value, or NULL/empty for a valueless key.

Makes a non-frozen copy of another object.

Gets a readonly view on all the added args. Namespace is always assumed to be . Name is the map key. Value is the map value, or NULL/empty for a valueless key.

Makes it a command line suitable for passing to the launcher executable directly.

Makes it a native resource suitable for stuffing.

Configuration of the launcher artifact (which bitness, and is it console).

The windows/console subsystem.

Utilities for stuffing launchers into host entry points.

When running an app installed from the standard package, locates the Launcher executable which is expected to be shipped with that package.

Checks if the entry point executable has the resource which is expected to be present for the to read its contents, without throwing if it's missing.

Checks if the entry point executable has the resource which holds the packed product content for single-exe distribution.

Gets the resource which holds the packed product content for single-exe distribution from the entry point executable.

Takes a clean launcher plus all parameters, makes a launcher stuffed with all those things.

Limiting lifetime. The non-stuffed clean launcher, take from an artifact. Defines the file body and the configuration (OS/CPU). Resources to embed. Native resources for a native launcher; for MSIL, natives are only stuffed if supported on the current OS, and corresponding managed resources are always added to be actually used at runtime. Product name and version. Get written as custom resource strings plus into native version info of the file. Product name also makes base executable name, unless , augmented with to ensure it does not conflict for launchers from multiple configurations emitted for the same product. If the current requires authenticode signing of all files, give the signing service. Take from artifacts. Take from artifacts. For xplat rendering operations. For downloading packages. Take from artifacts. Your logging target. Optional. If given, defines the exact file name (without ext) for the future stuffed launcher executable ( MUST be NULL in this case). If omitted, name is derived from the name against the . Optional. If given, and is omitted, defines how name is turned into the file name for multiple configurations without a conflict. If given, and is given, asserts. If omitted, the default is used when needed. Optional. If given, defines the relative path to app binary that will be embedded to apphost template. Optional. If given, embeds in the signature as entitlement data.

Calculates the launcher identity based on what we have before stuffing and what will be stuffed into it, so that they could eg allocate independent cache folders.

Write product branding into resources so that Launcher could use it with LoadString()

Adds the boilerplate splash to the launcher, unless there's a custom one already. To have the boilerplate splash: do nothing. To have a custom splash image: supply a native resource with the splash. To have NO splash screen: supply an empty native resource for the splash.

Icon groups make no sense in managed resources (in native resources, they change the appearance of the file or associated documents); other than that, we want all resources in managed form also. Native won't need them, but let's have for uniformity (save for a few large resources, avoid duplication). MSIL launchers, when run on cheaper systems, are only able to read managed resources.

Describes a file which will be packed as product content, and what should be done to that file when product content is expanded.

Gets the file name as it should be written into the product content package, to encode what should be done to it upon extraction.

The file from the container should be saved to disk as a file (even if it's a container on itself).

The file in the container is a Nuget package, and it should be expanded to disk following our general Nuget extraction rules rather than just saved as a file.

The file should not be expanded onto disk. Instead, it's intended for reading into Gallery right from the packed form in the resources.

MUST be in sync with main solution!

Splash bitmap, in PNG format.

A byte value of from which this instance were compiled, written to the instance's resources.

A unique identity of this launcher stuffing (should be deterministic for stuffing). Allows product content expansion code to choose a unique but repeatable folder. Should be a strong hash.

The product content resource with packed files to be expanded to a temp dir on startup. See .

The 4-semantic version of the product, i.e. the plus any possible prerelease or build suffices. An unparsed string.

Icon of the EXE file.

Looks up resource values in stuffed launcher files. Synced manually between the Launcher and the main solution.

We can read resources either from the classical native stuffing or from the managed-only stuffing which is a tail-appended ZIP archive. TODO: consider reading from managed resources if stuffing can plant them effectively, that's more structural than tail-appending a ZIP.

Reads resources from native resources of the entry module of the process (e.g. native launcher).

Reads resources from the given ZIP file.

Wraps operations with for compile-time and pwc-time tasks. Goals: • Better code reuse. • Avoid importing lots of supporting helpers and artifacts. • for filling up.

Rel path to app icon file, same as , but the path would be resolved under the given sub automatically, and only if the sub is present in sources. Only for calling subplatform-related methods.

Only for calling subplatform-related methods.

Base impl.

Renders the default boilerplate splash for the given product info.

Default. Windows only! Parent process does not wait for it to exit.

Name must match the CPP project file constant value.

Console parent process waits for it to exit, and its console is reused.

Name must match the CPP project file constant value.

The clean (not branded with any product nor stuffed with content, just as built) launcher native executables for .NET Core.

Requests a portable Single Exe distribution for a product.

Configuration of the launcher used for stuffing (bitness+subsystem). The stuffed EXE is in .

The which has been used for stuffing the installer. In case has no more than two version components, stuffer completes the version with . shows the product name and version as you supplied it to the stuffer, and this field shows the value which were actually used.

The product from which were under the which instructed this stuffed launcher to be made. NOTE that if it's a 2-component version then stuffer has completed it with the current when stuffing, so the actual launcher will have a different version, .

Which launchers (from the Clean Launchers total set) should be stuffed for a request for standalone launchers.

Windows NT native launchers, for x86 and x64. This is the classic option.

Pure MSIL launcher, works on every platform.

Suppress 32-bit native launchers. Will produce 64-bit launchers only, if any.

Requests that a standalone host be installed. The entry point executable is created on the Local Install stage. It does not appear in the product packages and is only generated on the target deployment machine. Thus, it can hold the full host components with any localinstalltime-serialized info.

Describes the standalone launcher, common properties.

Which launchers (from the Clean Launchers total set) should be stuffed for a request for standalone launchers. The default is to use — the original set of two WinNT native launchers.

The desired base name of the executable file which will be generated for this standalone host. In case it is not set (is null ) use of instead.

Requests that a standalone host be embedded into a product package. The entry point executable is created on the Compile stage. It is explicitly included with the product packages and is just extracted on the target deployment machine. It thus cannot have host components which have any install-specific serialized info or know the full set of installed application packages. Such launchers have to collect available packages on startup by reading the package metadata files.

Specific to in-package hosts. The subplatform whose package is to deploy it.

A subset of the properties which governs launcher's integration with the OS. For in-package hosts, this has to be carried out to the binary stage (which is executed upon installation) to be carried out.

Gives out the location of the stuffed launcher file, relatively to its originating package.

The ready launcher executables, branded with the product and stuffed with the serialized host components.

Alt naming scheme with technical names for entries, looks more techy and verbose, but better for service executables. Prefers shorter names for console executables.

Alt naming scheme with technical names for entries, looks more techy and verbose, but better for service executables. Prefers shorter names for GUI executables.

Augments another naming scheme.

Denotes core parts of the Local Install process. Forces all installation steps required for Local Install to be executed, but does not commit the results. This art is requested when we're doing Install from the Installer or Local Install from the Build Application.

Denotes parts that should be evaluated on "Local Install" command of the Build Application (aka ArtOfBuild). These steps are executed after steps to commit the installation.

Chooses the root suffix to be used when local-installing the host, both VS and standalone hosts.

Denotes parts that should be evaluated on "Local Install" command of the Build Application (aka ArtOfBuild).

Create packed and web installers and copy them to the Bin\Installers folder.

Isolation options for local install.

Causes the packages be saved into the Product Binaries Dir.

impl.

Causes the packages be saved into the Product Binaries Dir.

First stage build produces this artifact. Then we store it in package metadata and transfer to the second stage.

Do not uninstall the msi when all products (that use it) are uninstalled.

Local machine executables to run on register and unregister.

Optional filter for subplatforms whose packages (with all their recursive deps) will be saved. Take all if NULL.

Optional override of the output dir. Writes to a subdir of the bindir if NULL.

Sbom for publish on the web site.

json files containing metadata for the installer for the needs of JetBrains Toolbox discovery and R# Check for updates.

Local name of the per-profile folder under the common intermediate dir.

Per-profile intermediate dir, rel to the home dir. Includes the common intermediate dir and the per-profile folder under it.

Either host or sub-product information

Helps with writing standard local two-stage builds, where the first stage just collects the packages (optionally, compiles), and the second stage does smth with those packages, like local install. The first stage is all set, and the second stage differs only by the requested package, which is the only parameter here.

If the objective is serializable, and one or more of them are produced during the second stage, returns these instances.

The output file artifacts produced during the build.

If the objective is serializable, and one or more of them are produced during the second stage, returns these instances.

The output file artifacts produced during the build.

The build version. Always four parts, e.g. "2044.2.11.32801" for "2044.2.11 RC 33".

Release to manufacturing

Release candidate

Early access program

Experimental, no updates

Internal development

The marketing flavor.

The marketing number. Should be positive for all flavors. Should be null for flavor.

The parsed the marketing suffix.

The marketing version. Two parts for main releases, e.g. "2025.1". Three parts for bugfix releases, e.g. "2025.1.2". Four parts for hotfix releases, e.g. "2025.1.2.3".

Collect items from the given projects and run LiveTemplateCompiler from the nuget package.

After previous PWC/Extract/Install, there might be more assemblies in the Bin Dir than expected by the current profile. Normally, only assemlbies mentioned in the JetMetadata files are considered, any extras would be ignored. There are two exceptions: 1) Excessive metadata. If there's JetMetadata (or lightweight JetMetadata) from previous runs, then extra DLLs will be considered for use. JetMetadata has to be cleaned down to the actual set. 2) Ambiguous assemblies. Assembly is loaded by looking for a file which has the same name-without-extension as the assembly simple name, and a supported extension. If there's a DLL and an EXE at the same time, they'd conflict. One of them has to be cleaned up.

Checks the Bin Dir for potential problems — leftovers from prior PWC or MSBuild builds or Extract to Bin Dir (incl Local Install). For assembly conflicts, might erase useful files too in case of a conflict, so this should be called BEFORE any relevant writes. This includes: * Full Jet Metadata: ** On a source stage (hence, PWC), any full metadata is considered problematic (except for B-subplatforms of course). It might list stuff from a very very old extract to bin dir, while PWC tries to make fresh light-metadata. Full metadata takes precedence when loading, so it should be deleted. So filter down to available binary subs. ** On a bin stage (extract), shan't have metadata except for the actually available subplatforms-on-packages. So again filter down to available binary subs. * Lightweight Jet Metadata: ** On a source stage (hence, PWC), shan't have light-metadata from subplatforms which we do not have in sources at the moment. So filter down to available source subs. ** On a bin stage (extract), we're getting real metadata, so any light metadata is not needed. So again filter down to available source subs. * Assembly files: ** Assemblies are loaded by looking up files by the assembly simple name, plus known assembly extensions, case-insensitively. This makes it possible to match more than one file when loading (eg you change project target between DLL and EXE and you get both, all good for loading). We have to delete the extra one. Also ensure case matches.

When there's no preference for any specific VS, take the latest one. Or a fake invalid value, if none.

WAS part of the chain: … … . WAS: previously, all packages would be retrieved centrally and local-restored centrally, on PWC and before build. Now, build or design-time do not require that (SDK projects handle these tasks by their own), and other occasional clients retrieve only packages they need, and local-restore to their specific locations.

Relative to the Product Home Dir.

Config for our custom Mono and .NET runtime.

Full path to against this home dir. Works on any OS because this is a file in scripts.

Get files required to run including itself.

Works only on envs where Mono is applicable. Returns this executable which you must run and pass the .NET executable as the first param, then its args.

Nuget package layouts, locations, constants, etc.

— Nuget package layouts, locations, constants, etc for application shell aware needs. — very generic Nuget helpers in the Util, not aware of Build nor Application Shell packages layout. — Nuget services for working with the Application Shell packages. — Application Shell packages logic.

When referencing another subplatform, makes a version spec with constraints following the convention.

The standard Nuget Lib folder name.

.NET framework default folder name.

Folder in which Nuget looks for Targets and Props files to include in projects it's referenced in.

Folder in which Nuget looks for tools.

Gets relative path from the home dir to the standard local packages repository folder under the product home dir.

The path in a platform package under which all of the platform package files from are written.

Defines the value for of the Nuget packages created for subplatforms. This value means that only Nuget clients or servers of at least this version will be able to handle our packages. Advance this version when we use breaking features from new Nuget. The current heuristic is to fix for the major version of the Nuget (supposing we are good with any minor version). So far so good for 2.x. If you ever change this to manual, make sure there's a check we do not go to a new major version without moving this value.

Major build tasks producing our Nuget packages.

Supply as deployable those refs which are not development-only dependencies.

Refs in the regular managed references sense. Either on a project or subplatform-level or wherever else it's coming from.

Does the Local Restore of Nuget packages — having an artifact with the package body, ensures its contents ends up extracted under the $(HomeDir)/Packages folder. As opposed to the standard Nuget procedure: • Ensures the folder contains no more packages than the retrieved list, to prevent projects from using non-whitelisted pkgs by accident. Operates on the Backlog folder to quickly retrieve such packages whenif we switch context. • Ensures the expanded content still matches the original packages (the file set and their content, by timestamp of the last time we wrote them). • Fixes exceptions in Nuget which probably resulted from some race (NP-1199). • Operates on the already-retrieved package body, as an artifact object. • Uses a slightly optimized procedure for accessing the artifact body (not so important).

Filled in the process of trying to get the package from inputs or from source. At the end, all must be filled.

When a file is being extracted from a Nuget package, gives the file body (with effective path) and tracks the original package. Supports synthetic files like package metadata which we generate on the fly.

Allows peeking into content length without starting to render the file body.

Equal to . when you lazy-create the file body. Originally comes from the Nuget entry effective path (or synthetic rel path), but might be remapped with .

Lazy for a nuget package origin; eager when synthetic.

Sometimes fake JetMetadata is emitted, would have this False and would have no part path.

Gets the real original path of the package part of this file in the package, in case it's a real file from the package (), otherwise, throws.

Gets the streaming access to the body, without a random-access caching wrapper and no permanent allocations.

If this file is a managed assembly, wraps its into an .

Changes the effective path of the extracted file (does not affect the part path, if any).

Represents a central NTSF folder into which all packages are actually expanded upon local-restore and then linked into individual Packages folders with directory junctions as needed. The actual folder path might be NULL, which means that the central folder is not available (e.g. due to the lack of filesystem support for junctions), and local package folders must be used normally in such a case.

If the localappdata volume supports junctions. Always returns a non-NULL instance, but it might have a NULL path.

When extracting multiple nuget packages into the same flat dir, lists candidates for writing into the same effective path.

The file which would be chosen for the output. All candidates for extracting into the same effective path. If they all have the same content, won't be a conflict, see . Out of , only unique file bodies. If just one, no conflict will happen. Whether we consider this conflict worth reporting. Sometimes it's over files we do not care about.

When extracting multiple nuget packages into the same flat dir, lists candidates for writing into the same effective path.

The file which would be chosen for the output.

All candidates for extracting into the same effective path. If they all have the same content, won't be a conflict, see .

Out of , only unique file bodies. If just one, no conflict will happen.

Whether we consider this conflict worth reporting. Sometimes it's over files we do not care about.

When merging files from several packages, the relative path which several files are targeting.

Whether there is any conflict at all.

When we want to keep all original files from conflict, make them unique paths. The option of making them unique local names and keeping in the same folder was considered but dropped, since some files only work by their exact local name. So for the root folder, we reuse the Packages dir name, just like when extracting package variants (and possibly future multi-bin-dir layout?..), for now reusing the constant from nuget, this would at least make the usage searchable. Then it's the package full identity (modern way, two-level, kind of slash-separated). Then the part path of the file (in case it's a conflict within the same package, which is possible).

If files with these extensions conflict upon extraction, then it's not a problem, do not report an error.

If files with these local names conflict upon extraction, then it's not a problem, do not report an error.

Nuget package helpers which are specific to the build semantic, but do not contain the packaging logic.

Extracts files from several packages using twice for CLR and NetCore, merges and processes conflicts.

Custom handling of file conflicts. Logs an onerror by default.

Extracts files from several packages using twice for CLR and NetCore, merges and processes conflicts.

Custom handling of file conflicts. Logs an onerror by default.

Extracts files from packages as would be done for shipment in a ZIP for use in tools. First, enriches the set of nugets: * Adds symbol (PDB) packages (for checked builds). * Adds native DLL packages for specific platform. Then, extracts files from several packages using twice for CLR and NetCore, merges and processes conflicts. Then, adds extra per-deployment files.

The regular managed packages which you've selected for shipping, probably based on your Product ID's head package and its transitive dependencies. The full set of packages. We'll be fishing for symbol and native packages related to in this set. Picks the runtime (CLR/CoreCLR, OS, CPU, etc) for which the natives should be looked up. Helps decide whether to take in symbols (PDBs) or not. These guys know what to add to package files to make the set complete (e.g. third-party licenses).

Gets the packages by ID, plus all their references for specified s, transitively. A missing reference is an error.

For a set of packages with binaries, tries to look up corresponding packages with symbols in the total packages set. Skips out packages with native symbols, as denoted by the , as they're large and generally should not be shipped to the user. Extends .

Subset of binaries packages. The total set of packages to consider. The set of found symbol packages.

Subset of binaries packages. Only The total set of packages to consider. The set of found symbol packages.

Calls on each package in turn. Optimizes creating the resolver in the loop.

Reports if a certain package could not be queried for metadata. If omitted, issues a logger-verbose message.

Calls on each package in turn. Optimizes creating the resolver in the loop.

Reports if a certain package could not be queried for metadata. If omitted, issues a logger-verbose message.

If a package is wave'd but lacks an explicit metadata stream, tries to think up the fake metadata values resolver which would allow this package to run.

Gets those file items which are under our content folder, by their effective path which is relative to that folder. If such folder is missing (e.g. in third-party packages), reverts to collecting files. If the package is detected as a product package (), and has no explicit jet package metadata file in it, such file is generated as with function.

Gets the serialized value resolver from the jet metadata stream in the package (see for its extension), if one is present. For any package which references the Wave package, in case such stream is missing, it's optionally generated on-the-fly upon the available package data (see ).

Optional type binder for the resolver. Binds to loaded assemblies if not specified. When doing for multiple packages in a row, better do this in parallel, e.g. with .

Gets JetBrains-custom metadata attached to the Nuget package. This extends the standard Nuget package metadata and should be available by viewing just the Nuget Package metadata without downloading the whole package body; originally, this were available by just querying the package gallery. Currently, embedded as text into the Release Notes field of the standard Nuget metadata. If missing, returns an empty metadata object. On errors, log but does not throw.

Gets whether the package has JetMetadata stream inside.

Whether this package is referencing our root Wave package (of either version).

If Product Home Dir is known, tells how to find the Nuget Settings File under it. The idea is that if we're not given as an object or text, and we're not given , but are given the , then this build step will be called, and will infer it.

If homedir is known, and if it has the config file, gives it out as the default.

Gets whether this package is our subplatform-based package, and getting jet-metadata should yield smth, real or fake. Detected by reference to the Wave package currently.

Handler. Called if we were able to open metadata, and its return value is passed thru to the output. Make sure the value you produced is not lifetimed by the resolver. If metadata can't be opened, the handler is not called, and NULL is returned from the method. Optional type binder for the resolver. Binds to loaded assemblies if not specified. When doing for multiple packages in a row, better do this in parallel, e.g. with .

How to fetch metadata from packages.

Classic: only read metadata explicit in the stream under the known path.

Advanced, for extensions which are waved packages but might not have the explicitly-compiled-in jet-metadata stream: if the package references a Wave package, try generating relevant metadata on-the-fly.

Call this in real-life obfuscator calls so that to dump the inputs to be given to obfuscator in a repro.

Unless is explicitly specified, gives the default prerelease metadata part of the semantic version which is to be used on the packages we produce during the build. On the build server, there's a setting for this value to either a prerelease suffix (eap, beta, rc) or release (an empty string). Locally, it should designate a custom build.

This applies to builds which have not been compiled on the build server (and thus received any specific, possibly empty for release, metadata). For example, local compilations and locally installed products.

A reference to a Nuget package mentioned somewhere in the subplatform. If not dev-only, causes the resulting subplatform package to reference its target package, and have it deployed with installers, portables, and zips. WAS: previously, all packages would be retrieved centrally and local-restored centrally, on PWC and before build. Now, build or design-time do not require that (SDK projects handle these tasks by their own), and other occasional clients retrieve only packages they need, and local-restore to their specific locations. For help with that, use the helper. Basically, it serves all package reference needs, even has the full list.

Gets the Package Identity from .

The package reference record, as read from the packages.config file or else.

Additional flags. These do not apply to the package reference itself (as they should go into in such case) but to the origin of the reference (in addition to the original subplatform/project).

If the package has been requested by some specific project in the subplatform (and not the subplatform as a whole), points to rel path to the project file in the subplatform. Otherwise, NULL.

The subplatform which requested this package. If the package is not a dev-only reference, the output package of the subplatform would also list this package as a reference.

Additional flags. These do not apply to the package reference itself (as they should go into in such case) but to the origin of the reference (in addition to the original subplatform/project).

The package reference is coming from the static project description on disk (eg has not been injected by code in the build script or else).

New SDK-style project have package references embedded in the project file body rather than in a separate packages.config file, in <PackageReference/> elements.

Handles the package references from source-based subplatforms and all operations with them. Those are objects (exposed as here). Allows to retrieve those of the packages you need as package bodies (NOTE: this is not a free lunch, so avoid unless very necessary, and consider distro-caching the info you are getting from them). Allows to local-restore the packages to a physical disk location (NOTE: this is needed even more rarely, package exploration is done on package bodies). Previously, there was centralized downloading and restoration of all the packages, but now this isn't globally needed.

Finds matching references among all references known to the solution, and returns them in a stable order.

Looks up the specific package ID by its name part in the Central Packages Lock file, if the version is not known.

Limiting lifetime for the operation. The name part of the package identity of the package you need to retrieve. A noun-like title case or lowercase topic for this operation (e.g. "NUnit Runner", "CDB Self-Debugger"). Optional. The version part of the package identity of the package you need to retrieve, if known by caller. If not, will be looked up in the Package Central Locks (). If a manual version is given, and there is a record for this package in the central locks, will assert that it matches.

A noun-like title case or lowercase topic for this operation (e.g. "NUnit Runner", "CDB Self-Debugger"). The package we are looking for.

Gets the package body by the package ID (might need to download, if not in the cache, otherwise instantly). Throws if failed. Validates that the package version you request does not disagree with the central package locks.

A noun-like title case or lowercase topic for this operation (e.g. "NUnit Runner", "CDB Self-Debugger"). Gets the package body by the package ID (might need to download, if not in the cache, otherwise instantly). Allows to control what happens on failure with . Validates that the package version you request does not disagree with the central package locks. A noun-like title case or lowercase topic for this operation (e.g. "NUnit Runner", "CDB Self-Debugger").

A non-breaking assert that if central locks has an opinion (ok if not), they match with what caller asks for.

Might not exist. The API returns all possible file locations without checking for their existence. Rel to project dir. If no project, rel to sub dir. If no sub, rel to home dir.

If belongs to a project, path to its project file (not dir!).

If under a subplatform, name of the referencing subplatform.

Now we support original Nuget packages.config files, and also giving package references in projects.

The original packages.config file of Nuget.

Package references embedded into the project files as task items.

file, when treated together with package references (e.g. for normalizing versions).

Whether this should be treated as dev-only.

Whether this reference should be embedded rather than linked.

Package ID, its version part might be either written locally or coming from the version locks, see . The ID we currently expect to know locally.

Whether this reference should be used only on these runtimes.

The value (version, dev-only, etc) has been written locally on the entry.

The value (version, dev-only, etc) is omitted on the entry, and has been inherited from an upper level (for example, for a package reference on a project it inherits from the package locks file).

The value isn't given anywhere but it's the assumed default.

Name of the standalone product host. Must be not null for standalone products, and null for VS integrated products.

Denotes an optional part of another product. The name must match of the main product package. For VS integrated products, must be also specified.

For VS integrated products. A list of supported VS versions (see ).

Was never used. The semantic is unclear; nobody remembers what it means. Do not use, if you're not its author.

Denotes a package that contains a collection of files to be extracted into product binaries folder. The name must match of the main product package.

Denotes a package that consists of runtime-specific files to be extracted for these runtimes only (non-NULL), otherwise NULL for everywhere. Should only be used with . Use to get the parsed array of the runtime identifiers.

A collection of flags used by the installer to present the product and show install options to the user.

Gets an array of runtime identifiers from .

Specifies which zones should be activated, minimally, for this package to run. Because the components in the package do not necessarily have a common minimal set, might have multple sets. The outer array is a list of sets, each inner array is a set of module zones which should be active. If the outer array has one empty inner array, then the package has components eligible for zoning but with no requirements of them (an empty zone marker).

Lists which module zones are declared in this package, with their hierarchy.

Out of the package assemblies, take the zoning information and publishes it in the package metadata, as package components of type .

We found a new minimal zone requirements set for the package, register it.

A collection of flags used by the installer to present the product and show install options to the user.

Don't show the product on 32-bit OS.

The product supports plugins. The installer asks to keep plugins from the previous installation.

An ability to run NGen.exe after product's installation.

An ability to install ETW Host service after product's installation.

Product has file type associations (Windows Shell integration).

Product has directory context menu actions (Windows Shell integration).

If the product is not installed, the default installer action should be Skip instead of Install.

Represents a loaded file with the Nuget packages centralized versions lock storage. Allows to skip giving package versions on every reference, stating them all in the central place instead.

Keys in the package version lock storage, by package ID in the simple case (until there are groups).

Values in the package lock storage.

True: only allowed as dev. False: not allowed as dev. NULL: not restricted.

True: only allowed as embed. False: not allowed as embed. NULL: not restricted.

non-NULL: only required on these runtimes. NULL: everywhere.

Looks up the full identity (ID + version) for a package in the version locks file.

Looks up the full identity (ID + version) for a package in the version locks file, plus whether it is a development dependency.

Looks up the full identity (ID + version) for a package in the version locks file, plus its dev-only flag, and makes a package reference out of it.

Generates project.assets.json files so that full-SDK (e.g. from git-subplatform) projects can be compiled without calling the full nuget restore. Generation is embedded as a build target within build itself because the file has to be placed in the Obj dir of the project, which in case of an isolated build is a temporary location and won't be visible from any pre-build writeouts.

If you want to have custom defines in your project and have them left alone by Autofix, publish their names here.

The define constant symbol which is allowed to be set in projects.

Only effective in this subplatform.

Warn if live (because will be fixed), err if non-live because would fail the build.

Allows to extend Autofix with specific stages.

Runs your stage for this single project. Modify the project XML if you want to change it or report as invalid. Only write files to disk if optional artifact is set. The project XML won't be saved in non-live mode. Don't forget to report errors in non-live mode or if you could not fix them. It's nice to report warnings for fixable errors if you're running live.

Must be set to True if something were modified (or attempted to be modified), besides the , because it's okay to modify the project XML object without setting this flag, that would be detected by caller automatically.

On the autofix entry point, enables the LIVE mode and spawns all of the compile-time validators procedures.

A file in the product home dir with a list of projects (by project file local name, plain text, one per line) to manually force migrating a certain project to SDK Mini no matter what its conditions.

Lists projects to be converted to SDK Mini by Autofix.

Some simple stats are rendered on PWC (like, how many already in SDK). Here we give more details and reasons for why projects are not in SDK yet. Those reasons require detailed exploration, so they're too slow to run on PWC.

A set of hardcoded strings why this project cannot be SDK yet, should be a limited set for grouping by problem.

Optional comment to , might vary with specific info for that project.

Gets the "sub-extension" for the generated files which are ignored from our source control. Subextension means that it's like a second extension which precedes the real extension, e.g. Stuff.Generated.xml. The ignore pattern is like *.Generated.*.

We have defines which come from the stuffing, and if you open the VS properties editor and change defines there by hand, they get also written to the project file, and might contradict to what we want to see at runtime. Let's sanitize them.

This is especially important if we allow substituting project references with DLL references If our own project has been added as a DLL reference instead, replace it with the correct project reference

Turns [element][/element] into [element/], so that they weren't overwritten by VS project saver (which prefers another formatting style on them).

Enforces the single project configuration named “Default” instead of the “Debug”/“Release” pair.

Cleans up Nugets's attempts of adding a folder with an empty name under solution and placing some stuff there. We don't have the common sourcecontrolled solution root, so this ain't gonna work. Some props are removed with other props, and we'd remove bad imports and error blocks for them.

Many .targets files are imported conditionally on whether the file exists. We would like to have reliable effects on build — to see errors

After subplatform stopped looking for project files with full recursion, this here thing ensures there're no missed projects.

Ensures that the project Compile item group is wildcard-friendly, i.e. can potentially list its source files with the “*.cs” mask. Checks that all files under the project are included in the project.

Enforces that task items of the specific types, such as .cs, are only included by wildcard if they're under the project directory.

A veeery custom and by-task script which mass-adds dll references by certain criteria. Off by default.

Just some visual improvements, like cleaning up commented-out stuff from old old times.

To ensure concurrent changes from multiple branches are merged smoothly in the file written by many, ensure that: • There is strict ordering for items. • There are empty lines between items so that independent changes in adjacent items merged without conflicts.

In SDK projects, we want regular package references to have their versions listed in the common Locks file rather than locally.

Index all known project files by their rel path from home dir. NOTE that not all projects are available in sources, some might be binary.

Checks if certain can use stuff from . Schedule an autofix if not.

There is a path between these two subs which does not have the flag.

Supports B-subs in profiles when referenced from SDK Mini projects in [S]-subs, for PWC and ABuilt-driven runs.

Deserializes the written list file. Intended for SDK Task Body.

When emitted on PWC (into Obj), here's path from root.

Support for PWC, two-stage builds, etc.

Guys like two-stage-build load for use precompiled packages saved by PWC (when in incremental mode).

PWC pre-compiles them and saves for two-stage build to use.

Info about embedded git subs project references placed in a bi subplatform. We need it to be able to substitute project references with assembly references.

Implements serialization to support [B]-profiles for local operations. Used on the outermost stage of a build which has a sources stage (PWC, source validation, two-stage build with binary stage, etc). Produced on PWC, stored under bindir, then loaded by subsequent builds to supply input packages for the source stage. See docs in .

PWC is supposed to write packages for B-subs. We can only run correctly if there're enough packages for B subs there.

Legacy code: filter down by AllAssemblies. Now as this isn't used on TC, we're supposed to be getting only useful assemblies from the shadow dir, as PWC does the filtering and writes them down useful. So this filtering should not be used.

Allows the build to read some of the precalulated nupkgs.

Collects info about project reference substitution, so that PWC/build could then emit necessary info and write isolated assemblies.

Analyzes projects in [S]-subs and tells which projects in [B]-subs they reference, so that info could be emitted to substitute project references in their projects with assembly references to assemblies from [B]-subs' packages.

What kinds of projects have project references that substitute like described in this info.

Helps with compiling pre-SDK projects which reference a subplatform missing in sources (but present in binaries).

Called during compilation (before ABuild calls its driven MSBuild), in non-incremental/isolated mode, knows the compilation lifetime. Deploys the binary reference files to be used as replacements for project references into subs which we have as binary subs instead of source subs into an isolated workdir.

Lifetime of the compilation, for which duration the files exist on disk.

Called during compilation (before ABuild calls its driven MSBuild), in incremental mode, knows the compilation lifetime. Ensures that binary reference files (to be used as replacements for project references into subs which we have as binary subs instead of source subs) are present in the bin dir. Locally, they get extracted on PWC, but compilation must be self-contained.

Lifetime of the compilation, for which duration the files exist on disk.

When doing staging compile on the server, we already have part of the codebase in the binary form, and have no sources on disk. To compile projects which reference it, we need to substitute such project references with references to already-compiled binaries. This also applies to [B]-profiles locally, [S]-projects referencing projects which got into the [B]-part need to get DLLs rather than the source projects. This code runs classic projects. SDK Mini obviously does the replacement on-board.

Lists subplatforms with binary refs which have actually been used for substitutions. Allows to limit down the number of deployed subplatforms.

These tasks support binary subplatforms in profile on source stage. That is, when compiling some of the subplatforms from sources, and some of their referenced subplatforms are in packages already. When this happens: • On TeamCity, when building a non-first part of the solution. • Locally, when we have [B] subs in the profile. Problems to solve: • Regular csproj files reference other csproj files from other subplatforms, and those MUST be replaced with binary references to corresponding DLLs from nugets. The project files themselves are either missing on disk (TC with proper sparse checkout) or present but must be ignored (local story). Integartion points: * Doing PWC. * Opening projects in IDE (must ignore project references, must have binary references available). * Building with just MSBuild alone (should not recurse into substituted project references, should see their binary counterparts from nugets, should always run the “incremental” scenario). TODO * Building from within the build system task (should not recurse into substituted project references, should see their binary counterparts from nugets, incremental and isolated mode). TODO * Running TeamCity build step. TODO Implementation: * PWC (if got [B]s in profile): * First bakes an isolated profile with [S] removed, and [B] turned into [S], and builds it into nugets the usual way ( target). * Writes the result into the shadow dir (), those are packed nugets for reuse not expanded DLLs. * Then runs the regular LPWC ( target) with nugets from above as . * Its should land a copy of the extracted DLLs from B-subs into bindir, for use at runtime, by legacy projects' binary refs, and by incremental-mode MSBuild runs. NOT used by SDK Mini projects or ABuild-driven build runs in non-incremental mode. * Local two-stage builds (if got [B]s in profile): * In incremental mode, PWC is required to have been run, and must be readable with up-to-date set of nuges for [B] subs (some validation in place). * In non-incremental mode, first runs the build to make nugets for [B] subs, just like in PWC first stage, then uses them immediately. * TeamCity: * Prepare Isolated Request fetches nugets from dependencies and puts them as into the request (both for inputs and build script). * Run Isolated Request: just runs. No special treatment on this part. * Pre-SDK projects: * All driven thru Managed Targets included side-file, emitted on PWC time (or when running ABuild-driven compile). * Removing substituted project references: * Removed build-time in target (emitted by ). * IDE / Visual Studio: they're read on MSBuild Eval, so it's impossible to modify what comes from the project file on disk. VS just ignores them when missing or invalid. * IDE / Rider: runs a design-time build, so the build-time target is in effect. * Adding substitution binary references: * Added with eval-time task items group in Managed Targets, effective in all scenarios (emitted by ). * Bare MSBuild builds or incremental mode when driven from ABuild: points to a copy in the bindir. * Non-incremental builds and when driven from ABuild: points to a unique subfolder in a folder supplied by ABuild (unique per-build, in individual subfolders, only exists for the duration of the build), with helper , also uses info from . * SDK Mini projects: * Driven thru . * PWC writes it to the solution-wide file. In effect when opening in IDE or when building with bare MSBuild. TODO and document the file/format * ABuild makes an isolated copy of this when driving MSBuild for compile stage. TODO * No magic on eval-time. IDEs only open SDK projects with design-time build. So all magic is within the Task Body. * Substituted project references: * Task Body never does recursive calls in into those projects. TODO * The task items set is filtered for IDEs, does not matter for builds, MIGHT be omitted for speed. TODO * Substitution binary references: * IDE: extracted to a shadow location (like, Obj). TODO * Builds: used directly. TODO

Allows to edit tasks which are written in source code in a convenient way.

The entry point for running autofix of local projects.

Like other generated MSBuild items, allows to add custom MSBuild includes to all project files in the solution, but does not limit the text to specific MSbuild items. See base class doc for details.

Diagnostic identity of the custom section.

A valid XML document fragment to be inserted into the project file.

Creates an with an MSBuild Property Group which mounts the target named appropriately into the build process, for use as the .

Like , but adds BeforeTargets stuff to the target rather than manipulating property lists.

Allows to include pieces of an MSBuild script into each of the project files in the solution in a centralized manner. This means setting up properties with common project settings like outdir and optimization, stuffing assemblies, including tools from nuggets, etc. Each project in the solution (as part of the LocalAutofixProjectFiles procedure) gets the single import directive for the generated MSBuild file which receives all of these items. It gets written to disk either as part of the or as a dependency of the compilation stage. Yield one such item per each project to be stuffed, filter by subplatform if needed. // TODO: when each subplatform is precompile-processed separately, these items would be effectively per-sp, so won't be needed.

Optional condition.

How to place this injection in relation with the standard language imports for this project (e.g. Microsoft.CSharp.Targets). The “Before” stuff can predefine scalar property values to be used for paths in the standard imports. The “After” stuff can inject into list property values at first/last position because the standard targets have already had their say.

Specifies ordering for inserting this element within the corresponding section (). Zero is the dontcare level.

Path of the project to be stuffed, relative to the .

An explanation of the entity. Makes up for a comment in the emitted targets file.

The subplatform to which the project to be stuffed belongs.

Stuff specific to params of the derived type.

A pre-compile-time generated MSBuild Import directive. See base class doc for details.

The import target, relative to the project directory (as it will be written into the resulting generated file).

Here's no support for providing the import contents as a because if you've got the contents in your hands rather than somewhere on disk in a tool Nuget package folder, then you'd better insert it as custom content right into the generated MSBuild imported file, for simplicity.

The generated MSBuild project files to be injected into each of the solution's project files, built of all of the items. Originally, injected directly into the .*proj, as the profile name makes a part of the injected file name, the reference had to specify the profile name, for which the SolutionFileName MSBuild property were used. This had a problem of requiring the SLN file to make a build. Now a proxy MSBuild file is included by a fixed name, which in turn tries to include the file based on the current solution name, if known; or, as a fallback, the file for the most recently prepare-working-copy'ed profile, hence the .

Any items taking part in the generation which must also be realized relatively to the project folder (unless of empty content). This does not include the .

The file content of the generated imported project. Would be imported from the proxy file. To be realized on disk in the project folder.

Path of the project which is being stuffed, relative to the .

The file content of the generated proxy project. To be realized on disk in the project folder. Would be imported from the *proj file itself, and it will in turn import the main imported project file.

The subplatform to which the project to be stuffed belongs.

A pre-compile-time generated MSBuild Property. See base class doc for details.

Name of the MSBuild property.

Value for the MSBuild property.

Allows to contribute to the property which then gets passed to the Roslyn compiler as a semicolon-separated list of these custom feature parameters. This is global so far, not per-project.

Deserialization.

Serialization to string.

A pre-compile-time generated MSBuild Task Item. See base class doc for details.

This file's defines the task item's text. If the file has non-empty content, it will be realized on disk per-project (and thus effectively included as a real disk file). Otherwise it's just a task item.

Item group name for the task item.

A set of files from , including the main generated project file, realized on disk for preparing the solution or compilation.

The file content which were written.

The path to which the file were written.

Path of the project which is being stuffed, relative to the .

The subplatform to which the project to be stuffed belongs.

Realizes items on disk.

Locally write before compile. // TODO: make compile write the stuff itself, for better isolation

We do not store the main solution file in the source control, because it depends on the subset of projects you've chosen for work. This emits the solution and related stuff (solution settings, toolset for opening the solution, etc).

Name of the file as it gets shipped from SCC. A bunch of settings which tune R# to prefer a more optimal version between two alternatives (e.g. for vs LINQ).

A clone, cannot use the original one because it's not in the build script area but written into the Shell.

Name of the file as it gets shipped from SCC.

Chooses toolset based on solution caps, then downloads it together with the runtime, and yields valid local file paths.

Makes the IDE which opens the SLN choose our toolset for building with Solution Builder.

Makes the IDE run tests on .NET Core on Linux/macOS.

Gets the directory full path where the solution toolset would be installed for this solution. That's a per-profile path in under the Obj dir.

In DevKit/Config, we have a common solution settings file which should be applied to every Main Solution we generate here. To do that, we inject that exact original file as an injected settings layer into the solution settings file we write alongside the emitted solution file.

Plant a batch file into the solution root to run the chosen toolset msbuild for the main solution.

Full path to the local main solution file on disk, based on the current homedir and profile name and all.

Full path to the local main solution shared settings file on disk, based on the current homedir and profile name and all.

A contribution to the .

Ensures the toolset for building the main solution in the current profile is fetched and installed. Fetches runtimes such as Mono if needed.

msbuild.exe entry point in that toolset.

Path to the executable entry point of the runtime (e.g. Mono), in case cannot be run directly but rather via that runtime.

Identity for the toolset we've chosen for this solution.

As part of the , extracts to Bin Dir those package-wannabe items which are fast to produce, hence .

A service artifact for wiring related tasks to it.

Defines this conditional compilation symbol for all of the managed projects in the solution. C#/VBNet projects don't have values on #defines, so these only specify the name.

Emits defines (value-less) for generic managed projects, such as C#, VB.NET, F#, etc.

Generates the standard Assembly Version attribute set for including into each project file.

File version and assembly version component must not exceed the WORD size.

Emits metadata which might differ by project (depends on its sub), so it's not directly usable by the SDK build, but it should not depend on the current build envirnoment, so it can be reproduced from the sub by the SDK build. WARNING! SDK builds do this independently in the body task!

Emits metadata which is the same for all projects, but isn't constant (based on the current build artifacts), hence it can and must be supplied for use in the SDK projects.

Every "Trigger XXX" build on TeamCity defines a build chain used to build everything in .NET with specific parameters. This enum defines type or 'flavour' of a build chain.

For more see

Every "Trigger XXX" build on TeamCity defines a build chain used to build everything in .NET with specific parameters. This enum defines type or 'flavour' of a build chain.

For building a release it's required to run two chains: and since we need two versions of compiled code (in this case, with assertions and without them)

For building EAPs it provides two kinds of them: EAP_DEVELOPMENT and EAP_PRODUCTION. EAP_DEVELOPMENT is the usual EAP builds with all assertions etc. EAP_PRODUCTION - EAP installers without assertions to gauge performance before release.

Ordinal builds on TeamCity in Trigger All configuration. Minimum signed files, no signed installers. Set for builds in any branch for usual VCS trigger or merge robot.

Internal builds by request with signed files, assertions, exception reporting, timebomb etc

Every night builds with signed files, assertions, exception reporting, timebomb etc

Usual EAP builds with signed files, assertions, exception reporting, timebomb etc

SDK, checked installers etc, with assertions and exception reporting, with timebomb

Production installers, without assertions and exception reporting, with timebomb

SDK, checked installers etc, with assertions and exception reporting

Production installers, without assertions and exception reporting

Some artifacts might take much CPU to compress, make uncompressed ZIPs when doing for Snapshot for speed.

Borrowed from .

For , builds the list of compiler warnings we suppress.

The warning is suppressed everywhere.

The warning is suppressed when building in MSBuild. The warning should nevertheless be shown as a warning at design-time (in IDE). Example: Obsolete. Useless on build, must be seen in the editor.

This warning must always be an error.

Whether to tell the compiler to optimize. NOTE that define constants are emitted and passed via .

Critical for the case we're building with MSBuild passing a csproj, we do not know the profile, we read parameters from a MRU file, we learn the profile name from there. Then it affects bin/int dirs.

This is added to the assembly attributes of the project.

Path of the project to be stuffed, relative to the .

The subplatform to which the project to be stuffed belongs.

The tmp task item group name into which the file gets emitted before being mounted into Compile with deduplication.

Emits a file with custom assembly attributes for inclusion into each project.

Does most of emitting the ManagedProject.(profile).Generated.sln.Targets for each of our projects, with common project props and setups.

IsOutputPathInSeparateFolders: when building with a build tool, each project gets its own outdir, to avoid mixing up any of the output files which we're about to collect for deployment. Locally, everything is built into the same folder

Path to build output and intermediate dirs. Included “before”.

Sets up compiler warnings on/off at design/compile time, plus some VBNet warnings as errors. Some settings apply both in VS and in build, and some in build only.

#defines which are not regulated with any Mode-artifacts.

ProductHomeDir SubplatformHomeDir Also, SubplatformName (TODO: not needed?)

Parameters required to make CSC produce binary equal output on the same inputs.

Prevents the common targets from copying any referenced DLLs to the project's output folder on build. Included “before”. NOTE: copying refs to output folder is not needed because we're packing them from sources anyway, and since we're laying out project outputs by their subplatform/project folders, copying everything into each folder takes much time/diskspace, and should be avoided.

Enables XmlDoc generation for all our projects.

If a working copy were once operated as with SDK projects, the leftovers from that era might be confusing modern toolsets and failing builds with messages like "Your project file doesn't list 'win' as a "RuntimeIdentifier". You should add 'win' to the "RuntimeIdentifiers" property in your project file and then re-run NuGet restore.". These properties suppress the parts of the toolset which might be getting confused.

General settings for C#/VBNet projects. Included “before”.

If True, the path cannot contain things specific to the Configuration or Platform.

Suppress ImplicitlyExpandNETStandardFacades Microsoft.NET.Build.Extensions.NETFramework.targets for now, because we have nuget packages for these references and they do not behave good with overwriting our dlls in the output dir. They'd check if the project looks like it should reference NetStandard, and add pseudo-reference-assemblies for its DLLs to compilation via a dirty hack.

Roslyn uses named pipes for interprocess calls when reusing processes between compiler runs. This currently fails on Mono, so turn it off.

Instead of listing source files one by one, includes the list of them with a single wildcard. The wildcard is standard and does not sit in the .csproj but in the included managed targets file.

Language settings for C#/VBNet projects.

Suppresses some of the MSBuild warnings which we inevitably see in our solution due to having a mix of frameworks and architectures.

Assembles together the Roslyn feature members.

Hides all of the Compile items from Visual Studio so that no mem were wasted on their handling.

Add project reference metadata to avoid call NuGet targets. (https://github.com/Microsoft/msbuild/blob/master/documentation/ProjectReference-Protocol.md)

Sets up strong name signing of assemblies. Might have varying policy for Debug/Release builds. Included “before”.

Seems like a strong name is not a problem even in Debug builds, so let's have it everywhere for uniformity. Until R#9, we'd strong-name-sign only Release builds, but with SharedShell we have switched to SNing all.

A few info about the subplatforms-layout-specific environment. The idea is to only add info here on-demand, to avoid mis-use.

Disables VS in-process compiler, does not affect the build process itself. Included “before”. NOTE: we do not need VS build helping because we're running out-of-process MSBuild with heuristics, on the other hand, VS runs its background builds when allowed and slows down the things very much.

For each project, decides and sets its Target Framework, and adds toolset packages with compilers and headers, as appropriate.

We don't want to bind to full physical paths because this requires re-running PrepareWorkingCopy on each change, which we don't want to do locally. So we define fundamental properties, , and then reference them in other paths.

Whether debug asserts should be active and throw runtime exceptions. Default is True. False for production builds.

Whether stuff should be compiled optimized or not. This explicitly applies to the standard subplatform projects. Side compilations are welcome, but not required to favor it (e.g. might always be building for release, or always debug+release). Default is False. True for production builds.

Whether exceptions should be shown to the user. Default is ON.

Mark each assembly with an assembly attribute, so that we could later get the per-assembly mode at runtime. TODO: eventually, this should work per-package probably (with gettin the package of the host and its metadata then), but right now it's easier this way.

Whether statistics should be collected by the Statistics class. Default is OFF.

Whether set TreatWarningsAsErrors property.

see

Declare which products should go into deploy.json for subsequent deploy process.

We need this since R# Ultimate and Rider releases are not sycnhronized.

Default for ordinary builds is .

Everything about Rider

All R# Ultimate Products (R#, dot*, R# SDK etc)

Keeps shortened project names unique among the source projects of this profile.

Helps with installing the toolset for working with the solution. is the basic implementation, and this class adds usages of types specific to our solution. Now we prefer not to ship the whole toolset alongside the MSBuild, but instead plug in the relevant parts into each of the projects. So this has two parts, some recommended MSBuild, and a set of packages to add on per-project basis. The process is implemented by static methods in the class, this helper allows to avoid passing components manually and tracks that no two clients write into the same folder.

The main entry to the process. Expands properties from some of the , downloads and expands Nuget packages required for them.

Which props to expand — and fetch nugets for them. ID of the folder with toolsets. MUST be unique among calls to this method. Title for progress messages if dloading toolsets takes a long time.

Makes artifacts for Managed Project Stuffing out of the expanded properties. The request must have been already run.

For each project taking part in AllAssemblies, emits the generated Whatever.Project.Name.csproj.Generated.Targets file. This generated file should be included into the project as the one and only import at the end. This generated file includes the per-language common targets import, plus a number of standard project stuffing imports and task items, as calculated in the build engine.

The proxy imported project file name. Must not be possible to match with a profile-based main project file, for any profile name, including empty. Now, as it contains the "sln" word, that's a simple task.

Emits the proxt import MSBuild project file. This file has a fixed name and is included from the main project file by a fixed name. The file doesn't have any meaningful assignments inside, it only chooses which main msbuild imported project file to include, based on the current solution file name, if available, which tells the profile name. If not available, then the fallback is emitted to import by the most-recently-PWCed profile.

Forces projects in a subplatform to always compile with optimizations. Quite useful for various CPU-bound code generators.

For SDK Mini projects, list rel-to-homedir projects which should be forced into Mode Optimize.

Transitional. If legacy projects were generating files into under their source dirs, those files would interfere with SDK projects, clean them up.

Knows what Microsoft.CSharp.Targets etc is to be imported as the common targets import into project files of certain type.

The name of the project file (possibly with partial folder path, for context). The path for Import, or null/empty if this kind is not supported or not needed. True if this kind is supported

A item emitted as , see there for comments. NOTE they're global, not per-project. Origin: various emitters for project settings. Destinations: (1) PWC: emitted to product root alongside the solution file, per-profile. Imported by SDK targets automatically. See . (2) Compile: written to an isolated location, passed to compilation by path. See .

Writes out a file which can be directly used by the SDK Task to take parameters passed from project stuffing.

PWC-way: written to the Product Root under the name of the profile. Imported by SDK Targets automatically. NOTE on compile from build steps, the file gets emitted to an isolated location and passed to the build by path. This way it does not affect the current PWC even if with another props.

Sometimes we have leftovers after not properly configured project loading or independent builds, so we need to remove them.

For those projects which remain as non-SDK, fix them not finding their managed targets because of a changed solution name.

NOTE: most of the operations are done for ANY project, but SDK projects get an SDK attached rather than the managed targets.

Whether C++ internal stuffs have to be generated and sources are included. This should be OFF by default for general population, with turning ON for those who wants to play with C++. Default is False.

Whether CPP builds are not allowed to be run as Unity builds (where applicable and supported). This should be OFF by default for general population (thus allowing the builds to run as Unity), with turning ON for those who want to compile CPP the non-Unity way. Note that certain builds (e.g. CPP-CLI) might have additional considerations, like turning off Unity builds when optimization is turned ON. Default is False.

Whether CPP builds should use cahced compilation results from previous builds. Cached results are reused only in case sources has not been changed/ This should be ON by default for general population (since that speed up build a lot), with turning OFF only in case some cache fails. Default is False.

Whether it might be installed to the Bin Dir with the installer (supposedly, symbols packages are also included — check for if you want to filter that as well).

Ensures the Product Root Dir has all the product root files, like Product.Root, Nuget.config, etc.

This is the basic setup which can be performed for any set of sources/bin subs. This should be enough for all compilation build steps, but not for PWC. See for that.

Place in root dir to opt in for refasmer.

Requests that the tool package be injected by (a) requiring local restore of the tool Nuget package and (b) adding an MSBuild Import directive for it to all possible projects.

Condition for an artifact import

Rel path within the package (real, not effective) to be imported into MSBuild project files.

Nuget package with the tool.

Nuget package with the tool. Optional. Taken from the central list of omitted.

Optional. NULL to apply to all subplatforms, or a Regex which is matched against the subplatform name to determine if the tool task should be injected into the certain subplatform.

Handles .

If the binaries dir is not given, defers it from the product home dir as a fallback.

A supplementary artifact for specifying a local product binaries dir as a path relative to the product home dir (as a relative path behaves better in persistent settings). If the is given a value, this value is ignored. If the has to be calculated, it uses this value or falls back to if not set.

If relative, gives the desired path relatively to the . Otherwise, the path to use as is.

This class is accessible in build stage only, if you need to format product headline in runtime, use instead.

Appends product name.

Appends product version (wave + build number) like '2017.3 EAP 8 build 111.0.20171124.0-eap08'.

Takes company and version from subplatform. Requires not because the is only validly available with the sources, otherwise it would be an autogenerated unrelated install-time item.

Must not start with a digit because we derive VS Root Suffix names from the profile, and those take part in VS Hives (which are version+rootsuffix) which do not roundtrip well with text representation if the suffix could not be told apart from the version part.

A which has already been retrieved as a package (but not necessarily written to the local folder, see for that). WAS Chain: … … . WAS: previously, all packages would be retrieved centrally and local-restored centrally, on PWC and before build. Now, build or design-time do not require that (SDK projects handle these tasks by their own), and other occasional clients retrieve only packages they need, and local-restore to their specific locations.

Gets whether this package has been emitted as a simulated retrieved package reference rather than actually retrieved from the server.

The package.

The original references to which the retrieved package conforms. Unless , it has been retrieved by this reference.

Lists build artifact values which should be serialized during the Local Install to be then available at runtime as components.

If this artifact is set to True, all of the compilation should be skipped in favor of reusing the already-compiled stuff in the bindir. This helps with the local scenario when you often want to do stuff like LocalRegister without rebuilding everything anew. Shan't be set to True on the server.

Calculates a ready value for CPP compliation criterion. Converted into a helper for the sake of reporting missing files, there're dozens of them and emitting one error per file washes away all of the errors.

Calculates a ready value for CPP compliation criterion.

When your native compilation tries to collect an output file and does not see it there, call this method to report that it could be due to the Do Not Compile Native mode (if really so).

Path to the file, for diagnostics. Rel paths might be nicer for readability. Owning subplatform which tried to collect the file. Target logger for immediate message. Summary message goes to this helper's logger. If not running in Do Not Compile Native mode, uses this ( if omitted) to report the fatal error. If Do Not Compile Native is active, then it's always a non-breaking logger error.

When this helper is destroyed, reports the summary.

If this artifact is set to True, standalone hosts will not be integrated with the OS (Start Menu shortcuts and file associations). Shan't be set to True on the server.

If this artifact is set to True, standalone hosts will not be integrated with the OS (Start Menu shortcuts and file associations).

Input for the generator. Makes solution list these paths as solution items, under corresponding solution folders.

Generated real projects for project files on disk.

Input.

Generated solution folders to parent other stuff.

Given a build script class, finds the project it belongs to. Works for build scripts in sources because only has a meaning for subs-in-sources.

If required, a similar method which supports binary script as well (but has a more relevant return type) could be written, based on meta for bin subs.

Given a build script class, finds the subplatform it belongs to. Works for build scripts both in sources (gets sub on sources) and in binaries (gets sub on package).

Given a path to some sample file under the subplatform dir, looks up the subplatform for it.

All list of subs. Might include non-src ones, no problem. Rel path to sample file, under home dir (just like subplatform names themselves).

Extracts the path to the original build script file (assuming relative to ProductHomeDir, based on how scripts are fed for compilation) from a sample class from that file. This is based on PDB info, so the class must have some code in it.

Gets whether the subplatforms list has the given subplatform.

Gets whether the subplatforms list has a subplatform for the given type.

Given a build script class, finds the project it belongs to. Works for build scripts in sources because only has a meaning for subs-in-sources. If the class belongs to a sub-on-binaries, gracefully returns a False/NULL. If a class cannot be found to belong to any subplatform, it's an error.

Basic API to all-assemblies lists.

Caching and indexing of all-assemblies info.

Takes assemblies on sources, returns those of them which have been marked as [B] in the current profile.

The default name for the intermediate directory during the build, under Product Home Dir.

The default name for a ProductBinariesDir as a subfolder of the ProductHomeDir.

Package part extension for the jet package metadata objects embedded into a subplatform package. The part contains a structured storage with a SerializedValuesResolver holding the components. The other half of the part local name is the package ID (no version included, for easier cleanup when extracting), and the folder is the main content folder.

An explicit value for Product Home Dir when it has to be transferred to the callee via Environment Variables, e.g. when running NUnit tests on TeamCity in a sandboxed folder. Required for locating the test data. TODO: maybe pass the test data folder explicitly?

Name of the marker file which must be present in the root folder of the product. Used for autodetection of the product home dir from any dir under it, e.g. with .

Add to the subplatform package ID (generated with ) to get the ID of the Nuget package with the program database for that subplatform, separated with a dot.

Name of the marker file which, when planted in a non-root folder of a subplatform, instructs to look one more level down for project files. By default, only the subplatform folder itself and its immediate first-level child folders are considered for project files. In the root folder of a subplatform, this marker file is ignored. Otherwise, if this file is found in a folder X, any child folders (X/*) would also be checked for either project files or a marker file to look even deeper. If a project file sits too deep under the subplatform without the marker files, it would not be swept during a normal scan to save time. However, running would make a slower fully recursive scan to see if there are potentially useful project files missed from the runtime scan. If so, an autofix error would be issued, telling how to place the marker files to make this project reachable. If the project file is not intended to be included in the soluition (e.g. goes as resources instead), use marker file.

The proj extension makes it match the filename mask used when scanning for project files, which saves a filesystem lookup.

Name of the marker file which prevents from complaining on potential project files normally omitted by a scan due to its limited depth, see docs for details.

The SNK file in the subplatform root dir (next to ) which is used for strong-name-signing of all the assemblies.

Gets the list of subplatforms based on the locally-installed product binaries, as were extracted from the packages.

Gets the list of project files generating assemblies from all subplatforms of the product, and reads their expected assembly names.

Use . This is left only for tests.

Called on any folder within the source code tree of a product. Locates the product home dir by the marker file.

Used by subplatform to list project files.

The folder to look under. False: used by runtime, looks in the folder and its first-level child folders (unless got special marker). True: diagnostical, yields all of the projects (unless got another special marker).

Looks for subplatforms which are represented by source code folders under the product home dir.

Calculates Package ID for a subplatform package.

Called on any folder within the source code tree of a product. Locates the product home dir by the marker file.

A hack for ripping the assembly name and the ouput type from the project file. We're not spawning the whole MSBuild here, but just read the expected XML element. Should work for most our cases.

Collects all-assemblies on sources and on packages.

Just as , but specifically being created over already-compiled packages.

An extended (CLR4+) version which knows its package of origin. Also, not available in runtime because loading all packages into memory on startup would be very expensive.

Just as , but specifically being created over source-code-presented assemblies.

Optional package metadata which specifies the project files from which the DLLs were originally built. Used for mapping project references into the binary DLL replacements.

Lists project-in-subplatform — assembly name pairs.

Assembly name of the DLL compiled from this project.

Path of the project file from the root dir of its subplatform.

If known that this project will compile into a DLL. With NetCore, this does not necessarily mean that the project does not have an entry point. If not set, either or unknown.

If known that this project will compile into an EXE. If not set, either or unknown.

The project is based on a MSBuild Mini SDK, the new format which imports implementation targets from an custom mini-SDK, rather than as an explicit import.

The project is based on a Microsoft full SDK, the new format which imports implementation targets from an full Microsoft SDK, rather than as an explicit import.

Indicates that this subplatform contains public repositories.

Indicates that this project should not be treated as a product assembly.

Indicates that this project should be treated as a dotnet global tool.

Gets project output extension, based on its flags. throws by default. If non-throwing, fallbacks to a DLL.

Guesstimates the local name (with ext) of the project output assembly file. That's what you get in for this project after packaging it. On problems with determining the ext, falls back to DLL (unless throws).

The root object of the subplatform descriptor.

Like .

Whether this subplatform only exists to provide build script sources to other subs. It won't produce an output Nuget package, and references to it won't result in Nuget package references. This is somewhat a hack because it only works if the subplatform is taken in sources, but at this point that's the most optimal solution for cases like native builds.

Lists other subplatforms referenced by this subplatform.

Optional. Manually overridden subplatform version number. By default you should leave this NULL to allow the wave-number-derived version to be used. Do not read directly unless you want the manual value only, use to get the version of a specific subplatform, which takes auto-substituted versions into account as well. If NULL, usages like will derive a value from the current wave number, .

A subplatform which has been created from an already-compiled application package, without access to the sources.

The product package of this subplatform.

An extended (CLR4+) version which knows its package of origin. Also not available in runtime because loading all packages into memory on startup would be very expensive.

The original package on which this subplatform has been created.

Gives info on name and location of the original projects off which the package has been compiled, in case such info were available with the package. Yielded by our build system and used by it to do swiches between source-based and binary-based subplatforms, e.g. in project-to-project references.

A subplatform which has just been created from source code projects, by parsing out assembly names out of project files.

Project files. Paths are relative to the subplatform root folder. Partial info from .

Project files and the assemblies they would produce.

Gets the info on the Platform Core Shell subplatform, the center-most subplatform of all the infrastructure. NOTE: for other subplatforms, probably there'll be an auto-generated “Current Subplatform Name” class.

Access wrapper for in in .

References another subplatform by its name, which is a relative path from the product root.

Whether this subplatform reference only exists to provide build script sources to other subs. It won't result in Nuget package references. This is somewhat a hack because it only works if the subplatform is taken in sources, but at this point that's the most optimal solution for cases like native builds.

Whether this subplatform reference only exists to be included into Nuget package references. It won't be used during subplatform compilation.

Whether this subplatform reference should be used only on these runtimes.

Collects subplatforms from all of the input packages, without applying the to them. Similar to and , but those two obey the and might not include smoe of the subplatforms-originating input packages. Those two should be used by features which should obey the filter (like, running tests, packing installers, etc), while this object is for retrieving content from an expected input package, like clean launchers from Platform Core.

With a standard local build over the main solution, the outermost build stage (not including bootstrap) is an “entry” build which runs on the built-in engine, on Platform Core builds script sources (so that the bootstrapper only knew about this and not about how to discover the whole solution), and does nothing special but for discovering the actual solution structure, running a source stage (on the whole build script sources set now), optionally running the bin stage on its compile results, and optionally prepping B-profile subs before running all that. This class encapsulates the logic for spawning these stages. NOTE that server builds are usually either source-only or bin-only, so their bootstrapper (Make Isolated Request) would do all the discovery and make a request for running already a pre-setup stage right on full build script and ready previous binaries etc.

When running a build for , specifies which objective to invoke on the source stage.

The Nuget package with binaries of a freshly-compiled subplatform. Gets into the whole s collection by the end of the compile stage. On the binary stage, available among other s. The ID of the package is calculated with .

Calculates datetime fields for compiled packages. A service artifact, not intended for manual use.

Gets the expiry date.

Gets the date and time when the current package was built.

The Nuget package with program database files for the binaries of a freshly-compiled subplatform. Gets into the whole s collection by the end of the compile stage. On the binary stage, available among other s. The ID of the package is calculated with , plus the .

Visual Studio hive (version, instance Id and root suffix) for integration tests. Examples: "15.0", "15.0_a0848a47" or "15.0_a0848a47Exp". Instance Id and root suffix are optional. If omitted, they will be guessed from the current environment. If not defined or the value "0.0" means a standalone app (not a VS).

File name of the standalone application executable for integration tests.

Optional environment variable that specifies the integration tests mode - if true, the tests will run in OOP mode.

Optional environment variable that specifies the architecture for the standalone application to be tested. Use constants from enum. If not defined, current OS architecture will be used. Is not applicable and ignored for Visual Studio.

Obsolete. Sets the CPU for the integration tests server process. Use constants from ProcessorArchitecture enum. ProcessorArchitecture.PROCESSOR_ARCHITECTURE_UNKNOWN means “same as the current runtime”.

"True" defines that integration tests are running on TC in a virtual environment - server is started in a separate virtual machine. Obsolete and is not used now, kept for historical reasons.

"True" defines that integration tests are running on TC in a single machine mode - client and sever are on the same TC agent.

The environment variable defines a checkout directory of dotnet products on a TC agent. It is a subdir of the TC build checkout dir (%teamcity.build.checkoutDir%).

The environment variable defines a product install directory on a TC agent.

"True" allows to run capture traces if required, otherwise no capture traces taken.

When "true" the integration tests client should reset user settings before each new integration tests server process started.

Logging level to be passed to the product through "LogLevel" command line switch. Use enum values.

The environment variable defines a count of retries for failed tests

Field indicates should test retry or not

The environment variable defines a directory for performance logs. The directory path could be either absolute or relative. In the second case the directory is created under Logger.LogFolderPath.

The environment variable defines a profiling type (Sampling\Timeline) for the performance tests.

A directory on a TC agent to place artifacts that will be published and available on the TC build Artifacts tab.

A directory (local or on a TC agent) from where the integration tests client is started.

Specify this command line key for the process to make sure the integration test server component is enabled on start.

Integration tests run mode.

Requests run an empty VS process to warm up after Local Install and before running actual tests. It should be performed only once per tests episode, which may consist of more than one test assembly. The tests client should be able to clear the flag when dry run is performed. We cannot use environment variables for this purpose and have to use a marker file on the disk.

Denotes that the integration testing task wants to know the home dir for its affairs, even though the regular home dir is not normally available for binary stage tasks.

List of products to install in the integration testing task.

Integration tests run mode.

Integration tests are running locally.

Integration tests are running on TC in a single machine mode - client and sever are on the same TC agent.

Integration tests are running in a virtual environment - server is started in a separate virtual machine. Obsolete and is not used now, kept for historical reasons.

A separate artifact to specify the home dir root for test data. This is to avoid mixing up with the regular home dir when we're running binaries-only builds with tests. Also, the test data home folder might quite differ from the regular home dir.

Specifies batch parameters for Parallel Tests build feature by TeamCity.

Applies a filter to the unit tests, either by category or by assembly to run. To filter by subplatforms, set the .

A Regex which filters which subplatform assemblies are getting fed into the unit test runner. filters subplatforms which are deployed for running the tests, and this allows to further limit it down.

As in .

Specifies the platform for running unit tests, which includes the CPU architecture and CLR version.

Constants used to check ReSharper Ultimate license

Version of corresponding ReSharper Ultimate release

DateTime of corresponding ReSharper Ultimate release

Url to show the user who uses pirated blacklisted license server

No need to prepare for Ngen by default

Preparations for ngen will be made if true

Default value: OFF.

Each product package we emit must have a reference to the synthetic Wave package. This class manages either fetching this package from previous builds binary results, or emitting a new one. If emitted, should go to list.

Identifies subplatform packages as belonging to a certain bundle.

Create bundle package.

The expected/prospected bundle package ID for this wave and for this prerelease metadata.

Creates default instance of this class. Can be used (and SHOULD be used ONLY!) in environments without shell component container

DotNetCoreInstallationsDetector without custom dotnet providers Instance of if at least 1 SDK was found, otherwise null.

Represents global.json see https://docs.microsoft.com/en-us/dotnet/core/tools/global-json?tabs=netcore3x#globaljson-schema

Represents default model when there is no global.json was specified

This property represents so called 'shared frameworks' in the 'shared' folder under DOTNET_ROOT, also sometimes called 'runtimes'.

List of possible dotnet locations

Extension point for selecting best dotnet for current project. Do not use explicitly. Use DotNetCoreInstallationsDetector.ChooseBestDefaultDotNetCoreToolset() instead.

Override existed file on CDN

Unzip file during pushing on CDN, apply only for .zip files

Note: DON'T FORGET TO UPDATE Publisher.DeployAccessArtifact AFTER CHANGES HERE!!!

A strongly-typed resource class, for looking up localized strings, etc.

Returns the cached ResourceManager instance used by this class.

Overrides the current thread's CurrentUICulture property for all resource lookups using this strongly typed resource class.

Looks up a localized string similar to All.

Looks up a localized string similar to Unable to find '{0}' in '{1}' and found multiple versions of '{0}' installed. Please specify a version..

Looks up a localized string similar to Found multiple versions of '{0}' installed. Please specify a version..

Looks up a localized string similar to Unable to update '{0}'. Found multiple versions installed..

Looks up a localized string similar to Some extensions are missing from this product. Click to restore..

Looks up a localized string similar to A new version of NuGet Package Manager is available..

Looks up a localized string similar to Each extension is licensed to you by its owner. JetBrains is not responsible for, nor does it grant any licenses to, third-party extensions. Some extensions may include dependencies which are governed by additional licenses. Follow the extension source (feed) URL to determine any dependencies..

Looks up a localized string similar to Type 'get-help NuGet' to see all available NuGet commands..

Looks up a localized string similar to Failed to initialize the PowerShell host. If your PowerShell execution policy setting is set to AllSigned, open the Package Manager Console to initialize the host first..

Looks up a localized string similar to Added file '{0}' to project '{1}'.

Looks up a localized string similar to Added reference '{0}' to project '{1}'.

Looks up a localized string similar to Removed file '{0}'.

Looks up a localized string similar to Removed file '{0}' from folder '{1}'.

Looks up a localized string similar to Removed folder '{0}'.

Looks up a localized string similar to Removed reference '{0}' from project '{1}'.

Looks up a localized string similar to Each extension is licensed to you by its owner. JetBrains is not responsible for, nor does it grant any licenses to, third-party extensions..

Looks up a localized string similar to Extension Manager.

Looks up a localized string similar to Don't show again.

Looks up a localized string similar to The project is invalid.

Looks up a localized string similar to The project '{0}' is unsupported.

Looks up a localized string similar to Error reading '{0}'..

Looks up a localized string similar to Executing script file '{0}'..

Looks up a localized string similar to Failed to add reference to '{0}'. Please make sure that it is in the Global Assembly Cache..

Looks up a localized string similar to Failed to add reference to '{0}'..

Looks up a localized string similar to Case insensitive search for reference '{0}', to be removed, returned more than 1 match. Request could not be performed..

Looks up a localized string similar to File Conflict.

Looks up a localized string similar to Ignore for now.

Looks up a localized string similar to '{0}' already installed..

Looks up a localized string similar to Unable to retrieve extension list because no source was specified..

Looks up a localized string similar to No updates available for '{0}'..

Looks up a localized string similar to NuGet official package source.

Looks up a localized string similar to Operation failed..

Looks up a localized string similar to '{0}' cannot be removed because it in use by '{1}'.

Looks up a localized string similar to '{0}' was not installed in any project. Update failed..

Looks up a localized string similar to Finished configuring this product to restore extensions on start..

Looks up a localized string similar to Do you want to configure this product to download and restore missing extensions?.

Looks up a localized string similar to Downloading extension '{0}' failed..

Looks up a localized string similar to An error occurred while configuring the product to restore extensions on start.

Looks up a localized string similar to An error occurred while trying to restore extensions. Please try again..

Looks up a localized string similar to Downloading missing extensions....

Looks up a localized string similar to Skipped reinstalling extension '{0}' in product '{1}' because the extension does not exist in the extension source..

Looks up a localized string similar to Skipped reinstalling extension '{0}' because the extension does not exist in the extension source..

Looks up a localized string similar to Configuring the product to restore extensions on start....

Looks up a localized string similar to The extension source does not belong to the collection of available sources..

Looks up a localized string similar to '{0}' updated successfully..

Looks up a localized string similar to No project was specified..

Looks up a localized string similar to Reinstalling '{0}' in project '{1}'..

Looks up a localized string similar to Reinstalling '{0}'..

Looks up a localized string similar to You must restart application in order for the changes to take effect. The following extensions require a restart: {0}..

Looks up a localized string similar to Restart Now.

Looks up a localized string similar to _Restore.

Looks up a localized string similar to Show Details.

Looks up a localized string similar to Unable to locate the solution directory. Please ensure that the solution has been saved..

Looks up a localized string similar to The current environment does not have a solution loaded..

Looks up a localized string similar to Package Installation Error.

Looks up a localized string similar to Error accessing Extension Manager..

Looks up a localized string similar to Could not add all required extensions to the product. The following extensions failed to install from '{0}':.

Looks up a localized string similar to The project template has a reference to a missing Extension. Could not find an Extension with ID '{0}'..

Looks up a localized string similar to The project template lists one or more packages with missing, empty, or invalid values for the "id" or "version" attributes. Both attributes are required and must have valid values..

Looks up a localized string similar to The project template has a reference to a missing Registry value. Could not find a Registry key with name '{0}' under '{1}'..

Looks up a localized string similar to The "repository" attribute of the package element has an invalid value: '{0}'. Valid values are: 'template' or 'extension'..

Looks up a localized string similar to This template wizard can only be applied to single-project or project-item templates..

Looks up a localized string similar to The project template is configured to use an Extension-specific package repository but the Extension ID has not been specified. Use the "repositoryId" attribute to specify the Extension ID..

Looks up a localized string similar to The project template is configured to use a Registry-provided package repository but the Registry value name has not been specified. Use the "keyName" attribute to specify the Registry value..

Looks up a localized string similar to Adding {0}.{1} to project....

Looks up a localized string similar to The project template is configured to use a Registry-provided package repository but there was an error accessing Registry key '{0}'..

Looks up a localized string similar to Attempting to install version '{1}' of '{0}' but the project already includes a different version. Skipping....

Looks up a localized string similar to Unable to find extension '{0}' version '{1}' from the source '{2}'..

Looks up a localized string similar to Unable to find extension '{0}'..

Looks up a localized string similar to Unable to find extension '{0}' in '{1}'..

Looks up a localized string similar to Windows 8 Packages.

Looks up a localized string similar to Directory '{0}' is not empty. Skipping....

Looks up a localized string similar to Failed to generate binding redirects for '{0}'. {1}.

Looks up a localized string similar to Failed to remove extension directories that were marked for deletion on application restart: {0}.

Looks up a localized string similar to Failed to remove extension directory '{0}' that was marked for deletion on application restart..

Looks up a localized string similar to Failed to find match for removing reference '{0}'..

Looks up a localized string similar to Failed to mark extension directory '{0}' for deletion on application restart: {1}.

Looks up a localized string similar to '{0}' already exists. Skipping....

Looks up a localized string similar to No exact match found for removing reference '{0}'. Trying case-insensitive search....

Looks up a localized string similar to Extension {0} of version {1} is not referenced by any product..

Looks up a localized string similar to Install failed. Rolling back....

A strongly-typed resource class, for looking up localized strings, etc.

Returns the cached ResourceManager instance used by this class.

Overrides the current thread's CurrentUICulture property for all resource lookups using this strongly typed resource class.

Looks up a localized string similar to Failed to insert actions because the anchoring action is not included in the actions group we are inserting into.

Looks up a localized string similar to Failed to insert an action into the group because it failed to load.

Looks up a localized string similar to Failed to insert actions because an anchoring action was specified, which conflicts with the relative positioning value.

Looks up a localized string similar to Failed to insert actions because the target action group does not exist.

Looks up a localized string similar to Failed to insert actions because the target action ID belongs to an action that is not an action group.

Looks up a localized string similar to Failed to insert actions because the anchoring action does not exist.

Looks up a localized string similar to Failed to insert actions because the relative positioning value is invalid.

Looks up a localized string similar to Failed to insert actions because the anchoring action was not specified, as required by the relative positioning value.

Looks up a localized string similar to Failed to load the product action {0}.

Looks up a localized string similar to Unnamed <{0}> Element.

Looks up a localized string similar to Cl&ose.

Looks up a localized string similar to Copy to clipboard.

Looks up a localized string similar to Copy URL.

Looks up a localized string similar to Created new issue.

Looks up a localized string similar to Do not show this window after exceptions are submitted.

Looks up a localized string similar to Double-click an item to open the corresponding issue in a web browser or press Enter.

Looks up a localized string similar to Forget.

Looks up a localized string similar to Message:.

Looks up a localized string similar to &Mute.

Looks up a localized string similar to &Please describe what you were doing when the exception occurred (example: I tried to open a 6-project solution with BizTalk projects):.

Looks up a localized string similar to Please note that exceptions are submitted to JetBrains public tracker, which is available publicly.

Looks up a localized string similar to &Remove.

Looks up a localized string similar to &Submit.

Looks up a localized string similar to The popup menu must be used on the UI thread only.

Looks up a localized string similar to The menu is already visible.

Looks up a localized string similar to The menu item key is expected to be non-null.

Looks up a localized string similar to The no-items case should have been cut off earlier.

Looks up a localized string similar to Summary.

Looks up a localized string similar to When Happened.

Looks up a localized string similar to Nothing found.

Looks up a localized string similar to Issue Key.

Looks up a localized string similar to Result.

Looks up a localized string similar to Submitted.

Looks up a localized string similar to Download the list of available updates from the Web.

Looks up a localized string similar to No personally identifiable information is uploaded to the server.

Looks up a localized string similar to There are new plugin versions available.

Looks up a localized string similar to There are new {0} versions available.

Looks up a localized string similar to Download.

Looks up a localized string similar to Estimated price.

Looks up a localized string similar to free.

Looks up a localized string similar to There is a new plugin version available.

Looks up a localized string similar to There is a new {0} version available.

Looks up a localized string similar to feature release.

Looks up a localized string similar to update.

Looks up a localized string similar to prerelease build.

Looks up a localized string similar to service update.

Looks up a localized string similar to There are no updates available.

Looks up a localized string similar to There are no updates available for {0}.

Looks up a localized string similar to Plugin Updates.

Looks up a localized string similar to {0} Updates.

Looks up a localized string similar to Read More.

Looks up a localized string similar to installs.

Looks up a localized string similar to This.

Looks up a localized string similar to Unidentified Product.

Looks up a localized string similar to Unknown Company.

Looks up a localized string similar to Untitled.

The type of the experiment to check. true if the current instance is in the experimental group for the specified experiment; otherwise, false. Thrown when there is an error determining the experiment status.

Adds A/B Experiments' status to the About Box.

Settings for A/B Experiments.

Represents an A/B experiment with a configurable fraction of users allocated to it. Users not assigned to any experiment (remaining control group) will be shared evenly across experiments. To define a new A/B experiment, create an on-demand Shell component implementing this interface, and it would be the identity of your A/B experiment. The name of your class should not contain the word "experiment" because it will be displayed in the About -> Show more where users can see it, and it can affect experiment results.

Fraction of users in the experimental group, rounded to increments of 0.001 (for 1000 divisions for precision), with values up to 0.5 (50%). If null, users are distributed equally among this and other experiments with null fractions, which is the recommended approach for balancing distributions.

Provides notifications related to the state of A/B experiments.

Invoked when the method is called for a specific experiment type.

Gets permanent unique device Id. The Id is saved in Registry under HKCU\Software\JetBrains\Platform section.
The Id is used to idendify same user even after ReSharper (or another product) is reinstalled or downgraded. Please note that the Id is shared among all JetBrains applications intalled by the user. To make it sharable with Idea team it also resides in %appdata%\Roaming\JetBrains\PermanentUserId This one is to be used for feature statistics reporting.

Gets permanent unique user Id. The Id is saved in Registry under HKCU\Software\JetBrains\Platform section.
The Id is used to idendify same user even after ReSharper (or another product) is reinstalled or downgraded. Please note that the Id is shared among all JetBrains applications intalled by the user. To make it sharable with Idea team it also resides in %appdata%\Roaming\JetBrains\PermanentUserId This Id appears compromised for feature statistics reporting. Use PermanentDeviceId instead.

Alter actions do not en force the rebase operation when applied on the frontend. They are non-editing actions. They must be part of the alter subsystem because they are bound to position in time between actions initiated by the backend. Example of such an action: Open/Close undo scope should be time-bound: Backend will produce the following flow of changes on double-undo actions [Close Undo] ← DocMod2 ← [OpenUndo] ← [CloseUndo] ← DocMod1 ← [OpenUndo] It may look like undo actions should be regular Commit, but it is not convenient to have them as such. We cannot predict them on the frontend side, so the histories will be constantly diverging. We want to avoid flickering when possible and, so this mechanism is introduced. Alter actions do not en force the rebase operation when applied on the frontend. They are non-editing actions. They must be part of the alter subsystem because they are bound to position in time between actions initiated by the backend. Example of such an action: Open/Close undo scope should be time-bound: Backend will produce the following flow of changes on double-undo actions [Close Undo] ← DocMod2 ← [OpenUndo] ← [CloseUndo] ← DocMod1 ← [OpenUndo] It may look like undo actions should be regular Commit, but it is not convenient to have them as such. We cannot predict them on the frontend side, so the histories will be constantly diverging. We want to avoid flickering when possible and, so this mechanism is introduced. Represents a list of Alter actions

An optional commit message used only for diagnostics purposes.

Stores s with and provides helper methods to manage and traverse commit graph.

Clear all commits from the database except provided heads and a history to a base revision

Clear all commits except

Log the commits starting from (included) to (not included)

Basic interface for alter request. The alter system is based on the idea that there are two sides which make requests and maintain same history, similar to git repository. The conflict resolution is simple - backend always wins. Alter request is a serializable class, which represent change in the state of the editor/document/caret etc. Two most important aspects of alter request: 1. in can be serialized and passed to the other side 2. the two requests which output the same sequence of bytes are considered equal.

Marker interface for alter requests. Implementing this interface means, that the processing of the request on the backend will need write lock in most cases. Visit a commit action. Commit action can be applied on the frontend side only when the state of the worlds is equal to the encoded revision in the commit Visit a non-bound to revision action, which do not force the rebase operation, on apply on the frontend.

Takes all and applies the combining rule.

Returns files from the Extensions sub-folder

Extension settings and annotations files must be stored in a per-extension folder under "Extensions", e.g. "Extensions\{extensionId}\annotations\" or "Extensions\{extensionId}\settings\". This is to prevent name clashes since all packages are extracted to the main install directory. (Especially the case for annotations, where the filename is the name of the assembly being annotated). An instance of . The to be returned from the per-extension Extensions folder. An enumerable of all the files under in the per-extension Extensions folder.

Find the package with the host to provide version/build info By default, it's the Platform Core package, but if the host component is overridden in a product to provide the product info, we'd use its home package instead

Aggregating interface to access host properties, host product and shortcuts to host folders

Images of end user product.

AboutBox for the product shows this image. Recommended minimum logical width: 200h. Usually, it's the same image as the installer Welcome Page banner. So its logical width is 512 device-independent pixels.

Set to True to ask user whether he'd like to choose an alternative keyboard scheme during the product OOBE experience.

Examples: ReSharperPlatform, DotPeek, InspectCode, etc. Implementations are environment components.

Whether advanced layer editing should be available in Options etc. Null or no handlers means “Yes” (this functionality is activated by default). Any False wins over all Nulls and means “No”. Any True wins over all Falses and Nulls and means “Yes”.

Allows to look for older-version settings in non-standard folders when there are no up-to-date-version settings found and we would like to upgrade from an older version. The strings are file path names. The versions are versions of the product to which the settings supposedly belong.

Set this metadata on IApplicationDescriptor.Bag to enable showing product help on this command line key.

Set this on the application descriptor to the Action ID of the main menu for your application. Null means your application does not have a main menu.

Set this on the application descriptor to the Action ID of the main toolbar for your application. Null means your application does not have a main toolbar.

When an instance of this product is already running, whether to start a new instance or to pass the control to the existing one.

Standard multiple instance application. No single instance behavior.

When an instance of this product is already running, starting the second instance will not create the host but will pass the command line to the first instance AS IS instead, and exit.

To watch for the new command line arguments, see the .

Show the main application window which could be hidden.

Renders the product info in the same way as it's presented in ALL about-like UIs: About Box, VS About Box, VS Options, Exception Info, and so on. The first string is the company-name-marketversion part (“bold part”) and the second is the technical version. build date is omitted because it looks ugly.

Determine how plugins or plugin related files should be saved between product versions.

The cheat of using this instead of some is to have format it decently by default.

Fires periodically during the application idle time. Uses WinForms Application.Idle event.

Fires periodically on the main thread during the application idle time.

Gets the suffix that forms the , . The template must not include location-specific parts (ie “Software” for registry or “AppData” for folder), as they should be concatenated by consumers. There should be no leading or trailing slashes.

Gets the path to the product's Registry key.

Gets the location of the settings folders used by the product (product-specific or not). Creates the directory if missing.

The main implementation method for getting the settings directories for all products, per-product, product-specific, etc.

Product short name, if the settings should be per-product. NULL or "" for all-product settings location. If non-NULL and is specified, produces version-specific product settings. If non-NULL and is not specified, produces versioned all-products settings location. If NULL, produces version-invariant location (either all-products or product-specific). Allows to further differentiate locations by product or environment flavors, for example Visual Studio hives, as used to be up to R# 5. Each pair in the list is the name and the value of the additional parameter. Visual Studio 9.0 specific folder for the main Visual Studio hive has it as ("vs", "9.0"). A subfolder will be created for every additional parameter, in the exact order as they're given here. NULL or an empty list means there're no additional parameters. In this class, the default value for additional parameters is provided by the "GetSettingsPathSuffixAdditionalParameters" function (overridden by specific environments, like Visual Studio). Relative path to the directory (might not exist yet) from %APPDATA%, Registry Software key, etc. General rules for forming the suffix: • Folder with the company name. Always present. • Folder for the product, or the special “All Products” folder name () if getting an all-products location. • Folder for the version (as “v”{Major}{Minor}), or the special v∀ string () if getting an all-versions location. • One folder per each additional parameter (parameter name and value concatenated). The overall scheme looks like this: {CompanyName}/{ProductName}/v{Version}[/vs{VsVersion}{VsRootSuffix}].

Component for providing environment-defined settings location of products (VS, non-VS, etc).

Gets the path to the product's Registry key.

Registry prefix which forms the Registry key when combined with the suffix.

Gets the location of the settings folders used by the product (product-specific or not). Creates the directory if missing.

The main implementation method for getting the settings directories for all products, per-product, product-specific, etc.

When making an all-products folder location (e.g. with ), used in place of the product name.

Used in place of the version-named folder when getting a version-invariant location (e.g. with ).

Gets the list of legacy user-settings dirs (coming from previous product version), actually found on the local system, sorted in descending priority order. That means something like R# v2.5, which was in use even before platform v5 and compatibles, so it's double-legacy by now. The second part of the tuple is the product version of the legacy settings file.

Full path to the User Settings () XML file we save. Platform v5 and below. Overridden in some of the DotTrace subproducts.

Full path to the Workspace Settings () XML file we save. Overridden in some of the DotTrace subproducts.

Gets the directory in which the product assemblies are located.

Logs env vars and process name on startup. WAS: in , but it then would sit on the critical startup path being a sync operation. Now it will appear a bit later, but still.

Isn't an overridable factory anymore (since we upgrdaded everyone to a set of modern strategies), but keeps the knowledge of when to choose and which.

Provides environment config for internal/public modes.

If assigned by somebody, explicitly specifies the internal mode for next shell start, regardless of the cmdline.

Component for providing environment-defined settings location of products (VS, non-VS, etc). Specializes with a specific product. If you'd like to override the behavior in your product, you should rather override the utility class , because it provides impl for this class and some more.

Gets the full path to the computer-local per-user folder that stores the product settings. This folder should be used for storing large or easily-re-generated files, like type index caches.

Gets the full path to the network-roaming per-user folder that stores the product settings. This folder should be used for storing small and non-re-generatable files only.

Gets the path to the product's Registry key.

Gets the directory in which the product assemblies are located.

Manages Suspend/Resume functionality for the product.

Gets whether the product is currently in the suspended state. If you change the property value, or call one of the appropriate methods on this class, the product will be suspended or resumed.

Applies the command line key values to .

Supports persisting the suspended state in the Registry.

The product gets into the resumed state on startup

Causes the package to start in the resumed stage.

The product gets into the suspended state on startup.

Causes the package to start in the suspended stage.

Allows the product to start only if it's not suspended.

We want them installed earlier, by a host init mixin, and this just checks it hasn't been missed.

With Shell-running environments, we only init logger without file system watcher in its , and this component sets up watching for changes in the config.

Gets whether Internal mode is present among product configurations.

Caches info on the list of the currently installed application packages.

Turns known for deployable packages into the runtime which also knows where the packages are installed.

Handles requests from code to shut down the application. If you detect a situation when the app should be shut down, e.g. the main window has been closed, or File|Exit has been invoked, or the automated application has completed its task, call this handler.

Call this method if you would like the standalone application to shut down.

After shell has been temporarily shut down by this method, revokes this effect.

Called by impl to restart the host process in the host-specific manner, as might be overridden by the environment. The base impl tries to replay the command line.

The Application Shell should be shut down. For own hosts (like Standalone Executable apps), the host process would be shut down as well. For integration hosts (like Visual Studio), the product will be suspended, but the host process would continue running.

The Application Shell would be shut down and restarted without affecting the host process.

The host process would be shut down and run again with the (possibly) same settings.

The host process would be shut down and attempted to run again with high integrity level (“elevated”).

Any of the legal documents is not accepted by user or any of the policies is not satisfied.

All assemblies and types which pass the filter in the current catalog set.

Force-enabled zone

Allows to specify additional Deployed Packages for running with a product, in addition to what's been installed with the host. For example, a plugin. This class carries the possible data, serializes it back and forth, and can read it from certain sources. The XML text serialization (e.g. used for value) is performed by / methods. The spec is on the class.

Base name for environment variables in which the additional packages are assigned. The full name MIGHT have a process-specific suffix, like _PID_DEADBEEF, where DEADBEEF stands for the hex process id DWORD, which means that this variable is only intended for the process with such process ID. If the environment variable name has no PID specified, then it is suitable for any process.

Allows to specify additional packages for a child process through the environment variables, which has no problems with escaping and little problems with length limit. A variable name without the PID in it works good enough, except for one case when another JetBrains product is spawned from the process which has been given the environment variable. As the env values are derived by child processes, that new process would attempt to load packages which were not intended for it but only for its parent. When reads this property, it renames it to include the PID of the current process, which prevents child processes from inheriting the value. As you do not know the PID of the child process when setting this variable, you're expected to set the variable without the PID initially. If both bare and PID-specific properties are set, the bare has priority, and is renamed into PID-specific anyway.

Lists additional folders which should be scanned the same way as the main installdir of the product.

Implements the logic for reading env var value and moving the env var to PID-specific to hide from child processes.

Allows to create an application package from ad-hoc metadata and files, without a Nuget package or a JetMetadata file actually present on disk. All assembly files which should end up in the application Part Catalog (for creating the components) MUST be listed as child elements. This is the serialization info class for reading the additional packages data. Its goal is to parse and roundtrip, it does not do coersions and runtime validations yet. does the final validation and creates the application package.

Does the final runtime validation (that the files do exist on disk etc), reads the delay-read assembly names.

Boxed assembly name => assembly name; boxed null => read ad-hoc assembly name from file, must be a .net assembly; null box object => assembly name not expected.

Defines the schema for the environment variable XML content (see for possible env var names). Only local names of the elements are considered, namespaces are ignored, an empty one is used by default. The root element is the , and it might have one level of children in any order: , , .

]]>

]]>

]]>

Format choice rationale: We need to set the basic formatting rules for splitting multiple items on the list and item fields like id/version, as well as escaping for the items text. Choosing a well-known and well-supported format defines these rules clearly and enables the use of standard tooling for a reliable result. Well-tooled formats would be XML and JSON, but JSON requires escaping for the backslash which is expected to be a common char in paths, while XML does not touch the most commonly used path chars. Manual input is still possible, but the environment variable is mostly expected to be produced programmatically.

For a package file (in ): — An empty string "" or no attibute: means this is not an assembly file but a content file. Would not be included with the application Part Catalog, even if a managed assembly. — A valid full name of a .NET assembly, including at least the simple name (MUST match the file name without the extension) and version. The assembly would be added to the Part Catalog, and its classes created as components. — A star, "*": a shortcut for the above, means that you do not know the version (and the simple name matches the file name). The file would be treated as an assembly.

In element: the base directory of the ad-hoc application package, corresponds to the . All paths are relative to this directory. The path must be an absolute file system path and comply with parsing by .

Optional. In element: makes . Should be serialized in ISO-8601.

In element: makes . Should be serialized in ISO-8601.

In element: makes . At least one of the company names MUST be set.

ID of the package to be retrieved from the Nuget server.

Attribute for the local file/directory paths in the -friendly format.

The relative path of the item, relatively to the base directory. Must comply with string parser. Generally, that's just a path with forward or backward slashes and no escaping (except for what XML does of course).

In element: makes .

In element: the exact version of the package to be retrieved from the Nuget server, prerelease versions are allowed. In element: the semantic version for the application package. Must comply with parsing. Makes .

First-level child. Allows to create an application package from ad-hoc metadata and files, without a Nuget package or a JetMetadata file actually present on disk. All assembly files which should end up in the application Part Catalog (for creating the components) MUST be listed as child elements. Parent: . Child elements: . Attributes: , , , , , , , .

First-level child. Downloads a Nuget package from the Nuget server sources registered for this machine. The package exact identity is given by and . The package would be retrieved, expanded to a shadow directory, and its expansion location scanned for files the same way as the main installdir. Parent: . Child elements: none. Attributes: , .

First-level child. Reads the Nuget package file on the local filesystem at . The package would be expanded to a shadow directory, and its expansion location scanned for files the same way as the main installdir. Parent: . Child elements: none. Attributes: .

First-level child. Scans the local filesystem folder at the same way as the main installdir. Special handling: if installdir is given again as a , it will not be added as a duplicate and scanned for the second time. This allows to describe the whole layout in additional packages without specifically excluding the directory with an entry point. Parent: . Child elements: none. Attributes: .

Lists a package file for . Parent: . Child elements: none. Attributes: , .

Local name of the root element. As with all element names, they are matched by the local name, and the namespace is ignored. Parent: none. Child elements: , , , . Attributes: none.

For any folder into which a packages-based app is deployed, can cache the info which is normally extracted from the packages.

Loads the set of deployed packages as given in the , which is the discovery result over some bindir or elsewhere. Tries to read the data from the fast cache if available.

Identifies the bindir, plus possibly some filtered view on it.

This flag prevents writing the loaded packages set to the cache. For example, if there were errors loading the packages this helps to avoid the situation when an incomplete packages set would be reused even after fixing the error condition.

Caches the information obtained by the so that to quickly retrieve for starting up the host without scanning thru their files.

The place for this data. WAS: wave-specific. NOW: in the shared dir, since its filename is already unique, and there is no need to make it per-wave.

Loads the cache from the memory dump. Validates what it can (e.g. header and bindir path match).

Validates that the memory dump has been created with this same bindir. Defines the throw/canbenull behavior.

Tries to load the cached data for the specific bindir.

Identifies the bindir, plus possibly some filtered view on it.

Tries to load the new cache file for the , from its location in Local App Data given by its .

Makes new cache file content off the , also writes there the to check when loading.

Writes the new cache file for the Product Binaries Dir of , to its location in Local App Data given by its .

Makes sure that the end of stream (= next write) is aligned by a multiple of the given number of bytes. Useful for reading UTF-16 strings in the binary file (they must be aligned by WORD). Even more useful if you're about to map the file into memory, then many functions like to have their pointers WORD or DWORD aligned. Or reading unaligned structs might come out deadly slow.

Format marker.

RVA to the catalog tables. TODO: Format.

RVA to the serialized build-time components (all such collected from all the packages).

RVA to the identity of the deployed packages set cached in this instance. Format: a serialized version of . This is to validate that we're not colliding over the same hash.

Filters subplatforms (=packages) whose DLLs are considered for caching and cataloging in this folder. NULL means take em all. A specific value means that only the package which has this DLL and all of its referenced packages (transitively) should be taken.

Discovers the set of available Deployable Packages, e.g. the ones in the installdir, per-session supplied additional packages coming from plugins, and so on. Gives the set of what should be running. Produces the .

Discovers packages, using an installdir (ProductBinariesDir as installer output or a local build output) as the main source.

An installdir (ProductBinariesDir as installer output or a local build output) as the main source. Additional options and sources. The identity, which also serves as a file list for the host to load into the container.

Reads the environment variable (see for possible names) to add more package sources.

If a nuget package is encountered in any source, it would be expanded and loaded automatically.

If a nuget package is specified by its ID and Version, it would be retrieved and expanded and loaded automatically.

Keeps track of specific locations where deployed packages have been discovered. For instance, this implementation gets created by and submitted to the cached host components to make specific per-package-origin resolve available for them. That's the main way of getting this available at Shell runtime.

Keeps paths as strings so that to avoid parsing at load-time — delays till it's used.

Assumes all are in the same directory.

Incapsulates calculating the identity for . An identity uniquely describes the discovered set of packages, per folder, their set, and their content. Any packages related data could be cached keyed with this identity. This allows telling cache files for different contexts from one another and also to checking if the cache is still up to date or should rather be recalculated.

Assert when referenced packages are missed for these runtimes only.

LWTime of the folders which took part in collecting the stuff. Modified folder lwtime might mean that some items could have been added to the folder.

A hash to be used as the cache storage key. As with a regular hashtable, the full identity should be checked after looking up by hash, but it's not expected to clash any often.

Nuget packages which have been added by giving the package ID and version, and are to be retrieved by the loader.

Writes out the identity data into a BLOB.

Identity-significant attributes of a file: full path, timestamp (UTC last-write-time), and the byte size.

Data on each folder scanned for discovery.

Package metadata — runtime-only metadata which does not exist on disk but has been added e.g. as items.

Nuget packages which were discovered in the scanned folders in the package file form (were not pre-expanded).

Files with package metadata — those which are in the already-expanded form in the folders. Files from nugets expanded by the loader are not listed here.

Lists all of the module (dll/exe) files in the folder. Used to derive the identity from their timestamps. Files from nugets expanded by the loader are not listed here.

The package object (must be present in the ). The storage with metadata, including , the cached part catalog, and any other components. The package object (must be present in the ). The storage with metadata, including , the cached part catalog, and any other components.

The package object (must be present in the ).

The storage with metadata, including , the cached part catalog, and any other components.

In-depth loader of the Deployable Packages info needed for runtime. Uses the basic info fetched by .

Loads the data, no caching.

Lifetime of the data structures in the object returned. What's been discovered for loading. Optional diag. The loaded deployed packages (and catalog tables in ready-for-use form). The binary dump from which they were loaded (good for caching).

Package components from all the packages.

Assemblies which ain't got precalculated catalogs in their packages' metadata (or if they've been modified since) get cataloged here.

Tracks locations of expanded packages for lookup at runtime.

Assemblies which should be loaded, and which might not be present.

Optional object for testing and diagnosing this instance.

Empty on input, collects info on nugets autoexpanded during the loader run.

When deployed packages are -cached data for disk-based master assembly binder, such as where it should be able to resolve assemblies from, and which assemblies are OK to be skipped.

These assemblies are OK to be missing at runtime (e.g. when walking the catalog).

The binder should use this list to bind assemblies to backing disk files.

If a Nuget package is given as an input for loading Deployed Packages, it requires to be expanded into the local files before being loaded. This class does the expansion. TODO: expiration and autocleanup, probably means tracking the use TODO: self-validation that the data has not been corrupted

Expands packages onto disk, each one into a separate folder, but otherwise the same way as the installation would do (except that the installation originally writes them to the single folder).

The set of packages to expand in parallel. Optional. Allows to override the standard expansion location with a custom one, e.g. for isolation. Handles errors.

Full package with additional metadata, for autoexpanding.

Optional. Additional identity of the package. It's been observed that some build chains are violating the rule that the nuget id should be unique per its content, so getting the same file-based package might not mean that we could share it with another of the same ID. In this case other properties of the disk-based file provide the extended identity here.

The pkg with content, also gives the pkg id.

Name for the expand dir, considering the additional identity, if available.

Gets the deployment directory of a package by its identity. For instance, the implementation of gets created by and submitted to the cached host components to make specific per-package-origin resolve available for them. That's the main way of getting this available at Shell runtime.

Gets the deployment directory of a package by its identity.

Whether activator is enabled.

True if enabled

Whether requested zone is enabled

Type of the zone True if zone is enabled

Marks a component to run in the Environment container. DO NOT use unless you know the specific reason. The default container choice in absence of other considerations is Shell. The Environment container runs thru the life of the application host (VS, standalone, etc) and starts the Shell container with the products inside (zero or more times if it restarts or suspends). Originally, the purpose of the Environment container (and the reason this additional level appeared) were to serve Visual Studio requests even when Shell has not started yet or has been suspended. This is out of scope since we dropped support for VS9. Today, its task is to start the Shell, gather context for starting the Shell, and check conditions for starting the Shell (such as licensing, suspended state, etc), plus some early init. It should be as lightweight as possible to either start the Shell ASAP or keep a low profile when #R is suspended. By default, all environment components are not thread-bound and not created automatically. Implement the interfaces you need to serve. If your component absolutely needs to run automatically, provide one of the family interfaces, and it will be instantiated at the corresponding phase. Write your reasoning for auto-creation in a comment.

Holds the product's pre-Shell for running the Environment, already filtered down with Environment zones.

All zone parts in part catalogue

All immediate successors in zones graph

All immediate predecessors in zones graph

immediate successors in zones graph which are derived type (not IReguire)

Call when trace is enabled, tracks how negative zones are propagated.

Gets the attr of type on the zone, if it got one.

Gets feature info for a module zone, extracts from the attribute.

Call this method if you would like the standalone application to shut down.

Shell level component simular to , but the requests to shutdown always be executed on the frontend side of the application Shell level component simular to , but the requests to shutdown always be executed on the frontend side of the application

Holds the outermost catalog set for the class.

Lists all of the product assemblies registered with this host. This generally includes all installed JB products and all static plugins. The will be initially created on these, and other catalogsets will be a filtered-down subset of these assemblies. Lightweight plugins might be loaded dynamically and added to the part catalog set later, but major plugins go in this pack already.

Common extension methods over items, suitable for any apps on any runtimes on any OSes.

Runs on a set of product packages as discovered in the actual Product Binaries Dir, extracted there in a flat manner. Applies appropriate caching for per-package components and the common part catalog. Starting with wave04, this is expected to be the main way of running the shell.

The dir with extracted packages. Lazy, to ensure any exceptions in getting it are trapped. Filters subplatforms (=packages) whose DLLs are considered for caching and cataloging in this folder. NULL means take em all. A specific value means that only the package which has this DLL and all of its referenced packages (transitively) should be taken.

See , this method just takes the folder of the given assembly as the . The assembly is supposed to be the entry point assembly which has the Main function and which you are calling us from.

Runs on a set of product packages as discovered in the actual Product Binaries Dir, extracted there in a flat manner. Applies the appropriate caching for per-package components and the common part catalog. Starting with wave04, this is expected to be the main way of running the shell.

Lazy-inited when we're asked for the env part catalog.

The dir with extracted packages. Lazy, to ensure any exceptions in getting it are trapped. Filters subplatforms (=packages) whose DLLs are considered for caching and cataloging in this folder. NULL means take em all. A specific value means that only the package which satisfies this filter and all of its referenced packages (transitively) should be taken.

When there's no serialized info to run the build, but we have a set of locally-installed packages unpacked into a folder, collects the info on such packages for the app to run on these assemblies. Alternatively, the serialized info is submitted with directly as component implementations. This is the legacy no-caching version which builds the part catalog each time over the set of files available, and does not support AdditionalDeployedPackages.

The dir with extracted packages. Allows to run on a subset of the total set of packages located in the folder. Allows to modify set of packages found in the folder

Adds self to the logger, removes when this object is disposed of.

Adds custom object.

Adds a custom component to the host. Takes a functor instead of an object to discourage from executing code when writing the host chain, which usually has no loggers/reporters to handle the exception yet.

Takes the command line from and makes available as / .

If non-NULL, this set of args would be used as the instead of . If NULL, will use .

Takes the command line from and makes available as / .

If non-NULL, this set of args would be used as the instead of . If NULL, will use .

Fills the default product info components, as required for running the application.

Gets the zone as type, if it's already available at creating the object.

Gets the zone as a runtime type. The will be created when this mixin is queried for the value because at that point the catalog set is available, and it's possible to look up the zone's PCType in a more efficient way.

Asserts that the environment is started and stopped in a guarded context.

Injects HostInfo into the component container.

Extracts HostInfo from the SerializedValuesResolver. Applies fallbacks.

Extracts HostInfo from the SerializedValuesResolver, tries to read the RootSuffix from the bindir. Standalone applications have no RootSuffix in their serialized HostInfo, and that's the only way to get RootSuffix.

Does not show exceptions to the user. Used in Production Mode when we shouldn't be showing the exceptions to the user.

Inits just to some logger.

Safe to run on any runtime, but needed only on WPF-WinForms application. TODO: move out into a UIInteractiveWPF env component when we get off the Avalon Dispatcher by default, depend on this component in anything which wants to show UI in env before starting Shell, make Shell start depend on it

Early on app startup, adds trap for generic .NET unhandled exceptions.

Gets whether host startup has registered any traps.

Installs all exception traps for the lifetime duration. Done by mixin in its init phase.

When there's no serialized info to run the build, and we have not created packages to be extracted into the BIN folder (like we do for running tests), tries to make up a mock package for running the app from whatever DLLs can be located in the folder. This is a fallback scenario, use or whenever possible to run off the real packages. This scenario is to be used when you can't run the Local Register phase of the build (for example, when debugging the build itself;).

The dir with scattered DLL and content files. Leave NULL to use the home directory of the currently-executing assembly (assuming others are by its side). Allows to run on a subset of the total set of files located in the folder. The default filter limits files to immediate children of the folder only. The dir with scattered DLL and content files. Leave NULL to use the home directory of the currently-executing assembly (assuming others are by its side). Allows to run on a subset of the total set of files located in the folder. The default filter limits files to immediate children of the folder only.

Runs message pump for the main product's message loop.

Before final exceptions are logged, makes sure any deferred things are reported.

Exposes all serialized components to the runtime.

Writes text to StdOut on app startup. Useful for console apps.

Pre-factored text. Use another overload if you got any code which might cause exceptions.

Defer-calculates the text. This allows for catching any possible exceptions in string building.

The “Don't care” choice. Also the default value of the enum.

A bit earlier than defaults.

High-priority tasks, but with all natives and fallback exception reporting already in charge.

Initializing native stuff in the host, which must happen before major managed subsystems are loaded, like WPF / WinForms. Refrain from actions involving loading of large managed subsystems in steps prior to this.

Initializes pumping out all of the leftover deferred actions on shutdown.

Installs the fallback exception reporter — a primitive one which makes early-in-startup exceptions known, before the real exception reporter gets installed. In interactive GUI hosts this is a simple message box. MUST NOT use any WinForms / WPF code, just native stuff. Nor anything else which might affect the step.

A bit later than defaults.

Allows to add custom components to the host container, at the very top level (fixes into the Env container resolve).

Called when you're to add components. Either call Register for an object, or RegisterResolver for a custom resolver, or you can even add descriptors.

The container to modify. The catalog set over which the component is being constructed. We can't retrieve it from the catalog itself because it has not been composed yet at this point, though technically it would have been the preferred way. // NOTE: this param is a hack, but the best effort to resolve the VS service provider wrappers autodiscovery

Determines the environment zone (from the family) to be used for running the app.

The complete catalog set, as collected from the products currently known, plus their plugins and any parts introduced later. This is the origin of all the catalogsets in the component containers. It's not filtered yet, even by the environment.

Marks the base requirement for all mixins.

Create with End() at the end of the host parameters chain.

Add any additional information on the host here: VS Service Provider, main window, command line, etc. Environment components and product components will be chained into this container and will be getting this information.

Base Windows application host init, stuff specific to both non-interactive and interactive Windows NetFX hosts.

Meta-interface defines zones which should be activated for shell container. Use with .

Common nongeneric interface for , .

Meta-interface defines zones which should be activated for shell container. Use with . As compared to , adds a callback which can decide dynamically on Environment container startup on whether to activate the zone or not.

Support for conditional activation.

A companion interface for , also used on zone activators marked with , but optional. If applied, means the activator would be turned off if any of the zones mentioned by is explicitly turned off.

Previously, were used in place of this interface, and it were used for two needs: (1) zoing the activator component itself on whether it's visible in the catalog, if it's a environment zone; (2) marking dependent zone for user-disabled features, if a Shell zone. Now these have been separated: a requirement governs zoning of the activator, and this interface does the user feature disable dependencies.

Call this method if you would like the standalone application to shut down.

Meta-interface defines zones which should be prevented from activation in the shell container. Use with .

Meta-interface defines zones which should be prevented from activation for shell container. Use with . As compared to , adds a callback which can decide dynamically on Environment container startup on whether to activate the zone or not.

SuppressMessage("ReSharper", "UnusedTypeParameter")]

Represents the environment-specific host that can load our products and make them running. For example, there's a VS-host (single per products that share the same shell, ideally one per VS if versions are close), Tests host, etc. The host creates the shared environment, into which products can be loaded (by advertising "IApplicationDescriptor" to its known products list).

The environment, which creates and hosts environment-level components.

Defines a lifetime in a guarded context which will be terminated in a guarded context. Returns a lifetime definition whose termination should be initiated in an unguarded context.

An outer lifetime. MUST be terminated in an unguarded context. Identifies all the created lifetimes / guard contexts. The guard to use. Argument for the closure. Executes guarded. The given lifetime will be terminated guarded. A definition which you should terminate in an unguarded context.

Attempts to pump out all of the leftover deferred actions.

Runs the standard message loop for interactive hosts. When the function exists, the host should shut down.

The final verdict which caused the host to stop running. Use it for determining the exit code.

Nobody remembers, but it seems to force all finalizers to be executed and all assertions like EnsureEverTerminated to be reported (see RSRP-490524).

A handler which determines whether the particular product is allowed to be run. There are standard handlers for: license check, suspended state, timebomb, etc. Of all the registered handlers, they get asked in order of priority until any of the handlers gives a negative reply, which yields a negative result and stops polling other handlers. Note that the reply is not a scalar but a live value which can later change. If all of the handlers give a positive reply, the product will be started.

For priority of your handler see for standard values. The lower the value, the sooner your handler gets asked.

This method is called on your handler when the poll sequence reaches it (i.e. when all of the higher-priority handlers give an affirmative resolution). The is the duration until polling your handler goes out of scope (i.e. either the whole setup is terminated or one of the higher-priority handlers changes its resolution to something non-affirmative). After the is terminated, your resolution in the return value will be considered no more. If the poll sequence reaches your handler again, you'll get one more call with a new lifetime. The return value is your live verdict which you can change at any time within the .

The instance of the application environment. The host application (VS, standalone exe, etc) creates one environment, then loads the products into it.

Mainly saved for running the main pump from it later.

Creates the environment and defines its lifetime.

Defines the environment to be created: the set of assemblies with components, the configuration, additional runtime components, stuff to be created before composing the env container, and so on.

Configuration of this environment. Defined by the host when the environment is created. This includes environment zones chosen by the host starting the environment, like VS version-related zones in VS or the main env zone of a standalone app, plus a number of runtime-inferred zones for CPU, .NET runtime kind, etc. This list only has those zone types given when configuring or detecting, not their base types which might also be zones, those are added later when starting the containers.

Gets the environment component container. It is already created and able to serve component requests (subject to threading policy) upon leaving the class ctor, though its asynchronous construction might still be running, and active until the lifetime ends.

Catalog set for the environment components, as narrowed down from by applying the environment configuration filter to the parts. Do not modify.

A special method for non-continuous hosts, like the tests host, in which creation and destruction must be carried out on different stacks.

Get the Shell container, when the Shell is allowed to run and composes its container. When the Shell is not running, the property has a NULL value. Note that Shell might start and shut down zero, one, or multiple times within the lifetime of this environment, and that would be a new instance each time. You can get this property on any thread. Its values will only change on the main thread and under a guard.

Runs the main message pump for the duration of the app life, until any handler gives a permanent negative resolution. This would shut down the Shell and exit the pump. The Environment and host mixins would be terminated when you terminate the Environment's lifetime. While this pump is running, Shell might be shut down and restarted multiple times (by a temporary negative reason from a handler). This pump uses the specialized mixin-provided pump, such as the MSO Component Manager's Message Loop, if available — as opposed to running a pump manually.

Lists the zones which are available in the environment assemblies.

Creates the configuration object on the given host configurations, adding the well-known standard environment configurations, such as CLR version and CPU. On this early stage, the

The catalog for fetching configuration definitions. Module zone which specifies the configuration against the module zone axis. This will be combined with autodetected environment configurations from to choose the environment components. Further configurations for running the Shell will be determined by environment components.

Gets a union of standard configurations of all the possible environments.

Gets the standard configurations for the current environment, like CLR version and CPU.

Gets the configuration of the CPU architecture of the current process (not the OS architecture nor physical CPU). Examples: IntelCpu, Amd64Cpu.

Gets the configuration of the current OS (WinNT, Linux, etc).

Gets the configuration of the current Clr implementation (Framework, Mono, Core).

Gets the configuration of the current runtime (CLR version).

Prepare cached zones info before shell container composition. Call it each time shell container is about to compose so it can recompose with different allowed zones set.

API for spawning hosts. Start with the property and proceed along the host creation chain with ext methods, until you can with an ext method on the end of the chain.

Starts the host creation chain. Call ext methods to proceed further by the chain.

Standard sets of JetHost items for commonly used cases.

Hides from .

Completes the host creation chain by running the host, environment, and Shell, and returning the result after it exits. See for a breakdown on what happens within this method.

Puts the host parameters to use by starting the host, but not running its main message pump. This is required for hosts which have to do these steps separately: 1) Init (this method). Exits when the Environment container has already started its creation, but is not yet completely initialized. 2) Running (by calling , or, less preferably, pumping on or its underlying OS transport, which would not support some of the scenarios). This will complete the init and start the Shell, if configuration allows for it. When handlers give a permanent shutdown, the method will exit. Shell might be shut down and started again multiple times within the run, if handlers give a temporary shutdown. 3) Shutdown (by terminating the ). You should clean up the environment after exits, in which case Shell is already shut down and only environment components and host mixins would deinitialize. If pumping manually, you can stop pumping and shut down at any time, in which case this might also shutdown the Shell and anything in it.

Adds one more item to the host parameters (after the mandatory part of the chain is complete).

Removes items by their base type from the host parameters (after the mandatory part of the chain is complete). Usually, to replace them with new items (see ).

Removes items by their base type from the host parameters and replaces with a new item (after the mandatory part of the chain is complete).

Completes the init chain of the host parameters.

An item in the host creation chain. Adding more info proceeds to the next step in the chain. This is the first empty step.

An item in the host creation chain. Adding more info proceeds to the next step in the chain.

An item in the host creation chain. Adding more info proceeds to the next step in the chain. This is the last full step.

Base class for the host creation chain.

An item in the host creation chain. Adding more info proceeds to the next step in the chain.

Environment-level component that provides list of it has license for plus zone parts that do not require license and are used from the zones it enables. The component is signed with private key corresponding to public key of the zones it enables.

Fully quilifed type name signed with private key corresponding to zones' public key. Empty if no license-requiring zone is enabled.

Use the attribute to mark payed zone (zone that requires valid license to be activated) with public key. Public keys should be generated using LicenseGenerator tool. Several keys are alowed. The zone is enabled if any of licensed provides corresponding signature.

Used to generate/validate zone signatures. See https://jetbrains.team/p/net/repositories/dotnet-licensing/ for more details.

Base interface for environment lifecycle, has no meaning on its own, but you can find everything else in its inheritors.

Contract: your component MUST be auto-created (even if nobody requests it), and it can wait a bit while startup activities settle down. A perfect component only creates on-demand of course, but if you need it autocreated, this is the most graceful option. Even if the Shell decides not to start (suspended, no license, etc), Environment still MUST auto-create your component.

Contract: your component MUST be auto-created (even if nobody requests it), early on startup around the time Shell begins to start. Starting the Shell won't be delayed to wait for your component. You MIGHT observe any Shell components created sooner that your component. If you need strong guarantees, look for , but that one would impact startup time of business logic components. Even if the Shell decides not to start (suspended, no license, etc), Environment still MUST auto-create your component. Your operations would share CPU/mem/disk with starting product features, so consider if it can be further delayed to .

Contract: your component MUST be instantiated by the Shell Starter before (and if) starting the Shell actually begins, as it is implicitly needed for running the Shell. If the Shell decides not to start (suspended, no license, etc), your component MIGHT be never created. Use sparingly, since anything executed on this stage delays the process of starting the Shell itself, and that is the critical task. You SHOULD try making your component on-demand, so that it is created only when someone requests it. If impossible, you SHOULD consider using / if it's not absolutely necessary to delay Shell by your component's operations. If your component is directly required by shell starter, like or or something transitively used by them, then you SHOULD NOT mark it with this interface because that would be redundant and misguiding.

On this level, should check if the env is fully initialized for starting the product (and calling other checkers). Eg in VS this is when VS' Shell gets into the non-zombied state.

On this level, should check for any user-induced deactivations of the product. Eg in VS it's when a user suspends a product.

On this level, check for a license.

The resolution part of the .

Affirmative resolution: this handler doesn't object running the product. Next handlers will be asked if they also don't have any objections.

Negative resolution: this handler prohibits the product from being run. This is a veto, i.e. next handlers will not be polled. “Temporary” means that the handler is committed to resolve to either affirmative or negative-permanent state somewhen soon. An example is shutting down the product to immediately restart it with another licensing options. A standalone product should not be shutting down with such an active resolution. For a VS-integrated product, this is the same as a permanent negative resolution.

Negative resolution: this handler prohibits the product from being run. This is a veto, i.e. next handlers will not be polled. “Permanent” means that a standalone product might shut down when it sees such a resolution. A VS-integrated product will just be deactivated. “Graceful” means this state is not unexpected. For example, closing the standalone application main window or suspending a VS-integrated product is a graceful shutdown.

Negative resolution: this handler prohibits the product from being run. This is a veto, i.e. next handlers will not be polled. “Permanent” means that a standalone product might shut down when it sees such a resolution. A VS-integrated product will just be deactivated. “ByError” means this state is reached due to some problem like a failed startup or an invalid product license.

The verdict of a single handler.

The resolution (to make a decision on product).

Comment on the resolution. Optional. Highly recommended with non-positive resolutions.

Error code of the resolution. Useful for command-line tools. Highly recommended with non-positive resolutions.

0 means no error

Gets whether the resolution is affirmative.

Whether it's one of the permanent negative resolutions.

Whether the overall application run is considered as failed.

Gets whether the standalone application host should be still running.

Gets whether the product shell should be started.

Gets whether the standalone application host (NOTE: this is not the product shell with components, but the host) should be still running.

Gets whether the product shell should be started.

The core method for running an automated application. Its method is called after the Shell is started up, waited upon, and the application exits when the method exits, using its return as the process exit code. You can import components as method parameters.

For each given product, monitors its validators, and reports to when the product can be started.

Whether the product Shell is allowed to run right now (Success means it can be started or continue running; Failure means it cannot be started or has to be shut down if already running; Permanent means that a standalone host should also be terminated).

Apply invariants to the active state of the tellers, then update the property.

When the Shell container is started, allows to get it on the environment level.

Watches if the product is allowed to run (). If yes, starts the Shell container.

Gets the zones which would normally be running in Shell but have been suppressed by timebombing of their package, or dependency package, or because of timebombing of their activator's package.

Runs the product. The lifetime start and end must be guarded & locked.

Gives out the configurations the product is running in. Published as a product-specific component on the Shell-level.

Called by when it sees timebombed zones.

Looks for static methods with . If found, executes them and shuts the app down.

Gives out the product's main of the running Shell. Available for import in Shell.

Shell is not started or terminated

Shell is starting

Shell is started

An annotation which must be by convention present on environment-level activator classes implementing or .

Whether zones are calculated in

Attaches to the exception reporter, dumps to TC.

A module-initializer method in class which inherits module initializer from Core project will force loading Core module and invoking module initializer from there.

Shell-level zone indicates that the feature does not support working in Visual Studio in OOP mode Should be used to mark features and products which are not currently supported in OOP mode.] Always activated, is is only a complimentary zone Configurable feature, unchecking it in Products and Features used as a flag to start in OOP mode

Launcher for base app entry points. The full standalone app has its own launcher in its project, because it references more stuff.

The console entry point for calling from the native part. Expects to have the partial set of components written in resources, like host name and environment zone, while the set of the application packages is collected ad-hoc based on what's found in the application folder.

The exit code for the process.

The console entry point for calling from the native part. Expects to have the partial set of components written in resources, like host name and product branding, while the set of the application packages is collected ad-hoc based on what's found in the application folder.

The exit code for the process.

Refer to this if you need to get the for the method of this launcher.

Registers the native component manager on startup of the Windows application.

All mixins in the same process should share the same native component manager instance, because two cannot be installed at a time. This static is no more than per-appdomain of course, but for now that's good enough. Ideally, this should be handled on the native side, with the second attempt just returning the already-installed instance. With the current impl, we can only see that there's a native pointer to some instance, but cannot tell if it's ours or a conflicting one, I guess. So keeping the sharing on the managed side within the wave07 time frame.

For running a TeamCity Host.

Picks the minimal set of the Build Runner Core assemblies from the available subplatform packages and their references.

Makes a packed executable with the Build Runner Core assemblies inside.

VS Extension manager registry key in HKCU under VS root key.

VS Extension manager registry key for registered user extensions.

VS Extension manager registry key for the types of registered user extensions.

A Registry value name under the root VS Registry Hive key in HKCU which has to be touched on VS11 to signal that configuration has to be rebuilt.

A Registry value name under the ExtensionManager key in HKCU which has to be touched on VS11 to signal that configuration has to be rebuilt.

A Registry value name under the ExtensionManager key in HKCU which allows per-user extensions to be loaded when VS is started as administrator.

A registry key under config hive containing PkgDef cache related info.

A registry value under the %VsHive%_Config\Initialization key containing the timestamp of PkgDef cache.

A registry value under the %VsHive%_Config\Initialization key containing a list of folders to exclude from PkgDef search.

VS11+. Try to touch the special file which means that configuration has changed, otherwise VS won't re-read its extensions for any updates.

VS11+. Reset VS flag which means that configuration has changed, otherwise VS won't re-read its extensions for any updates.

Registry hives in terms of Visual Studio.

Visual Studio registry HKLM (Config) hive. Example: “Software\Microsoft\VisualStudio\16.0_fe2455e3_Config”.

Visual Studio registry HKCU hive. Example: “Software\Microsoft\VisualStudio\16.0_fe2455e3”.

Extension identifier (goes to the Identifier field of the Extension, used to identify it eg in VS Ext Man Registry). Pattern: $(CompanyName).$(ProductName). Example: JetBrains.ReSharper.

The exact version of the extension, as written into its VSIX manifest. Pattern: $(ProductVersionMajor).$(ProductVersionMinor). Example: 5.5.20190327.

The full extension identifier includes name and version. Example: JetBrains.ReSharperPlatformVs15,9.0.20190327.

VsRegEdit.exe is a VS15+ command line tool which performs registry operations on VS registry detours (aka privateregistry.bin).

Known issues: 1) VS 2017 15.2 Release. Does not have Suffix parameter. 2) VS 2017 15.3 Preview 7. Have Suffix parameter but does not process it correctly (does not include suffix in the registry key). 3) The Remove value operation always returns code -1, even if it's successful. 4) Cannot read/write Qword values. 5) Cannot create registry key. >

The executable is located in the VS bin folder (Commot7\IDE) beside devenv.exe.

Reads the value off the specified key. VsRegEdit.exe read PathToVs [Suffix] Hive KeyName ValueName ValueType

Sets the specified value name to the value type. Use @ as the name to set the default value. Creates the key if it doesn't exist already. VsRegEdit.exe set PathToVs [Suffix] Hive KeyName ValueName ValueType Value

Removes the value from the key. VsRegEdit.exe remove PathToVs [Suffix] Hive KeyName ValueName

Deletes the specified key. VsRegEdit.exe delete PathToVs [Suffix] Hive ParentKeyName KeyName

An entry in the GUID Store.

GUID value of this entry.

Whether this GUID is exposed as a #define constant to the involved programming languages (mainly, WiX).

WiX hits the command line length limit if we expose ALL of them, but it actually needs only a few.

Key to this entry. Must be unique throughout the dictionary.

Key to the GUID in the GUID Store.

Gets the name of the key. This is the only key identity.

Determines whether the specified is equal to the current .

true if the specified is equal to the current ; otherwise, false. The to compare with the current . The parameter is null.2

Serves as a hash function for a particular type.

A hash code for the current . 2

Returns a that represents the current .

A that represents the current . 2

Indicates whether the current object is equal to another object of the same type.

true if the current object is equal to the parameter; otherwise, false. An object to compare with this object.

Knows how to switch between s and s.

Returns whether this converter can convert an object of the given type to the type of this converter, using the specified context.

true if this converter can perform the conversion; otherwise, false. An that provides a format context. A that represents the type you want to convert from.

Returns whether this converter can convert the object to the specified type, using the specified context.

true if this converter can perform the conversion; otherwise, false. An that provides a format context. A that represents the type you want to convert to.

Converts the given object to the type of this converter, using the specified context and culture information.

An that represents the converted value. An that provides a format context. The to use as the current culture. The to convert. The conversion cannot be performed.

Converts the given value object to the specified type, using the specified context and culture information.

An that represents the converted value. An that provides a format context. A . If null is passed, the current culture is assumed. The to convert. The to convert the parameter to. The parameter is null. The conversion cannot be performed.

Well-known values for .

Represents a store of GUIDs keyed by strings.

Namespace guid for , see for details.

If specified to a non-empty string, turns on fallback behavior for missing GUIDs: those are silently generated with

A GUID value with its key.

For GUID values whose keys were missing from the store, new entries are emitted into this collection, so that they could be moved into the main collection by the operator.

Tries to get an entry by its key. Throws if missing.

Tries to get an entry by its key. Nulls if missing.

Tries to get an entry by its key. If missing, adds a new entry to the collection, and returns an empty (but still non-Null) GUID.

We know metadata for a certain package on the Web source, will retrieve body on-demand, and metadata is available beforehand.

can't change type of this field for compatibility reasons

this must be 0 for VS prior to VS 2015

When we have a ready local (read directly from installer pack resources for example).

All immediate successors in graph

All immediate predecessors in graph

Immediate successors in zones graph which are derived type (not IReguire)

Keep in sync with .

An enumeration of possible macro names, is not used directly in the XML files, but instead serves as a reference info or string constants from the code.

Location of the Package assembly.

The System directory. Used to locate the mscoree.dll that is the COM Server for us.

The directory that contains the product binaries.

Date and time at the moment the macro is resolved, in an arbitrary format. Use with care, because the date-time might resolve at the installation time on the user machine. The format is not defined. Fits for producing generation numbers.

A directory to which the product is built; contains all of the product binaries. Warning: when doing a local install, this is the same as the target InstallDir.

References directories of the product and its submodules. The product references directory is “/Lib” under the product root, and module's references directory is “/Lib” under the module root. Deployment code of each module can only use references from its own module and any modules it depends on, transitively; plus, the product references directory. The file must be unique by its path relative to the references folder throughout the product. Any conflict results in a failure.

Binaries installation directory on the remote system (the Bin folder).

The directory that contains the program groups (the Start menu) for all users or the current user, depending on per-machine/user installation.

Per-machine: VS installation directory that contains the "devenv.exe" executable file (the Common7\IDE folder). Per-user: VS hive root directory in LocalAppData that contains "privateregistry.bin" registry detour file.

A single satellite file in the installation.

An installation of a file whose source name (on the source file system) and target name (on the target file system) are different.

The source file to be deployed on the target system. Name for this file on the target file system. If omitted, the name of the source file will be used.

Any additional metadata on the files.

The source file to be deployed on the target system.

Determines whether the specified is equal to the current .

true if the specified is equal to the current ; otherwise, false. The to compare with the current . The parameter is null. 2

Serves as a hash function for a particular type.

A hash code for the current . 2

Compares the current object with another object of the same type.

A 32-bit signed integer that indicates the relative order of the objects being compared. The return value has the following meanings: Value Meaning Less than zero This object is less than the parameter.Zero This object is equal to . Greater than zero This object is greater than . An object to compare with this object.

Indicates whether the current object is equal to another object of the same type.

true if the current object is equal to the parameter; otherwise, false. An object to compare with this object.

Allows to modify ACLs when installing a file. This info is written to field on an .

entry key for files that should have ACLs specifically modified upon deployment.

Proceed with the installation if this ACL fails to set.

Only applies to OS versions of this and newer. Null for no limit.

SID or username for which to modify ACLs with this entry.

Access rights to assign.

Subject of the entry

Base class for all of the files installed to the target system by the Installation Data items.

Sets the name of the file item on the target filesystem.

The local name of the file on the target system. If left empty, will be the same as the source name. Must be left empty if the source name matches more than one file.

Determines whether the specified is equal to the current .

true if the specified is equal to the current ; otherwise, false. The to compare with the current . The parameter is null. 2

Serves as a hash function for a particular type.

A hash code for the current . 2

Compares the current object with another object of the same type.

Indicates whether the current object is equal to another object of the same type.

true if the current object is equal to the parameter; otherwise, false. An object to compare with this object.

Folders that contain files that should be installed on the target system. In MSI, they create Directorys and Components.

An ID for this folder entry, from which the component, folder and file IDs in the installation database are derived.

Relative path from the specified root to the directory on the target system.

One of the root folders to locate the file on the target system.

Adds a new file of type .

Adds new files of type .

HKEY_CLASSES_ROOT.

HKEY_LOCAL_MACHINE.

HKEY_CURRENT_USER.

HKEY_LOCAL_MACHINE or HKEY_CURRENT_USER, depending on whether the installation is per-machine or per-user.

Base class for installer Registry keys and values.

Creates a object.

Hive. Path to the key under the hive.

The Registry hive.

Path to the key.

Gets the proper Windows Registry root key.

Compares the current object with another object of the same type.

Registry Keys to install and then REMOVE when uninstalling. A registry value does not require that you write its parent key here. Write a key if you'd like to make sure it will be removed by uninstall. For that matter, do not add foreign keys (eg Visual Studio ones) into which we're writing our values.

Creates a object.

Hive. Path to the key under the hive.

Creates a new Registry Key under the current Registry key.

Relative path of the nested Key. The new registry value.

Creates a new Registry Value that derives its Hive and Key path from the current Registry key.

Name of the value. Value of the value, must be either a or an . The new registry value.

Returns a that represents the current .

A that represents the current . 2

Compares the current object with another object of the same type.

Represents a value to be written to the Registry. On uninstallation, the value will be deleted. It is not necessary to have a key element for each value, unless you want it to be deleted upon uninstallation.

Creates a object.

Hive. Path to the key under the hive. Name of the value. Value of the value, must be either a or an .

Specifies that the value should be written on registration and left intact on unregistration.

Name of the value under its key, or an empty string for the default value of the key.

Type of the value, which determines the type of the Windows Registry value to be created. The Value must be formatted accordingly.

Value for the value.

Returns a that represents the current .

A that represents the current . 2

Compares the current object with another object of the same type.

Lists possible types for the Registry values.

An integer DWORD value.

A string value.

Binary hex-encoded value

An advanced installation task which alters the contents of an installed file on the target system. It takes a regular installed file as a source, reads its text, applies the transformation, and writes to the new location on the target system.

Specifies the file text encoding.

Relative path from the root folder to the folder on the target file system in which the original file for patching the text is residing.

Local name of the original file for patching the text (under ).

Root folder on the target file system in which the original file for patching the text is residing.

Escapes a full string literal (a data name or a data value of type string) for use in pkgdef files. Surrounding quotes are not totally required, only if there're spaces, but they won't do harm.

Does mid-string escaping for use in pkgdef — means this is a part of the string and quotes should not be added to it.

Standard macros which could be used in files when replacing their text. The string representation of the macro reference is $()-surrounded text representation of the enumeration member name. Has various macro versions for different escaping, with trailing backslash or not.

Installs a shell link (an .lnk file shortcut). Its and parent folder's / point to the place where the shell link file will be created (.lnk), while the // point to the target the shell link will be referencing. The source information on the parent is not used for the shell link.

Sets the name of the file item on the target filesystem.

Name of the shell link file itself on the target filesystem. Root folder on the target file system this Shell Link will be pointing to. Note that this is not the location of the shell link (.lnk) file itself. Relative path from the root folder on the target file system this Shell Link will be pointing to. Note that this is not the location of the shell link (.lnk) file itself. Name of the file on the target file system this Shell Link will be pointing to. Note that this is not the location of the shell link (.lnk) file itself.

Relative path from the root folder on the target file system this Shell Link will be pointing to. Note that this is not the location of the shell link (.lnk) file itself.

Name of the file on the target file system this Shell Link will be pointing to. Note that this is not the location of the shell link (.lnk) file itself.

Root folder on the target file system this Shell Link will be pointing to. Note that this is not the location of the shell link (.lnk) file itself.

Determines whether the specified is equal to the current .

true if the specified is equal to the current ; otherwise, false. The to compare with the current . The parameter is null. 2

Serves as a hash function for a particular type.

A hash code for the current . 2

Indicates whether the current object is equal to another object of the same type.

true if the current object is equal to the parameter; otherwise, false. An object to compare with this object.

A placeholder build helper to ensure some helpers are always registered for the interface, and resolve succeeds for them.

The root element of the product installation data.

Gets the list of folders with files to install.

Local machine executables to run elevated on register and unregister.

Gets the list of folders with files to install.

Msi-es with shared installation strategy.

After all the installation data is collected as , applies transformations to it which cannot be implemented by populating the installation data in the regular additive manner. After all the transformation, the is ready for execution.

Installation data after all the transformations. To be used by installation data consumers.

Creates a new final-installation-data by wrapping the given installation data.

Merges the installation data into the host's, and destroys the former. All of the collections are guaranteed to be non-Null

To be produced out of the original contributions. Used as input for the first transformation.

Merges the installation data into the host's, and destroys the former. All of the collections are guaranteed to be non-Null

Produced by emitting build steps, or collected out of disjoint file/registry artifacts. Will be packed into the single for processing.

Installation data in between the transformations. A special type to avoid mixup with the or while within the pipeline.

Creates a new transform-installation-data by wrapping the given installation data.

Merges the installation data into the host's, and destroys the former. All of the collections are guaranteed to be non-Null

Executed in ascending order.

Applies the transformation by modifying the installation data contents. Yield Null if you don't want to modify.

Temporary empty transformer to avoid failures on empty array injections.

Writes the InstallDir to the Registry. Works for VS shells.

A list of VS versions to install the products.

Do not install into VS. "Visual Studio integration" checkbox on the main installer page.

Product or set of products chosen by user on product website. This option affects default action on product and its location. '*' indicates that all available products should be installed.

Product or set of products chosen by user on product website. This option affects default action on product and its location. '*' indicates that all installed products should be removed.

Installed products with default action Remove. Used to keep user selection on restart elevated, not for manual use.

Full identifiers of hosts to remove silently. This is used in add remove programs menu.

Full identifiers of hosts to reinstall silently (install extensions scenario)

Full identifiers of hosts to modify. SpecificProductNames must contain a list of products to be installed.

Full identifiers of hosts to find and apply updates from the gallery... Check for updates showing UI, if found shows installer, if not shows up-to-date message. '*' indicates that all installed hosts should be checked for update.

Full identifiers of hosts to check for updates and notify in tray if available... Checks for updates in background and shows tray notification if found. Exits if not. '*' indicates that all installed hosts should be checked for update.

Full identifiers of Packages that should be excluded from installation

When EAP launcher was downloaded or run from EAP product...

When we want to define specific predefined hive. Special value '*' is used in junction with 'HostsToRemove' when we need to uninstall products from all hives.

Set to true when called from ReSharper9Plus.msi uninstall

Skip automatic registration of installed extensions.

Disable extension verification.

A list of plugins packages to install or update. Packages could be identified either by package id and version ("JetBrains.I18n.ja.2024.3.10") or by package id only ("JetBrains.I18n.ja"). In the first case the exact plugin version will be installed, in the second case the highest available version will be installed.

A list of plugins packages to uninstall.

Run no UI...

Perform true per-machine installation

Define a custom log file.

Logging level for the . See for a list of possible values.

Remote Gallery URL.

Silent "Install", "Update" or "Remove" from the Toolbox.

Show "Featured products" section.

Web proxy settings. See .

Installer "User-agent" HTTP header.

Color theme: Dark or Light. If not specified, Dark is used.

Skip Ngen Rider assemblies.

Skip ETW service. Do not install, update or remove.

Skip running VS with /Updateconfiguration command line switch after R# install/uninstall.

Set "I have read and accept the license agreement" checkbox.

Installer origin source id.

Add managed memory pressure to the installer (MB). If 0 is specified, the pressure is disabled.

Runs showing the cleanup page.

Generate

Do not install Vsix Installer extension for Visual Studio

Skip installation of SQL/NoSQL feature in Resharper

Keep in sync with JetBrains.Platform.Installer.Bootstrap.InstallerBootstrapConstants.

Human friendly name for all products installers, e.g. "ReSharper Ultimate 2018.1 EAP5 Web Installer"

Name part of all products installers file name, e.g. JetBrains.ReSharperUltimate.2020.2.web.exe

Production CDN (RTM and EAP).

Contains the semantic version of the latest RTM build, e.g. "111.0.20180201.62931". Mind the copy in JetBrains.Platform.Installer.Bootstrap.InstallerBootstrapConstants.

Contains the semantic version of the latest EAP build, e.g. "111.0.20180124.70542-eap". Mind the copy in JetBrains.Platform.Installer.Bootstrap.InstallerBootstrapConstants.

Contains the information on the latest RTM packages.

The latest RTM single executable web-installer (no .exe extension). Mind the copy in JetBrains.Platform.Installer.Bootstrap.InstallerBootstrapConstants.

The latest EAP single executable web-installer (no .exe extension). Mind the copy in JetBrains.Platform.Installer.Bootstrap.InstallerBootstrapConstants.

Installer bootstrapper (located in the product bin folder).

An empty (not stuffed) installer (located in the product bin folder).

Provide an ability to turn update notifications off. Format: {"update-notification-allowed":true}

The clean (not branded with any product nor stuffed with content, just as built) launcher executables. This is the artifact to be used on post-compile stages for the tasks which run on packages.

Takes and makes them into a package suitable for caching (as used by ).

for post-compile artifact.

1) Republishes the Clean Launcher packages to the IPZ as an artifact. 2) Asserts that a valid package is available for download for Nuget sources. This is necessary to compile locally on cheaper operating systems correctly, and to speed up operations on any OSes. This assertion would prevent merging changes which change the launchers compilation without republishing the package.

Performs local-system installations.

Forces all installation steps required for Local Install to be executed, but does not commit the results. The Installer will commit them, if there are no installation errors. The Build Application commits them on stages. See .

Commits Local Install results when the build script is invoked by the Build Application.

Wires up running binary validation on packages when local-install is performed from the Build Application.

Commits Local Install results.

In theory, reverses changes made by . Practically, it's not used, because it cannot work that way.

Performs the local installation of the given installation data by writing the Registry keys and copying the files.

Copies or deletes the files.

Executes the registration/unregistration operations on the Registry keys.

The Registry to process. The Registry to process. Processing type. The macros to substitute when processing the keys.

Writes the key to the Registry.

Writes the value to the Registry.

Deletes the key from the Registry.

Deletes the value from the Registry.

Emits the install-time launcher hosts (as opposed to the compile-time in-package launchers which are done on the source stage). Publishes info for their OS integration.

Compile-time in-package hosts have been produced at the source stage and will be just extracted from their packages, but now their OS integration has to be processed.

Register to the host of the right bitness. Prefer the native launcher of the system-best CPU (because it shows splash quickly and checks for all requirements and loads CLR nicely and so on), then MSIL if not found.

NULL on failure.

Gets whether it's possible to notarize with the server at this moment.

If the Notary service is available, uploads the file for notarizing to Apple S3 and waits the result. Otherwise throws an exception.

Identifies the Notary service access info by giving issuer id, key id, and its private key, similar to .

Base impl available in platform-core-shell, more specific impl uses extra nuget packages and sits in a separate sub.

Installer gallery specifically for Pack EXE distribution. Runs immediately on the memory-mapped EXE file body by reading the Product Content Pack ZIP from the native resources of the executable.

Reads the ZIP catalog, reads only manifest of each package (right from the native resource bytes, no mem cloning), and leaves reading the rest to when the package is actually needed. NOTE: requires the ZIP Entry streams be seekable, which means they MUST NOT be compressed when packing. Packer looks at the gallery flag to ensure that.

Defines the exact stage of the registration process of which the handler is being queried.

The assembly is being registered.

The assembly is being unregistered.

Contains a package with binary files for a product. The primary purpose is to transport Rider frontend binaries to the dotNet installer.

Used to make legacy Rider nsis-installer. Please visit dotnet-teamcity-config.git repository before renaming or changing it.

A Checksum is value that allows the contents of a file to be authenticated. Even small changes to the content of the file will change its checksum. This class allows the results of a variety of checksum and cryptographic message digest algorithms to be represented.

Algorithm for Checksums.

The checksumValue property provides a lower case hexadecimal encoded digest value produced using a specific algorithm.

Identify who (or what, in the case of a tool) created the SPDX document. If the SPDX document was created by an individual, indicate the person's name. If the SPDX document was created on behalf of a company or organization, indicate the entity name. If the SPDX document was created using a software tool, indicate the name and version for that tool. If multiple participants or tools were involved, use multiple instances of this field. Person name or organization name may be designated as “anonymous” if appropriate.

Identify when the SPDX document was originally created. The date is to be specified according to combined date and time in UTC format as specified in ISO 8601 standard.

Single line of text with the following keywords: "Person: person name" and optional "(email)" "Organization: organization" and optional "(email)" "Tool: toolidentifier-version"

An optional field for creators of the SPDX document to provide the version of the SPDX License List used when the SPDX document was created.

An optional field for creators of the SPDX document to provide general comments about the creation of the SPDX document or any other relevant comment not included in the other fields.

Cross-reference details for the URL reference

True if the License SeeAlso URL points to a Wayback archive

True if the URL is a valid well-formed URL

Indicate a URL is still a live accessible location on the public internet

Status of a License List SeeAlso URL reference if it refers to a website that matches the license text.

The ordinal order of this element within a list

Timestamp

URL Reference

Identify any external SPDX documents referenced within this SPDX document. Intent: SPDX elements may be related to other SPDX elements. These elements may be in external SPDX documents. An SPDX element could be a file, package, or SPDX document.

externalDocumentId is a string containing letters, numbers, ., - and/or + which uniquely identifies an external document within this document.

An External Reference allows a Package to reference an external source of additional information, metadata, enumerations, asset identifiers, or downloadable content believed to be relevant to the Package.

Category for the external reference

The unique string with no spaces necessary to access the package-specific information, metadata, or content within the target location. The format of the locator is subject to constraints defined by the type.

Type of the external reference. These are defined in an appendix in the SPDX specification.

Provide a locally unique identifier to refer to licenses that are not found on the SPDX License List.

Provide a copy of the actual text of the license reference extracted from the package, file or snippet that is associated with the License Identifier to aid in future analysis.

Provide a common name of the license that is not on the SPDX list. If the License Name field is not present for a license, it implies an equivalent meaning to NOASSERTION.

Provide a pointer to the official source of a license that is not included in the SPDX License List, that is referenced by the License Identifier.

This field provides a place for the SPDX document creator to record any general comments about the license.

Uniquely identify any element in an SPDX document which might be referenced by other elements. These might be referenced internally and externally with the addition of the SPDX document identifier.

Identify the full path and filename that corresponds to the file information in this section.

This field provides information about the type of file identified. File Type is intrinsic to the file, independent of how the file is being used.

This field provides the result from some specific checksum algorithm. Checksum algorithms consume data from the file and produce a short, fix-sized summary that is sensitive to changes in the file's data. Any random change to the file's data will (with high likelihood) result in a different checksum value.

This field contains the license the SPDX document creator has concluded as governing the file or alternative values if the governing license cannot be determined.

This field contains the license information actually found in the file, if any. This information is most commonly found in the header of the file, although it might be in other areas of the actual file. Any license information not actually in the file, e.g., “COPYING.txt” file in a top-level directory, should not be reflected in this field.

This field provides a place for the SPDX document creator to record any relevant background references or analysis that went in to arriving at the Concluded License for a file. If the Concluded License does not match the License Information in File, this should be explained by the SPDX document creator. It is also preferable to include an explanation here when the Concluded License is NOASSERTION.

Identify the copyright holder of the file, as well as any dates present. This shall be a free-form text field extracted from the actual file.

This field provides a place for the SPDX document creator to record any general comments about the file.

This field provides a place for the SPDX document creator to record license notices or other such related notices found in the file. This might or might not include copyright statements.

This field provides a place for the SPDX document creator to record file contributors. Contributors could include names of copyright holders and/or authors who might not be copyright holders, yet contributed to the file content.

This field provides a place for the SPDX document creator to record, at the file level, acknowledgements that might be required to be communicated in some contexts. This is not meant to include the file's actual complete license text (see LicenseConcluded and LicenseInfoInFile), and might or might not include copyright notices (see also FileCopyrightText). The SPDX document creator might use this field to record other acknowledgements, such as particular clauses from license texts, which might be necessary or desirable to reproduce.

If the SPDX information describes a package

Uniquely identify any element in an SPDX document which may be referenced by other elements.

Identify the full name of the package as given by the Package Originator (7.6).

Identify the version of the package.

Provide the actual file name of the package, or path of the directory being treated as a package. This may include the packaging and compression methods used as part of the file name, if appropriate.

Identify the actual distribution source for the package/directory identified in the SPDX document. This might or might not be different from the originating distribution source for the package. The name of the Package Supplier shall be an organization or recognized author and not a web site.

If the package identified in the SPDX document originated from a different person or organization than identified as Package Supplier (see 7.5 above), this field identifies from where or whom the package originally came. In some cases, a package may be created and originally distributed by a different third party than the Package Supplier of the package.

This section identifies the download Uniform Resource Locator (URL), or a specific location within a version control system (VCS) for the package at the time that the SPDX document was created. Where and how to download the exact package being referenced is critical verification and tracking data.

Indicates whether the file content of this package has been available for or subjected to analysis when creating the SPDX document. If false, indicates packages that represent metadata or URI references to a project, product, artifact, distribution or a component. If false, the package shall not contain any files. If omitted, the default value of true is assumed.

This field provides an independently reproducible mechanism identifying specific contents of a package based on the actual files (except the SPDX document itself, if it is included in the package) that make up each package and that correlates to the data in this SPDX document. This identifier enables a recipient to determine if any file in the original package (that the analysis was done on) has been changed and permits inclusion of an SPDX document as part of a package.

Provide an independently reproducible mechanism that permits unique identification of a specific package that correlates to the data in this SPDX document. This identifier enables a recipient to determine if any file in the original package has been changed. If the SPDX document is to be included in a package, this value should not be calculated. The SHA1 algorithm shall be used to provide the checksum by default.

Provide a place for the SPDX document creator to record a web site that serves as the package's home page. This link can also be used to reference further information about the package referenced by the SPDX document creator.

Provide a place for the SPDX document creator to record any relevant background information or additional comments about the origin of the package. For example, this field might include comments indicating whether the package was pulled from a source code management system or has been repackaged.

Contain the license the SPDX document creator has concluded as governing the package or alternative values, if the governing license cannot be determined.

This field is to contain a list of all licenses found in the package. The relationship between licenses (i.e., conjunctive, disjunctive) is not specified in this field – it is simply a listing of all licenses found.

List the licenses that have been declared by the authors of the package. Any license information that does not originate from the package authors, e.g. license information from a third-party repository, should not be included in this field.

This field provides a place for the SPDX document creator to record any relevant background information or analysis that went in to arriving at the Concluded License for a package. If the Concluded License does not match the Declared License or License Information from Files, this should be explained by the SPDX document creator. It is also preferable to include an explanation here when the Concluded License is NOASSERTION.

Identify the copyright holders of the package, as well as any dates present. This will be a free form text field extracted from package information files.

This field is a short description of the package.

This field is a more detailed description of the package. It may also be extracted from the packages itself.

This field provides a place for the SPDX document creator to record any general comments about the package being described.

A manifest based verification code (the algorithm is defined in section 4.7 of the full specification) of the SPDX Item. This allows consumers of this data and/or database to determine if an SPDX item they have in hand is identical to the SPDX item from which the data was produced. This algorithm works even if the SPDX document is included in the SPDX item.

A file that was excluded when calculating the package verification code. This is usually a file containing SPDX data regarding the package. If a package contains more than one SPDX file all SPDX files must be excluded from the package verification code. If this is not done it would be impossible to correctly calculate the verification codes in both files.

The actual package verification code as a hex encoded value.

Defines a relationship between two SPDX elements. The SPDX element may be a Package, File, or SpdxDocument.

A related SpdxElement.

This field provides information about the relationship between two SPDX elements. For example, you can represent a relationship between two different Files, between a Package and a File, between two Packages, or between one SPDXDocument and another SPDXDocument.

This field provides a place for the SPDX document creator to record any general comments about the relationship.

Identify the current SPDX document which may be referenced in relationships by other files, packages internally and documents externally.

Provide a reference number that can be used to understand how to parse and interpret the rest of the file.

Identify name of this document as designated by creator.

Compliance with the SPDX specification includes populating the SPDX fields therein with data related to such fields ("SPDX-Metadata"). The SPDX specification contains numerous fields where an SPDX document creator may provide relevant explanatory text in SPDX-Metadata. Without opining on the lawfulness of "database rights" (in jurisdictions where applicable), such explanatory text is copyrightable subject matter in most Berne Convention countries. By using the SPDX specification, or any portion hereof, you hereby agree that any copyright rights (as determined by your jurisdiction) in any SPDX-Metadata, including without limitation explanatory text, shall be subject to the terms of the Creative Commons CC0 1.0 Universal license.

Provide an SPDX document-specific namespace as a unique absolute Uniform Resource Identifier (URI) as specified in RFC-3986, with the exception of the ‘#’ delimiter.

Identify any external SPDX documents referenced within this SPDX document.

Identify who (or what, in the case of a tool) created the SPDX document.

An optional field for creators of the SPDX document content to provide comments to the consumers of the SPDX document.

Helper class which provides facility to build reference closure of .NET assembly(ies).

Used in console tool installers to determine files necessary for particular tool.


            ReferenceClosure
              .Of(ConsoleRunner.AssemblyName, files)
              .IncludeAssembly("JetBrains.Profiler.Windows.ElevationAgent")
              .IncludeExtra(ourIncludeExtra)
              .Exclude(ourExclude)
              .Build();

Includes in result set given extra files (by mask).

Includes in result set given assembly.

assembly name (w/o extension)

Excludes from result set given files (by mask).

Builds reference closure against specified assemblies and includes given extra files.

Initiates ReferenceClosure.

entry-point assembly name (w/o extension) all files which build step has produced the base path to locate assembly's metadata

Tool exe would get everything user passes to the batch script as arguments, plus this stuff. Use batch references to names from if you need to refer any of the context.

Env vars you might reference in additional tool arguments.

Can make a nuget package with an EXE tool which we then might run from a CMD file.

Nuget SDK targets: forms the command here, before passing to the Exec task.

Nuget SDK targets: Additional arguments to the executable, might be passed by caller from outside, will be used when starting the app.

Nuget SDK targets: The abs path to the exe, determined by the props file, unsed in targets file (or if you import the nuget as an sdk, in your project).

Wires up post-compile validation to IPZ. Makes a file with validation errors list.

Call this method every time file associations has been changed.

Application Registration. See: "https://docs.microsoft.com/en-us/windows/win32/shell/app-registration".

File type association. See: https://docs.microsoft.com/en-us/windows/win32/shell/fa-file-types See: https://docs.microsoft.com/en-us/windows/win32/shell/fa-progids

Directory association. See: https://stackoverflow.com/questions/4902041/windows-shell-add-item-to-context-menu-when-click-on-blank-part-of-folder

Executes action. Called after Update, that set ActionPresentation.Enabled to true.

DataContext delegate to call

Updates action visual presentation. If presentation.Enabled is set to false, Execute will not be called.

DataContext presentation to update delegate to call

If a product has been installed with an installer which got the packaging identity, expose it in the About Box.

Additional About Box display.

Adds data to the text content that will be copied to clipboard. Either a single-line string or a set of CRLF-terminated lines.

Adds a Rich Text Label to the About Box presentation.

Represents the main window of the application.

Represents the main window of the application, as a Win32 handle wrapper. TODO: rename this interface to Win32MainWindow and make less central, or use some generalized object for a window.

The IsInternetConnected function determines whether the current user is connected to the Internet.

Opens the specific URI in the default Web browser.

Opens the specific URI in the default Web browser. However, it is recommended to use component , it is overriden in tests

Patches the URI to add utm_source=product parameter to it. Returns the same URI if the parameter is already present. Only adds utm_source to the links, which point out to jetbrains.com.

meh, why this method is not in the .NET framework?

Fires when the user clicks a mouse button on the control.

Gets or sets the automation object for the view which manages the painting and layouting of the indicator. There must be registered views for both WPF (ViewKind.Wpf) and a Windowless Control () if you want your control to be presented correctly across all supported VS versions. If the value is Null, the status bar indicator is hidden and collapsed. You may use this approach for concealing the indicator instead of removing it from the status bar. To show a tooltip over your indicator, implement AvalonTooltipManagerComponent.GetJetTooltipEvent or on your view of this content, depending on its type.

Gets or sets the mouse cursor

Fires when a context menu should be shown.

Fires to get the placement of the context menu relative to icon or content of status bar item

Fires when the user double-clicks a mouse button on the control.

Gets whether the control is currently hot (has mouse over its view).

The margin around the "WindowlessControl" content inside the status bar indicator place.

A simple implementation of a text tool tip on the status bar indicator in the whole. This is only triggered if the 's view does not handle tooltip on itself, in either WPF or Windowless Control. Handling of the tooltip on the view might be required if you want to have different tooltips over different indicator areas, or present advanced tooltip content. Handling the tooltip with this method is simpler and also applies advanced layouting for the tooltip so that it didn't cover the indicator.

Provides access to the Status Bar of the UI application.

Gets the collection of the status bar indicators.

Gets whether the application status bar is currently visible (not turned off).

Gets or sets the text currently displayed in the status bar.

Gets or sets whether the statusbar text is currently emphasized.

Clears the status bar text.

Sets the status bar text.

Text. Whether to apply special highlighting to the status bar text to emphasize that it's not a routine message.

If the status bar is subclassing the IDE status bar (like, in Visual Studio), gets the actual text from the IDE and returns it.

Represents the data for an indicator in the status bar.

indicator with highest priority is placed into the rightmost position

Fires when the user clicks a mouse button on the control.

Gets or sets the mouse cursor

Fires when a context menu should be shown. Note: the object is disposable. You must either avoid creating it by not touching the container, or use the value you get from it (either JetPopupMenu.Show(JetBrains.Lifetimes.LifetimeDefinition) the menu, which will then dispose of it correctly, or of it explicitly).

Fire the signal to show context menu on demand

Fires when the user double-clicks a mouse button on the control.

Gets whether the control is currently hot (has mouse over its view).

The margin around the "WindowlessControl" content inside the status bar indicator place.

Default status bar document implementation. Data-only. Both clients and status bar implementations access data in this class.

Base dummy impl of the task bar manager.

A fully custom build request.

Requests that a build be run, applies all defaults to the parameters, but for the resulting artifact objectives.

When a build starts running, activates various UI for it (e.g. opens build log view) or generates teamcity logs.

Serves simple build requests on app dispatch by wrapping them with a fully-defined request.

Defines all parameters of the request to run with the build. Originally, were the of the engine itself. Then, it's the version-independent .

When a build app runs a session, allows to track its progress.

A task which completes when the build is done.

The logged entries, live list.

The original request for running this build.

Free-threaded counter of running bootstrap builds. Does not affect manually-runs, but prevents auto-refresher from running

Full info on the cached bootstrapper: its files, plus info on how to check if it's up to date and track for changes.

Name of the file used by the current build system version for storing the cached compiled bootstrapper.

Tries to load from persistent caching, no error if any problems.

Tries to save for persistent caching, no error if any problems.

Assigns initial startup values for build artifacts. This includes artifacts from the command line and predefined values (like ).

Handles binary parameters on the build request which can be overridden on the command line. There's no autodiscovery — if they're not cmdline-supplied, then they're not set.

Filters out files with build engine/script binaries by removing SSTGs which don't hold the right type of data. This would have happened later in the build, but saves passing potentially large files back and forth.

Creates the component with when running the shelled version of the build tool.

Components with this interface must all be done before exposes it to general public.

To let all stringtable loaders run correctly, this is the separate storage only exposed with when fully ready.

Syncs the arts with external sources.

Denotes the skeleton of the build request (the entry point and key params). The other parameters are environment-based and will be assigned when translating into the full request and before running the build.

User-friendly display name.

The main objective of the outermost build. Usually, just one of the predefined entry points which run the nested build for the real objective after all of the preparatory steps. See creator methods for examples.

Optional input artifacts. When running standard wrapper objectives, might specify what to run as the binary stage payload of the build. With bootstrapped build runner, all parameter instances must be serializable to strings (as .

Creates simple request for running a local binary-stage build. Locally, this requires running the source-stage to compile and pack the Nuget packages first. So the main objective is set to the predefined , and the binary stage objective is passed as the artifact.

Objective for the second, binary stage.

Creates the simple request for running a build for exactly the objective specified.

Helps with filling the complete from the context available to the build runner.

Writes InputArtifactStrings to the request, based on the and optional custom parameters.

The full request to get filled. Stringtable with globally known artifact values. In the build app, these are settings chosen in GUI or loaded from the app settings file or passed as cmdline parameters. These have already been supplied as serialized objects, and should be filtered out from any string representations to avoid duplicates. Logger.

A component which can find all Build Engine DLLs. The version which knows of the Shell and can use the part catalog / application packages.

DLLs required to run the builtin version of the engine.

Emits build log messages into TC output. WAS a component in the shelled BuildApp on TeamCity, performed an activity similar to build app's showing the log tool window when a build runs. Now serves as a set of helpers for running build on TC which turns logged messages in to TC messages.

Shell ctor, listens for sessions in the build app dispatch.

Manual ctor, serves the single session. Hidden from the container, use factory method.

Apply tags to the build (taken from build parameters).

User interactivity for the .

Shows the log tool window instance which starts dumping the application log.

Shows the log tool window without attaching to any log source. Returns the collection which should be populated with log records by the caller.

Means PBDA is specified as a final value, so the relative hint has no effect.

Input collection with all the log records.

When True, a fake “Running” item is added to the end.

The collection as it should be displayed by the tree.

Externally adds a record to the log in .

There is no result yet (e.g. operation has not yet started for this item).

The result is OK (so far no warnings or errors).

There were warnings (but not errors).

There were errors.

The item is excluded from the run.

Show progress when dispatch reports running a build.

Assigns a value to a build artifact before running the build. Syntax: name=value Name is the build artifact class name, long (with namespace) or short (just local class name, if not ambiguous). Value is the string representation for the artifact value, to be coerced to artifact type with or .

Specifies path to the build engine binaries. See impl for comments on allowed formats.

Fully defines the build runner request, including the build script, engine, and inputs. Takes the full path to the file with the serialized object, in the current build runner format. The format must match exactly, so do not use this to pass build data unless when between the runners of exactly the same version.

Specifies path to the build script binaries. See impl for comments on allowed formats.

Specifies path to the folder with *.cs build sources. If no such parameters are given on the command line, autodetects sources in well-known Platform folders. To suppress autodetection without supplying sources, pass a commandline key with an empty value.

Allows to specify the on the command line.

Runs the build for the specified build artifact class name, long (with namespace) or short (just local class name, if not ambiguous).

When packaging for deployment, adds info on third party libraries used by the products in that packaging.

Search inside the nuget package for files whose names end with third-party-libraries.json, and take the list of licenses from there.

Nuget package to search Logger List of licenses found

Raw info on third party libraries.

If any nuget package of the product contains a third-party-libraries.json file specifying the licenses of this package's dependencies, such licenses will be included in this collection bypassing all checks.

This structure corresponds to the contents of the third-party-libraries.json file. This structure is used both for exporting dotnet product licenses for publication on the website and for importing licenses from nuget packages.

Package name Package version Url to a package repository or a home page Package license License url. Either link to a spdx.org website or to the license text in a package's repository

Package name

Package version

Url to a package repository or a home page

Package license

License url. Either link to a spdx.org website or to the license text in a package's repository

Collects info on third party libraries used in products, and their licenses. Does the basic publishing in Wiki format (see Rider uses for its publishings).

Set of SPDX license identifiers under which JetBrains releases its open source software

Get all possibly installable packages, per installable product.

Get license-friendly metadata info for packages, including external provided through .

Include checking third party licenses consistency when doing validation runs.

A stub for the service which emits native images for managed assemblies for a specific runtime. NOTE might throw if it's not the current runtime.

Identity of the impl, for caching.

The target artifact for a post-compile TC step which takes all compile packages and makes NGen companion packages for them, and exposes them as the same so that other post-compile builds which take this one could use them just like other compiled input packages.

Specifies for which OS to make NGen packages.

Runs the command-line version of the build, without spawning the full shell.

Local name or full name of the build objective artifact. Optional artifact string values. Map a local or full name to the string representation. Optional directories with build script sources (if there's build script in the source code form). The strings are paths to directories in which to look for build script sources, recursively; paths are either absolute, or relative to the , if given on the commandline. Optional files with build script binaries — assemblies, Nuget packages, or structured storages with these (if there's build script in the binary form). The strings are absolute paths to files. Optional files with build engine binaries (if using custom build engine rather than reusing build runner's). The strings are absolute paths to files. Result code, negative for a failure, S_OK if clean, S_FALSE if nearly ok but there were warnings. Maximum logging level in values. Any higher (= less meaningful) messages will be omitted from output. Result code, negative for a failure, S_OK if clean, S_FALSE if nearly ok but there were warnings.

The command line interface entry point.

Runs the TeamCity version of the build, without spawning the full shell.

Converts scattered parameters for powershell input into the command string object.

Starts logging to the standard logs location. That's not the working output of the logs (which go to stdout/teamcity with all formatting etc).

Expected to be called when session is not running any more. Summarizes the run and prints the first error/warning.

In-catch part of .

Runs the TeamCity version of the build, without spawning the full shell.

Build runner command string in the standard format. The return value of the run: a pointer to a DWORD where it should be written. Result code, negative for a failure, S_OK if clean, S_FALSE if nearly ok but there were warnings.

Deals with input artifacts, mainly in the build tool UI.

Allows to watch individual artifacts for their live values.

Maps the artifact name to its string value serialization. The name is either the local name or the full name of the artifact.

Caches names in keys of the by their local name.

If one or more artifacts match this local name, stabily chooses one of the full names.

Typed version of .

The typed value, live.

An item in .

Whether there's a value for this artifact.

The raw string value, live.

Gets, sets, or removes a value as a raw string.

Deals with input artifacts, mainly in the build tool UI. Base impl.

Allows to watch individual artifacts for their live values.

Maps the artifact name to its string value serialization. The name is either the local name or the full name of the artifact.

Caches names in keys of the by their local name.

If one or more artifacts match this local name, stabily chooses one of the full names.

The typed value, live.

Whether there's a value for this artifact.

The raw string value, live.

Gets, sets, or removes a value as a raw string.

Parses artifacts from the command line. Long syntax: command line key named Artifact, its value has the artifact name and value separated with =. Short syntax (optional): command line keyless parameter prefixed with & has then the artifact name and value separated with =

IsDeadlockSafe(ShellComponentAttribute, SolutionComponentAttribute) is true (i.e. "components created during Sync and Async stages of shell container compose are deadlock safe for solution components") IsDeadlockSafe(SolutionComponentAttribute, SolutionComponentAttribute) is false IsDeadlockSafe(ShellPerClientComponentAttribute, SolutionPerClientComponentAttribute) is true IsDeadlockSafe(SolutionComponentAttribute, SolutionPerClientComponentAttribute) is false IsAvailable(ShellComponentAttribute, SolutionComponentAttribute) is true (i.e. "shell components are available for solution components" or "shell components can be injected into solution component constructor") IsAvailable(SolutionComponentAttribute, SolutionInstanceComponentAttribute) is false IsAvailable(ShellPerClientComponentAttribute, ShellPerClientComponentAttribute) is true true for component attributes marked with [ComponentContainerNestedIn(null)], e.g. for OptionsComponentAttribute lazy enumerable are excluded

Synthetic artifact which derives from all the post-compile-stage validation artifacts.

The list of validation errors, if any.

A subset of what does, handpicked for running when you do LocalInstall in the build app. The full set of operations includes checks which run on packages, which in turn requests building of all deployable artifacts, and it takes A LOT of time and is undesirable to execute on every local install. On the other side, we still want some basic and fast validations (such as zoning).

All validations are supposed to be added to explicitly, but in case smb forgets, we'd attach them automatically. This would result in error pool duplication in PCVR, but we suppose they would be deduplicated when using.

(1) Checks that all components are zone-filter-visible. (2) For environment components, checks they are only zoned with env zones. An environment component runs within the Environment Container, which only has Environment zones ever enabled. So if an environment component is zoned with a non-environment zone, it would just never run.

An Activator cannot be starting (transitively bringing via ) environment zones with which it isn't zoned already.

An environment component cannot be zoned by zones which are not environment zones.

See docs on .

Validation thinks a reference to this sub should be added. Validation thinks this is the sub with the product which needs a reference. Validation thinks this is the product which needs a reference. Within this product, packages which have code zoned with the of the . Within this product, packages which have existing code zoned with the of the . Packages which are currently considered when shipping the product, full list.

See docs on .

Validation thinks a reference to this sub should be added.

Validation thinks this is the sub with the product which needs a reference.

Validation thinks this is the product which needs a reference.

Within this product, packages which have code zoned with the of the .

Within this product, packages which have existing code zoned with the of the .

Packages which are currently considered when shipping the product, full list.

(This is an experimental condition which only checks manually declared features; possibly, a more automatic solution could be developed, or even packages added to products automatically.) Requests validation for a certain feature that if its interface package is shipped with a product then implementation packages are also included. The feature is identified by its zone (e.g. IMyFeatureZone). An implementation package is such a package which has runtime-specific implementations for the feature (for example, UI Interactive WPF version of the implementation, in which case IWpfUIEnvZone would be the conditional implementation zone). Now the validation condition is: if the product ships ANY packages with IMyFeatureZone, and ANY packages with IWpfUIEnvZone, then it also MUST ship the package which has both IMyFeatureZone and IWpfUIEnvZone. In other words, if the product includes our feature, and the product runs WPF UI, then the product must not forget to ship WPF UI for our feature. This does not happen automatically because the product might be referencing feature indirectly thru other features, in which case nobody would reference the WPF-specific package.

The zone of the feature we're trying to protect from losing implementations. The runtime-specific zone which is the condition for including implementation packages: if the product runs this zone, then any packages zoned by the feature zone and this zone MUST also be present.

The zone of the feature we're trying to protect from losing implementations.

The runtime-specific zone which is the condition for including implementation packages: if the product runs this zone, then any packages zoned by the feature zone and this zone MUST also be present.

The linking point for validating the zones on the packages which have already been built.

Emit for your package if you know that zoning is invalid in your package and want to issue warnings for it instead of errors.

Formalizes the write-out as a text file with a specific artifact.

Removes zones which are reachable from other zones in the list.

Zone definition check. We're not checking it as a regular type, the exception is that the types mentioned in requirements are OK not to be required at the location where the zone itself is declared. But we should ensure that the Module Zone Definition is not zoned by more zones than it requires, otherwise it would not be possible to mark anything with just this zones, the enclosing zones would implicitly be required too — to reference the zone definition interface/class.

Missing zones for a missing-error, illegal zones, etc — the minimal list, excludes transitively reachable zones.

Missing zones for a missing-error, illegal zones, etc — the full transitively-closed list.

Content might be empty if n/a for this error type.

Explains how the involved zone has been encountered (by which class and namespace zone markers).

To use , Error.InvalidZones must also be required.

In addition to explicit requirements, the type also requires Error.InvalidZones, which is not allowed. E.g. a Zone Definition is under a namespace zone marker.

Single-threaded for the single visiting hierarchy only.

Represents arguments of change event

Executes the specified action after the current change has finished or immediately if there is no change currently in progress.

Initiates the event dispatching process using the specified provider as a starting point.

In Content Model Forks can only be invoked from Fork's primary thread.

Registers change provider in the dispatching scheme.

Lifetime for which the change provider is registered Provider of changes This API cannot be used in Content Model Forks

Adds dependency between two providers.

Lifetime for which dependency is added Change provider that depends on Change provider that depends on Both providers must have already been registered. This API cannot be used in Content Model Forks

Dumps the internal structure into the specified writer.

The event about changes in the system. Can be used for various leaf change handlers that do not want to participate in the dependency graph. Only fired on the UI thread.

The event about changes in the system, including changed happening inside content model forks. Can be used for various leaf change handlers that do not want to participate in the dependency graph. Only fired on the UI thread OR the main threads inside forks.

Type of the changed occurred on file system means file or folder has been added means file or folder has been removed means file's or folder's content or attribute has been modified means something is changed in the subtree. This change type is used when is caught. Note, there will be no nested changes when this event type is used means file or folder has been renamed default value. Should not be used in real cases

Indicates that this must handle change events happening inside Content Model Forks. Change events in forks are being sent and handled only on Fork's primary thread. Make sure there is no shared mutable state stored in change provider if implementing this interface.

You don't need to implement this interface if your implementation is empty.

Defines set of file names that match the specified regular expression

Represents a sequential modification stamp to be used on the Content Model entities, such as documents and project files. As those are two independent hierarchies, has to be declared in some common point (hence, Shell). Project files intentionally use document modification stamps for their stamping, so those are essentially the same entity.

Opaque raw value. Treated as a black box.

Command processor that performs undoable actions.

Gets whether the command processor is executing at least one command.

The outermost command of the command processor. Opening nested commands does not affect this property.

Makes sure current command is not completed until the is terminated

Prolongation period lifetime Prolongation reason for logging purposes

If in a batch change (), bears the batch change name. Otherwise, null.

How frequently should we reload config. Zero means no reload

Cached config value will be reset. It will be reloaded on next call

Cached config value is reset and config reload is scheduled. If the next call to occurs before the new value is loaded, will be called sync

Cached config value is left as-is and config reload is scheduled. If the next call to occurs before the new value is loaded, old value is used

A settings node under . Root for internet-related settings.

Web proxy settings. Use to create a .NET-API-compatible proxy object.

Gets the .NET-API-compatible proxy settings.

This attribute is used to discover runtime types by RdId using PartCatalog If you are using the interface in Rd communications without DSL, you must register all inheritors of this interface using this attribute

Warm component state, optionally queue ILazy to additional warm up

Extender for the Shell component container

Container for getting ALL (not only leaf) applicable components

Contains global settings of objects that do not have components to store settings in

An interface for a component that has some settings and they should be saved whenever all of the application settings are being saved. // TODO: rework when we have a mature settings model.

Tells the component container to reload the settings from the persistent media, deserialize them from the bag, and apply them to the components. If a particular component has not been initialized yet, it will be called for IXmlExternalizable.ReadFromXml / before its IComponent.Init. Otherwise, those xml-related methods will be called on it for the second and so on time.

Tells the component container that it's about time to query the components of their settings, serialize them to the bag, and write that to the persistent media. You must make sure this method is called on component containers in the end of the session. The component container will never save settings on its own.

The interface which is used to mark components as requiring initialization from configuration file which ships with the product. Used for components which have complex initial configuration which is better to keep in external files rather than in code.

Called on the component by the component container before its IComponent.Init and IXmlExternalizable.ReadFromXml to load the XML Configuration from the resource in the component implementation assembly, the name of the resource specified in the on the component implementation.

This method is called on the component to populate it with default or loaded settings, unless the component implements and returns True from its handler. The element is taken from the settings file, if available. If not, and there are settings files from the older versions, and the component does not implement , this method is called with the old settings. Otherwise, this method is called with an empty element or a Null value. For the first time, this method is called right before component's init. The settings-reading protocol might be executed more than once thru the component lifetime.

Called when the component should serialize its settings into the XML presentation, for saving into the settings file.

Interface for classes that support registration in Windows Registry

If a previous User Settings version is found, and the component implements this interface, it's called with this interface instead of the regular Externalizable. Otherwise, the old settings will be passed into the regular interface.

Element names for the component under which it used to be known in the old settings files.

Called with component's settings taken from the older version of the settings file, for each of the (even if some of the handlers return True). IXmlExternalizable.ReadFromXml will not be called if any of the calls returns True. The settings-reading protocol might be executed more than once thru the component lifetime.

An XML element with component settings, taken from the settings file. Version of the product that supposedly produced the legacy settings file we're upgrading from, or an empty instance if those are not known. Whether the component has upgraded. Its normal IXmlExternalizable.ReadFromXml will not be called if that is the case.

A component container with XML serialization capabilities for the component settings.

This stores the settings after they're read from the storage and before they're loaded by the components, and before they're written back to the storage.

Whenever an older version of the settings file is found to be upgraded, set to the version of the product that supposedly produced that file. Otherwise, Null, which means that the upgrade should not be called.

A dummy XML document for creating XML elements for component settings. When settings are deserialized, set to their XML document. It's not important which XmlDoc to use, we'd just like to minimize their number.

Invoked by the base implementation when it's time to load the XML Settings Bag from the permanent storage. This logic (like, choosing the file) must be implemented by the inheritor. The inheritor might look for legacy settings files from previous versions if the normal settings file is missing and set to use them with components. Call to submit the XML representation of the settings for a particular scope (see for details).

Override this property to provide a list of scopes that are valid for components in this container.

There were no upgrade, but there's a valid settings element, and it will be applied.

If in upgrade mode, see for upgrade data for this component.

Reads from an XML document and stores into the XML Bag. Collects the entries for the map from the . The scope is given by , and the name comes from the XML tag names.

Overrides the base init-component to perform XML-related ops.

Uses and as the default implementation of "IXmlExternalizable" over .

True if loaded anything, false otherwise

Gets the boolean properties.

Gets the integer properties.

Gets the string properties.

Represent the properties collection.

Gets a property by its name. Creates a new one if missing.

Gets a property by its name. Creates a new one if missing. The second parameter is the default value for the case the property does not yet exist.

Adds an item to the .

The object to add to the . The is read-only.

Removes all items from the .

The is read-only.

Determines whether the contains a specific value.

true if item is found in the ; otherwise, false. The object to locate in the .

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 array at which copying begins. arrayIndex is less than 0. array is null. array is multidimensional.-or-arrayIndex is equal to or greater than the length of array.-or-The number of elements in the source is greater than the available space from arrayIndex to the end of the destination array.-or-Type T cannot be cast automatically to the type of the destination array.

Returns an enumerator that iterates through a collection.

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

Removes the first occurrence of a specific object from the .

true if item was successfully removed from the ; otherwise, false. This method also returns false if item is not found in the original . The object to remove from the . The is read-only.

Returns an enumerator that iterates through the collection.

A that can be used to iterate through the collection. 1

Gets the number of elements contained in the .

The number of elements contained in the .

Gets a value indicating whether the is read-only.

true if the is read-only; otherwise, false.

Returns an enumerator that iterates through the collection.

A that can be used to iterate through the collection. 1

Tries to load the XML Document for (either from current version location, or any of the legacy dirs for an upgrade).

Looks for just the current version. Also saves initial content and timestamp to check for overwrites.

Settings from prev versions for upgrade. Initial-content/timestamp not saved in this branch.

Tries to load the XML Document for (either from current version location, or any of the legacy dirs for an upgrade).

A property that IApplicationDescriptors could put into their IApplicationDescriptor.Bags to look for older-version settings in non-standard folders when there are no up-to-date-version settings found and we would like to upgrade from an older version. The strings are file path names. The versions are versions of the product to which the settings supposedly belong.

Contains global settings of objects that do not have components to store settings in

Allows to mark a type as XML Configurable. Call to to configure. is used to fill instance with data.

Name of the embedded resource in either the component's assembly or the product's IApplicationDescriptor.ConfigurationAssembly that contains the XML to be passed into the component's before its IComponent.Init.

For an XML-configurable component, loads its config and applies to the component.

Use this attribute to mark those fields and properties of a class that should be serialized to XML.

The default value for this entry. You do not need to initialize the field itself in the inline initializer or the constructor. Instead, you MUST set this to the desired initial value, for serialization to work consistently. The possible values are: • Null,.which means the default value for the of the field (Null for reference types and zero memory for value types). • Some value of the same type as the of the field, or a value type convertible to it. • An invariant string representation of a value that cannot be presented inline in the attribute ctor. value of the same type as the of the field, or a value type convertible to it. The appropriate is used for reading the value.

Use this property to specify settings name used in the xml, if different from the property (field) name.

Gets or sets whether the XML Serializer should be used for serializing the value of this field.

Defines the scopes for the externalizable components. The define the sets of isolated components that are serialized to separate storages. You may use one of the base values, or introduce your own ones as integers, as the string representations are never used. The scopes are normally not persisted, because they define a settings storage on serialization and are defined by the storage on deserialization.

Don't return from components. Means that, when filtering, all the scopes should be allowed.

Locally-stored settings of a project or a solution. They're not intended to be shared in the team or added to the SCC. Typically, they're persisted in a “.resharper.user” file.

Team-shared settings of a project or a solution. They're intended to be added to the SCC. Typically, they're persisted in a “.resharper” file.

User settings of the product.

Workspace settings of the product.

Utility class to externalize values of fields and properties of given instance via reflection. Helpful for implementing and interface. Values of all fields and properties marked with are saved/restored. The following value types are supported: , , , , s, s and one-dimensional arrays of the above types (as well as arrays of arrays).

Controls the element nullity in the new serialization behavior. New behavior: elements with non-empty content are not-null values, and IsNull attribute must be present on elements with empty content to tell apart Null and empty string serialization (or empty arrays). Old behavior: if the IsNull attr is missing on an empty-content element, a self-closed tag is considered Null, and an opening+closing pair is considered an empty string.

Name of the root element of the settings we write.

Name of the / root element.

Enumerates the XML-externalizable fields of the object and sets them to the default values, if such are given in the property.

XML Serial access to the CDATA element content. Called on each top-level element under the stream root element.

XML Serial access to the CDATA element content.

Gets the members supported for XML Externalization. That is, fields or properties with the attribute.

Reads a value from the reader, returns either that value of type , or Null.

XML Reader positioned at the element whose value should be parsed. Expected value type.

Reads the value, returns it if available, or otherwise.

Value deserialization for the case.

The value read from the member, or the value to be written to the member. Temporary storage. Not operated by this class, read and written by external consumers. Initially, .

Gets the type of the member values. Supports fields and properties of a CLR and type.

Retrieves a value of the member. Supports fields and properties of a CLR and type.

Retrieves a value of the member in a raw manner.

Gets whether there's a default value specified for the member in its .

Analyses and parses the default value, as given by the ->.

Assigns a value to the member. Supports fields and properties of a CLR and type.

Sets the value of the member in a raw manner.

Determines whether the specified is equal to the current .

true if the specified is equal to the current ; otherwise, false. The to compare with the current . The parameter is null.2

Serves as a hash function for a particular type.

A hash code for the current . 2

Compares the current object with another object of the same type.

Indicates whether the current object is equal to another object of the same type.

true if the current object is equal to the parameter; otherwise, false. An object to compare with this object.

Manages the Content Model Forks - a mechanism of isolation that allows you to have separate syntax trees instances for the same source files, separate documents to modify, separate RW lock.

- Content Model Forks can only be created under the Read Lock (so fork lifetime cannot cross the Write Lock boundary) and always execute with at least Read Lock level of content model access. It's not possible to release the Read Lock in the fork. - Content Model Forks only support synchronous code execution. Nothing like 'ExecuteOrQueue' is allowed in forked context, no async commits. - Write Lock in the fork can only be taken by the fork's Main Thread - the thread that's created the fork. - Fork nesting is not allowed (it's not possible to fork the forked state).

Return 'true' if the current thread is running in the Content Model Fork context.

Return 'true' if the current thread is running in the Content Model Fork context, where Write operations are allowed.

Indicates that the current fork (if any) has received the interruption notification (because of the global Write Lock acquire attempt)

Creates the new Content Model Fork and sets up the currently running thread to execute in this fork. Read Lock must be taken for the whole period of the fork's existence. Nested forks are not allowed. Use and methods if you need to extend this fork to some other child thread.

Fork's name, for diagnostic purposes only Content models locks access Controls if Write Lock acquire is allowed inside the created fork Fork's lifetime cookie

Captures the current Content Model Fork (if any) into the data structure that enables to execute the child threads in the context of the same fork via method call. If the current thread is not forked - this whole thing is a no-op.

Set up the existing Content Model Fork for the currently running child thread. Read Lock must be taken for the whole period of the fork's existence. Nested forks are not allowed.

Transition cookie from method.

The very special API for rare cases when the code may already run in Content Model Fork context and needs nested content model fork. Currently only used to implement 'CachedInheritors' cache that collects and replays the SWA dependencies. Read Lock must be taken for the whole period of the fork's existence.

Fork's name, for diagnostic purposes only Content models locks Controls if Write Lock acquire is allowed inside the created fork Fork's lifetime cookie

This API is intended to only be used in tests to allow temporary "exit" from fork's execution context.

The very special API for rare cases when the code may already run in Content Model Fork context and needs to execute some code in global, non-forked context. Read Lock must be taken for the whole period of the fork's existence.

Content models locks Fork's exit lifetime cookie

API to store some data associated with some not-fork-isolated (shared between forks) domain entity. Data is referenced by the strong reference until is referenced.

Use this type to split the state of components per each Content Model Fork. The factory is synchronized and will only be called once (per each Fork + outside of Fork once). You MUST split the state of all the resolve-dependent caches like 'InvalidatingPsiCache' to support Forks and parallel SWA. Lifetime: 1. The non-forked value is referenced via strong reference as long as the instance is referenced. 2. The forked value is referenced by the Fork itself, meaning it will be preserved until Fork is alive.

Special exception kind to throw from operations that are logically impossible to perform in Content Model Fork context: for example, saving modified document is disallowed.

A point, in screen coordinates. Available if the context has been created from a screen point: (or if published by some data provider).

Presence of this data constant in the data context means that you would like to refine the context to all the possibly known details of the current selection, like current document, file, text control, caret position in the text control, selected text, and so on. All of the data rules providing context info should be doing this in inference from this constant instead of supplying the data out of nothing.

Presence of this data constant in the data context means that you would like to refine the context to the current global state of the application, which is more or less permanent and does not depend on selected window/document etc. Global features not bound to selection (like Memory Usage Indicator for instance) might be using this context for their actions and settings binding. In VS-based products, this normally includes the solution object, because a solution defines the VS context (and you must switch the state with an explicit Open/Close Solution Action to alter this context), but does not include projects because the current project changes with selection. In DotTrace with one-process-per-snapshot, this might be the snapshot.

Gets the component container which is best for factoring object belonging to this context.

Returns a that represents the current .

A that represents the current . 2

The Action Manager's implementation of IDataContext. If you'd like to create your own data context, use one of the methods (import ). With it, you can add any rules or constants on your own, and create the data context on a specific control or point, or without any local context (the default global context). In the rare case when you need entirely your own datacontext without standard data rules, implement directly.

Recursion prevention.

Creates the data context. If you'd like to create your own data context, use one of the methods (import ). With it, you can add any rules or constants on your own, and create the data context on a specific control or point, or without any local context (the default global context). From all the rules lists (plain and pre-sorted), rules are picked first by priority, then (within the same priority, which is usually the case because nearly all the rules have the default priority) — first from the plain list in order of appearance, then from the sorted list. The precedence of the plain list comes from the fact that it's usually the context-specific one (from focused control or moused control etc), while the pre-sorted list is the global list of the Action Manager.

Limiting lifetime. Validates values returned for data constant Optional. The plain list of data rules for the context. Optional. As Action Manager has a large persistent list of data rules, they're given in a way that they're pre-tossed by constant and pre-sorted by priority for each constant.

Thread affinity.

For diagnostyx.

For exception diag only, might be as slow as you'd like.

For diagnostyx.

Gets if there're no rules at all in this datacontext.

From all the rules lists (plain and pre-sorted), rules are picked first by priority, then (within the same priority, which is usually the case because nearly all the rules have the default priority) — first from the plain list in order of appearance, then from the sorted list. The precedence of the plain list comes from the fact that it's usually the context-specific one (from focused control or moused control etc), while the pre-sorted list is the global list of the Action Manager.

Optional. The plain list of data rules for the context. Optional. As Action Manager has a large persistent list of data rules, they're given in a way that they're pre-tossed by constant and pre-sorted by priority for each constant.

Tries to get the constant value by evaluating all of the data rules in both lists.

Stores registered rules, already in order for application. Threading: writes should be protected with to ensure consistency (see usage for comments), reads are free.

Registers a data rule that will apply to data contexts created by this object.

Required for debugging data constant values inference. Allows to track the rule supplying the questionable constant value. The rule knows how to produce this constant out of some other constants or the environment.

Registers a data rule that will apply to data contexts created by this object.

Tracks generation for each new added rule, imposes first come first serve order for rules of the same priority, allows for binsearching the rules upon removal.

Gets the data context for executing the actions in the control that currently has user input focus.

Manually-supplied additional data rules. Takes precedence over any other data rules (of the same priority).

Gets the data context for executing the actions based on the given data rules. Note that the focused control is not used for collecting data rules in this overload, but application-wide selection context (like VS selected hierarchy item as current project file, text control, document, etc) still contributes to the context. Registered data rules are also enabled with this context.

Manually-supplied additional data rules. Takes precedence over any other data rules (of the same priority).

Gets the data context for the current application-wide state. Note that the focused control is not used for collecting data rules in this overload, and application-wide selection context is not used either(like VS selected hierarchy item as current project file, text control, document, etc). Only application-wide state like currently opened solution takes effect. Registered data rules are also enabled with this context.

Manually-supplied additional data rules. Takes precedence over any other data rules (of the same priority).

Gets the data context for executing the actions based on the given data rules. Note that no selection/application context is used for collecting data rules in this overload. Only transformation data rules should be applied. This method is different from creating a explicitly on these providers because registered data rules are added to the data rules pool (with a lower priority than your manually-supplied list).

Manually-supplied additional data rules. Takes precedence over any other data rules (of the same priority).

Gets the data context for executing the actions based on the given data rules. Note that the focused control is not used for collecting data rules in this overload. The registered data rules are not taking part in this data context.

Manually-supplied additional data rules. Takes precedence over any other data rules (of the same priority).

Gets the data context for executing the actions in the given screen location. Basically, this is the context for the UI control at the given screen location.

Point, in screen coordinates. Manually-supplied additional data rules. Takes precedence over any other data rules (of the same priority).

Gets the data context for executing actions within the given control.

The control of either kind. Manually-supplied additional data rules. Takes precedence over any other data rules (of the same priority).

Clones the existing data context and extends it with additional given data rules. The registered data rules are not taking part in this data context.

Original data context Manually-supplied additional data rules. Takes precedence over any other data rules (of the same priority).

Exposes the aggregator of registered data rule finders.

A data context that knows no data constants at all.

Helps with binsearching registered rules, ordering them first by priority then by order of appearance within the same priority. Helps with locating the specific rule upon removal with binsearch, as this ordering is unique.

Attribute for impls.

The higher the priority, the sooner the finder is asked (and can promote its own result in precedence of the others).

Takes , prioritizes, and runs queries on them.

Helps with defining a view model whose view should be providing the data rules. Wrap your viewmodel with this type. As a result, it will wrap the view with a layer which registers the data rules provider.

Identifies a piece of data that could be requested from an .

Gets the unique ID of this data constant instance.

Gets the type of the constant. Somewhen soon enough this is likely to become the identity of the constant.

The context, passed to Action. Must be used immediately ONLY, within the same execution session. If you're deferring the execution, extract these parameters and store in your own structures.

State of the context. Used to assert its validity.

Quick check if the context is empty and never returns any value

Returns cached (or evaluates and store) value for the specified

Type of return value Data constant in question Value associated with the

Allows the context to be executed on a different thread

Context's lifetime New data context based on current

Creates a new property bag with a snapshot of this data context.

Creates a property ID identified by a data constant. We convert it to a generic type, and then instantiate for the same T.

Creates a property ID identified by a data constant.

The Windows Forms specific way of providing ui-context-specific s on UI controls.

A data rule that is the internal mechanism of the default 's implementation of for evaluating values of constants. When a constant is requested from the data context, it's evaluated transitively by a chain of rules where the first rule in the chain uses no inputs and just tells the value (e.g. current text control from the environment), and other rules transform it to get the desired data constant out of it (e.g. document from the current text control).

Semantic name of the rule. Crucial for debugging data constants inference.

The output type of the rule.

The rule priority. The lower the priority, the earlier the rule gets chance to contribute. Evaluation stops after some rule yields a valid value. The order of execution for rules of the same priority is undefined in most cases. However, as rules are collected from UI context by bubbling out of the active our mouse-hit control, rules of the control closer to the bubbling origin would be preferred. See for typical values. As you create a rule with class or one of the helper methods, it gets the default priority of .

Attempts to evaluate the data rule.

The data context from which the data rule could optionally get any other constants to calculate the rule result upon. Returns the value if it could be calculated. The possible return values are: (1) A valid value, if the rule was evaluated successfully. No rules would be further evaluated. The value must be of type specified by . (2) A Null value if this rule has insufficient information for evaluation, such as a "text control selection from text control" when no text control could be taken from data context. The remaining rules will be evaluated in this case. (3) The VT_ERROR/DISP_E_PARAMNOTFOUND value, which means that the rule knows and understands this context and usually can produce a result, but right now (with current user selection etc) cannot yield a value. In this case rules with larger priority values will not be processed, and Null will be returned from the data context for this constant, unless some of the remaining rules of the same priority provides a value. Evaluation of the remaining rules of the same priority is not prevented because their relative order is not well defined.

The default data rule implementation with default priority.

Creates a constant data rule (no evaluation involved).

Creates a data rule that evaluates a function, possibly requesting other constants from the data context transitively. Out of the return type variations supports Null and a meaningful value. For the usually-available-but-now-missing value, see another overload.

Creates a data rule that evaluates a function, possibly requesting other constants from the data context transitively. Unlike the other overload, supports all of the return type variations. The boolean in the tuple means whether the value would usually be available in this context. Your function could return the following tuple combinations: (1) {meaningful-value, True}: evaluation succeeded. (2) {Null, True}: evaluation recognized the context and usually would return smth, but right now there is no value available. See for further details. (3) {Null, False}: evaluation has no idea as of what to return. See for further details.

The last-chance data rule to be called only even no other data rules for this constant could yield a result.

The data rule to be called before all the others. For example, to assert the main thread.

Helper class for creating lists of data rules.

Starts a new list of data rules.

Adds another rule to the rules list. Modifies the original list. Fluent.

Sample priority classes for data rules.

The highest priority. Used for assertion data rules that should be executed before all the others.

Default priority. Most of data rules be at this level.

Ambient data rules taking context from the environment. For example, Visual Studio selected hierarchy item is turned into a project model element. Would not be called if any of the product rules are able to provide a value for the constant.

Last-chance data rules providing an arguably useful value in case it couldn't be inferred from normal rules or host environment. For example, if there are no declared elements available, use the project model element to expose it as a "declared path" to make it searchable etc.

Overrides the data rule priority to make it a last-chance-fallback to getting the current selection of the application environment (eg VS). This rule is only active when a Data Context with current selection is requested () is present in the data context.

Overrides the data rule priority to make it a last-chance-fallback to application environment (eg VS).

Rule name for rules inference problems diagnostics. Output data constant of the rule. Rule function.

Overrides the data rule priority to make it a last-chance-fallback to getting the current selection of the application environment (eg VS). Is deactivated on background threads. Use this when calling into VS APIs which are primary-thread-only. This rule is only active when a Data Context with current selection is requested () is present in the data context.

Overrides the data rule priority to make it a last-chance-fallback to application environment (eg VS).

Rule name for rules inference problems diagnostics. Output data constant of the rule. Identifies the main thread to which this rule affines. Rule function.

Overrides the data rule priority to make it a last-chance-fallback to getting the non-selection-dependent state of the application environment (eg VS). See for details. This rule is only active when a Data Context with current selection is requested () is present in the data context.

Overrides the data rule priority to make it a last-chance-fallback to application environment (eg VS).

Rule name for rules inference problems diagnostics. Output data constant of the rule. Rule function.

Operates as a combination of and , which means that this rule is active when either selection or ambient information is requested (any of the or constants is present). See documentation on the above mentioned rule kinds for details.

Overrides the data rule priority to make it a last-chance-fallback to application environment (eg VS).

Rule name for rules inference problems diagnostics. Output data constant of the rule. Rule function.

An entity to look for an based on the current cursor position or current UI control.

Gets the data provider for the control that currently has user input focus.

Gets the data provider for the control that is located at the given screen point.

Gets the data provider for the given control.

Exception to report application performance issues.

Shows the Focus Monitor which helps to learn where keyboard focus has gone, after what, and at which stack trace.

This name should be applied to the focus monitor view to allow filtering it away from the focus tracking results.

Base log entry object of the viewer.

Log entry faked by the viewer.

Log entry which replaces focus reports inside the focus monitor UI.

Log entry based on a real report from focus tracker.

callerHint should be sanitized, see e.g. JobUpdateProjectFiles.ExecuteUpdate: file.Name ProjectModelUpdaterImpl.UpdateOrCreateProjectAsyncImpl : projectDescriptor.Name

Core implementation of reentrancy guard freeze monitor. It implements all the logic except for capturing stack traces and errors reporting.

VS never shows a yellow bar for hangs for less than 5 seconds

If guarded action execution time exceeds this threshold, a freeze will be reported.

How frequently it is checked whether there is pumping during guarded action execution.

Collection of action names not to be monitored (for whatever reason).

Fired on main thread when a freeze is detected.

An info about reentrancy guard freeze.

Guarded action name. Names of all executed guarded actions. There could be many of them in case of lifting(s). Total guarded action execution time. Max period without message pumping. Could be either: string: a description why stack traces have not been captured; Exception: an exception occurred during capturing stack traces; JetBrains.Platform.ClrStack.Caller.CaptureStackTracesOfAllThreads.StackTraces: the stack traces.

An info about reentrancy guard freeze.

Guarded action name.

Names of all executed guarded actions. There could be many of them in case of lifting(s).

Total guarded action execution time.

Max period without message pumping.

Could be either: string: a description why stack traces have not been captured; Exception: an exception occurred during capturing stack traces; JetBrains.Platform.ClrStack.Caller.CaptureStackTracesOfAllThreads.StackTraces: the stack traces.

If a path points to a folder whether to remove the folder itself or leave it but remove all nested files and folders

File or folder location

How to clean

Creation time of the file or folder

The most recent access time of all the files within

The most recent write time of all the files within

How much time did it take to evaluate

Total size in bytes

Errors encountered if any

Name of the entry. I.e. caches folder

How old should be the files (the most recent file's last access time within folder) to get the path cleaned

Shell component that performs automatic disk cleanup when enabled. Enabled means that both and are set to true.

Whether automatic cleanup is allowed by the program.

Shell-level component that performs disk cleanup of specified folders

Asynchronously collects data about files and folders matching specified pattern.

Cancellation token Path pattern as in msbuild with environment variables. I.e. %temp%\JetBrains\**\*.log

Performs cleanup of specified path patterns when files and folders are older than specified timespan.

Cancellation token Path patterns Dictionary of paths processed with size and exceptions if they happened

When Shell is running, takes over Exception Reporting to provide smart behavior: show popup exception notifier, store exceptions, submit the whole list.

Central class of the Exception Reporting subsystem.

Gets the task executor passed to nested strategies to handle the exceptions.

Identifies the owning thread.

Main constructor

Looks for our company/product names in the stack trace.

Starts listening logger events with this exception reporter. Previously listening exception reporters are stacked beneath and deactivated until this method is reverted by disposing of its return value.

Free-threaded, lock-free reads, copy-on-write. Stacks reporters, the last one is active.

Exception occurred. Dispatch to reporter on top of stack. Might be empty, as we would never remove exception listener.

Returns true if this storage is meant to store exceptions. Otherwise returns false.

Returns the path to the exception storage.

Components exporting this interface are called to add data to the exception when an exception is about to be reported. Use (NOTE: it's important to use this overload as the others are non-functional in Production mode!) on the object of the data you're given to add exception data to the exception object.

Exception reporting value in the Platform Core.

Central property for deciding whether to show any exceptions to the user. Sometimes we'd like to suppress exception notifications at all (eg for trade show demos), in these cases this flag goes low. The composite value of whether to report exceptions, this takes into account both the build config and current shell internal mode.

Components exporting this interface are called to add data to the LeakedSolutionException exception.

Unlike (which is called when the exception is reported), this provider is called at the moment when a solution is about to be closed. The exception will be thrown later or won't be thrown at all. This interface is declared here to be accessible from any asseblies (e.g. IntegrationTestsServer.Server).

Generic memory leak exception.

Stores data from previous exceptions that matched this one

Additional text in the header, just before the full stack traces of the exception. Might contain environmental info, build description, etc. Most of the technical data must be added to the exception data itself, with inside your implementation of . It will appear in the detailed stack traces among the data field of the outermost exception. If you'd like your data get into the header text, call inside your implementation of . Use sparingly.

Adds to the .

Product configurations (includes env, CLR, edition, internal mode, etc).

Exposes the SCC revision of the codebase off which the host package was built. Lists packages which contain the activated env zones.

The About Box has detailed info on all packages' revisions.

Exposes the SCC revision of the codebase off which the host package was built. Lists packages which contain the activated env zones.

The About Box has detailed info on all packages' revisions.

Exposes the SCC revision of the codebase off which the host package was built. Lists home packages of subproducts. As a Shell component, only activates in Shell.

The About Box has detailed info on all packages' revisions.

Exposes the SCC revision of the codebase off which the host package was built. Lists home packages of subproducts. As a Shell component, only activates in Shell.

The About Box has detailed info on all packages' revisions.

Uploads a file to uploads.jetbrains.com and returns the folder id.

Build User-Agent like: "ReSharper/2026.1 EAP 1 D (build 261.0.20251021.173616-eap01d)"

Materializes files from the given report attachment providers, zips them into a single archive and uploads it. Returns uploads.jetbrains.com ID or null if not available.

DataFlow extension methods that require a Shell.

Prevents any property modifications if called on any thread but the primary one.

Prevents any collection modifications if called on any thread but the primary one.

Prevents any property modifications if called on any thread but the primary one.

Assigns a new value to the property under a on the primary thread, asynchronously. The logic is not used, the asynchronous is always called instead, even if allowed to in the moment. This guarantees that the property value assignments will always be serialized (eg a later will not be overwritten when a previous gets to run).

Ensures that the property is modified (and the events are fired) in a guarded context only.

Ensures that the signal is fired in a guarded context only.

Ensures that the collection is modified (and the events are fired) in a guarded context only.

Ensures that the property is modified (and the events are fired) on the only.

Ensures that the collection is modified on the only.

Ensures that the list is modified on the only.

Ensures that the is fired on the only.

Establishes a data flow between two properties. The assignment to the target property only happens in the guarded context on the specified thread. It is guaranteed that the values are properly serialized, ie a delayed early value will not overwrite a later direct execution. Not suitable for high-throughput property changes, as it schedules a new guarded execution for each change. Use in such cases.

Supports the mode.

Establishes a data flow between two signals. The firing of the target signal only happens in the guarded context on the specified thread. Not suitable for high-throughput property changes, as it schedules a new guarded execution for each change. Use a in such scenarios.

Supports the mode.

Establishes a data flow between two collections. The changes to the target collection only happen in the guarded context on the primary thread. It is guaranteed that the values are properly serialized, ie a delayed early value will not overwrite a later direct execution. Returns a cookie for terminating the flow. Not suitable for high-throughput changes, as it schedulles a new guarded execution for each change. Uses the given callback merger for guarding the changes.

Helper for .

Fetches data about product releases from - web: https://data.services.jetbrains.com/products - local file for testing purposes: %localappdata%\JetBrains\Shared\vAny\data.json

See https://github.com/aspnet/DataProtection/blob/master/src/Microsoft.AspNetCore.DataProtection/Internal/DockerUtils.cs for the implementation details. Copyright (c) .NET Foundation. All rights reserved. Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

Checks whether specified path is a root path in a docker

Path to check Docker info

Checks whether specified path is in a docker container

Path to check Docker info

Helper class for scanning a directory for files matching a pattern

Main storage of FileSystemTracker Internally it is a trie, where each node corresponds to a directory or a file. For each node we store reference counters, which represents requests which are made through Advise/Unadvise changes, a list of sinks and optional file system watcher. For example, the trie could have the following structure: C: └───work └───projects (Rc = 0, Watcher) │ x.sln (RcFile = 1) ├───a │ │ a.csproj │ │ a.cs └───b (RcRecursive = 2, Recursive Watcher) │ b.csproj Which is created if we have the following requests: Advise file changes for C:\work\projects\a\x.sln Advise recursive changes twice for C:\work\projects\b\ System watchers can only be created on directories, therefore the system watcher for file requests are created on the parent directory. Filter events from specific directories. If the path exists in the dictionary it means, that events from the corresponding watcher should be restricted only to files, mentioned in myDispatchFilerFile dictionary. Bool Value means nothing. All paths to files, which were added via . Bool Value means nothing. List of reasons why the watcher for this directory cannot be created. Null otherwise. Ref counters fields Ref counters Indicates that the node is not stub and should be presented in the trie as Data Describes the path in trie to node. There is no "get parent" operation in the tree, this helper class used to simulate it. It is much faster than the alternative way - finding nodes by querying dictionaries on each intermediate node. Describes the path in trie to node. There is no "get parent" operation in the tree, this helper class used to simulate it. It is much faster than the alternative way - finding nodes by querying dictionaries on each intermediate node. Modifies internal state. Enumerator have to be disposed! intermediate nodes without data are also returned! trie cannot be modified while enumerating! Modifies internal state. Enumerator have to be disposed! intermediate nodes without data are also returned! Debugger purposes only, thread unsafe! Debugger purposes only, thread unsafe!

For file existence caches, i.e. AssemblyExistsService

For file information caches

Subscribes to the file changes by . Requires the call to when tracking the changes are not necessary amy more. It is preferred to use the overload with

File path to track changes Cookie to be passed to

Subscribes to the directory changes by . Requires the call to when tracking the changes are not necessary amy more. It is preferred to use the overload with

Directory path to track changes Whether to watch sub directories Cookie to be passed to <see cref="UnadviseChanges"/> Just hangs tracker on the folder. In some cases the on-change-action will be executed externally by the ExternalChangeProcessor

Unsubscribes from file or folder changes.

Cookies to unsubscribe

Subscribes to the file changes by with specified . No call to is necessary. When called from background thread and the lifetime gets terminated, no subscription is made and invalid cookie is returned.

Lifetime of subscription File path to track changes Cookie. Not used in most cases

Subscribes to the directory changes by with specified . No call to is necessary. When called from background thread and the lifetime gets terminated, no subscription is made and invalid cookie is returned.

Lifetime of subscription Directory path to track changes Whether to watch sub directories Cookie. Not used in most cases

Listens for changes in and executes on it (on FileSystemTrackerCommit thread in async mode and on main thread in sync mode). Delta argument of receives only changes related to Note, if happens in containing folder the change will be received

Listens for changes in and executes on it (on FileSystemTrackerCommit thread in async mode and on main thread in sync mode) Delta argument of receives only changes related to Note, if happens in containing folder the change will be received

Queues immediate file system changes commit on separate thread (async mode) or fires Changed event on main thread (sync mode).

Whether file system changes are allowd to commit automaticall when detected. Obsolete. Use instead.

Whether auto-commit is allowed currently. It is true when and no active suppressors set by

Forbids changes in folder to be propagated to the system. Necessary for caches folder that may be located inside project.

Period of time when folder should not be listened to Path to the folder

Prevents file system watcher merge to listen changes in the whole folder. I.e. for temp folder or drive root.

Period of time when folder should not be listened to Path to the folder Reason not to listen to the specific folder

Checks whether the specified folder is allowed to be listened to.

Path to the folder True if the folder is allowed to be listened to

Fires on file system change from OS in separate guarded thread (async mode) or in main thread (sync mode).

No help topic (default value) Empty help topic (opens the start page of the product help)

Adapts ICommandLine to be used with ICommandLineMapper.

One parsed parameter of the command line.

The key to the command line parameter. Null or "" on a non-keyed parameter.

The command line parameter value. Null or "" on a command line key without a value.

Defines a command-line switch that will be known to the shell and registered with the hosting app, as needed.

The name of the command line switch, without the prefix. The number of parameters of the command line switch. Description of command line switch

Gets the name of the command line switch, without the prefix.

Gets the number of parameters of the command line switch.

Description of command line switch

Parsing rules: Keyed parameters start with “/” or “-”. Non-keyed parameters don't have this prefix and wholy go to the value. The keyed parameter is of the “key=value” or “key:value” form, where value might be omitted with or without the separator. All parameters afer "--" are non-keyed. "/" support is limited to Windows-only ( ( '/'|'-' 'key' ['='|':' ['value'] ] ) | ( 'value' ) )*

The startup directory which is required for treating relative paths in command line args. Parsed command line arguments. The args[0] is a first argument not an executable path. Raw command line. It's required if GetNonKeyedTail feature is used, otherwise it might be null. Raw command line starts with full executable path.

Array of defined keys: /Key[=Value]

Strings, that does not start with '/'.

Forms the complete standalone host command line parameter presentation.

Command line argument name and value (either optional, but not both at a time). Product name (prefixes the arg). If this is the default product of the standalone host, its name can be omitted in the host command line (non-product-name-prefixed keys are attributed to the default product of the host, if there's one on that host).

Forms the standalone host command line containing multiple parameters.

Each parameter will be presented with , see there for details. Product name (prefixes the arg). If this is the default product of the standalone host, its name can be omitted in the host command line (non-product-name-prefixed keys are attributed to the default product of the host, if there's one on that host).

Gets everything from the current process environment.

Array of defined keys: “/Key[=Value]”.

Strings that do not start with “/” and do not belong to the previous string with a “/”.

Gets all of the command line parameters, and together, in order of appearance. If a standalone application implements the singleton mode, command line parameters from attempted new instances get added to this list of the original instance.

The startup directory of the application. Can be used to restore full paths from relative paths passed to the command line parameters. // TODO: handle the case when sending cmdline keys to the second instance of the application.

You should not be using (or even worse for that task because the current directory of the process might change at runtime (e.g. by open-file-dialog), and the command line arguments should always be interpreted against the current directory at the time the process were started.

Returns command line tail starting from given non-keyed parameter.

Command line tail used when we need to bypass part of original command line to sub-process.

Command line of the host, which includes both product-shared keys and all keys that belong to each product. In VS, created over the VS command line object. In standalone, created over a string array.

See doc on . True in VS, False otherwise.

Gets the string to be passed on the command line to this host so that the product-specific command lines would get for parsing. For calling from s to serve their requests. For example, let's consider a non-default Visual Studio hive with root suffix “Exp”, a key with short name of “SelfDestruction”, for the product named “Kalabash”. This method is given the product-decorated “Kalabash.SelfDestruction” key name (formed from the short name by some ), and yields the full ready-for-VS-command-line “Kalabash.SelfDestruction.Exp” key name. In non-VS or VS default hive, returns the original string. If the product is also the default product of the host (not applicable to VS), the resulting full name will just be the short key name.

Checks if the key is defined in any product loaded in this host.

Command line of the product. Usually created over the host command line, whose keys are then stripped of the prefix identifying the product.

Gets the prefix of the command line keys in the host command line. To parse the whole host command line into the command lines for each of the products, they're filtered by the prefix (usually, "ProductName."), and the prefix is removed from keys.

If there's a default product in the host, its command line keys could optionally be specified without the .

Gets the string to be passed on the command line to this host so that the command line of this product would have the key named defined. If this product is not the default product of the host, the product name will be added to the short key name (to distinguish between keys addressed to different products). The environment (for example, Visual Studio non-default hive) might also add decorations to the key name. For example, let's consider a key with short name of “SelfDestruction” that belongs to the product named “Kalabash”, currently running in a non-default Visual Studio hive with root suffix “Exp”. This method is given the short key name “Kalabash”, and yields the full ready-for-VS-command-line “Kalabash.SelfDestruction.Exp” key name. In non-VS or VS default hive, there is no root suffix. If the product is also the default product of the host (not applicable to VS), the resulting full name will just be the short key name.

Implements the command line of the product over a host command line. Selects those keys that have the prefix of a specific product (or no prefix at all, for host-default product).

Init.

Host command line to filter and strip key names. Prefix of the product (dot not included). Keys with this prefix (followed by a dot) are attributed to the current product and given out. Case-sensitivity flags of the command line request also applies to the prefix. If the host has a default product, then keys without prefix are also attributed to that product. An example is a standalone application (eg DotTrace).

Adapts ICommandLine to be used with ICommandLineMapper. Additionally implements ISupportRawCommandLine.

TODO: decouple the static instance storage class from hierarchy of components which spontaneously flip it, plus external side-effects usages of just ctor like StandaloneCultureContextComponent::Ensure

Generates environment variables required for external processes to replicate the current process's localization context.

A list of environment variables that should be passed to an external process. These variables include all necessary information to restore the same localization behavior, such as the current culture settings and the paths to localization resource files.

Simple rotation animation on the icon image.

Dummy class to yield the underlying static image of a for usages which do not support animation.

Dynamically-generated per-RGB-color icons.

NULL if N/A and should use Uni, otherwise whether to use Dark vs Light.

Original imagery when Themed Icons were first introduced. Some border at the corners (optionally) plus solid fill by the color with slightly rounded borders.

Color shape: paint the color swatch as a rectangle with rounded corners, like with Avalon (new RectangleGeometry(bouns, rx, ry)). That's four straight lines and four arcs.

Custom-painted imagery. Has checkered background and two halves, one with transparency removed (to display the hue) and the other with true transparency.

ColorIconSample Themed Icon generated identifiers: — identifier class, for use in attributes, XAML, and generic parameters; — identifier object, as a field in the identifier class, for use where an value is expected.


                                             
                       `````````````         
                 .                    ``.`   
                .                       `.   
                .                        .   
               `.``````                  .`  
               `.``````                  ..  
               `.``````                  ..  
               `.      ``````            ..  
               `.      ``````            ..  
               `.      ``````            ..  
                .``````      ``````      .`  
                .``````      ``````      .   
                `.`````      ``````     ``   
                    ```............```

identifier class

Returns the set of theme images for Themed Icon ColorIconSample.

Loads the image for Themed Icon ColorIconSample theme aspect Dark.

Loads the image for Themed Icon ColorIconSample theme aspect Light.

Loads the image for Themed Icon ColorIconSample theme aspect Uni.

ColorIconStaticBase Themed Icon generated identifiers: — identifier class, for use in attributes, XAML, and generic parameters; — identifier object, as a field in the identifier class, for use where an value is expected.


                                             
                                             
                 .     ......      ......    
                .      ......      .......   
                .      ......      .......   
                .......      ......      .`  
                .......      ......      ..  
                .......      ......      ..  
                .      ......      ........  
                .      ......      ........  
                .      ......      .......`  
                .......      ......      .   
                .......      ......      .   
                 ......      ......     `    
                       ............`


                                             
                                             
                 .     ......      ......    
                .      ......      .......   
                .      ......      .......   
                .......      ......      .`  
                .......      ......      ..  
                .......      ......      ..  
                .      ......      ........  
                .      ......      ........  
                .      ......      .......`  
                .......      ......      .   
                .......      ......      .   
                 ......      ......     `    
                       ............`


                                             
                                             
                 .     ......      ......    
                .      ......      .......   
                .      ......      .......   
                .......      ......      .`  
                .......      ......      ..  
                .......      ......      ..  
                .      ......      ........  
                .      ......      ........  
                .      ......      .......`  
                .......      ......      .   
                .......      ......      .   
                 ......      ......     `    
                       ............`


                                             
                                             
                 .     ......      ......    
                .      ......      .......   
                .      ......      .......   
                .......      ......      .`  
                .......      ......      ..  
                .......      ......      ..  
                .      ......      ........  
                .      ......      ........  
                .      ......      .......`  
                .......      ......      .   
                .......      ......      .   
                 ......      ......     `    
                       ............`


                                             
                                             
                 .     ......      ......    
                .      ......      .......   
                .      ......      .......   
                .......      ......      .`  
                .......      ......      ..  
                .......      ......      ..  
                .      ......      ........  
                .      ......      ........  
                .      ......      .......`  
                .......      ......      .   
                .......      ......      .   
                 ......      ......     `    
                       ............`


                                             
                                             
                 .     ......      ......    
                .      ......      .......   
                .      ......      .......   
                .......      ......      .`  
                .......      ......      ..  
                .......      ......      ..  
                .      ......      ........  
                .      ......      ........  
                .      ......      .......`  
                .......      ......      .   
                .......      ......      .   
                 ......      ......     `    
                       ............`


                                             
                                             
                 .     ......      ......    
                .      ......      .......   
                .      ......      .......   
                .......      ......      .`  
                .......      ......      ..  
                .......      ......      ..  
                .      ......      ........  
                .      ......      ........  
                .      ......      .......`  
                .......      ......      .   
                .......      ......      .   
                 ......      ......     `    
                       ............`


                                             
                                             
                 .     ......      ......    
                .      ......      .......   
                .      ......      .......   
                .......      ......      .`  
                .......      ......      ..  
                .......      ......      ..  
                .      ......      ........  
                .      ......      ........  
                .      ......      .......`  
                .......      ......      .   
                .......      ......      .   
                 ......      ......     `    
                       ............`

Marks Compiled Icon Cs Classes (). This makes the full set of compiled icons discoverable, and also allows applying zoning to them.

Base class for all C#-only compiled icon classes (which does not involve compiling or loading XAML/BAML). Can be used in generic constraints. Derived classes must be marked with attribute. Must have a public static readonly field of type called Id representing the Themed Icon ID of this icon class.

Gets the available theme images of this icon. This API is the backend for . Also provides for enumeration and discovery. The theme images must be listed in descending priority order. If no exact match for theme aspect is found, the first theme image will be used by default.

Gen 1 icons format: overrides this method to return a set of theme images loaded by static functions from the csexp format. Gen 2 icons format: overrides this method to return a set of theme images loaded by static functions from the tisvg format. Gen 3 icons format: base impl reads literal fields with strings recording theme images in tisvg format.

Identifier of an icon which was statically defined in C# code and precompiled into the product DLLs.

The part catalog type, if it's been initially given. If NULL, then must be non-NULL. This allows to defer binding runtime types and loading assemblies when we've just been enumerating type-identified icons and storing their IDs.

The runtime type, if it's been initially given, or has already been bound from a catalog type. If NULL, then must be non-NULL.

Creates an icon ID from the compiled type, in part catalog form.

Creates an icon ID from the compiled type, in runtime type form.

Gets the full (unique) name of the icon.

Gets the simple (short) name of the icon. Unless the icon pack is specifically marked for isolation, this would be globally unique as well.

Gets the type of the which identifies this precompiled icon.

Gets the Icon Class type as a Part Catalog Type if it's been specified.

Gets the Icon Class type as a Runtime Type if it's been known initially or has already been bound from the catalog type (see ).

Owns identifiers of icons which were statically defined in C# code and precompiled into the product DLLs.

For a Compiled Icon Cs Gen3: it keeps theme images serialized in TiSvg format in literal fields whose names starts with this prefix, then followed with the theme image aspect name.

The core implementation. Loads the actual image from the icon.

Loads the theme icon image.

A helper type for the interface between and . Describes one of the available images in the set.

Ctor with custom lazy-loading delegate.

Ctor which lazy-loads from a TiSvg string in a static field.

If the icon has just one image and no themes, assume this theme hint.

Lazy-loads the image for this theme. Throws on errors. Does not cache, do caching on caller side.

The hint to use when checking if this image fits a certain theme aspect.

Marks Compiled Icon classes (e.g. , ) which declare a compiled icon that the name of this icon should be considered private per-icon-pack and not be validated to be unique thru all the runtime. This means IconPackFlags::IsIconNamesInPrivateSpace.

Owns identifiers of icons which were statically defined in resources and precompiled into the product DLLs.

JET_MODE_ASSERT-only cache. Maps icon name (in lower case) to a pair of the original name case and its owning icon pack.

JET_MODE_ASSERT-only cache. Maps icon name (in original case) to its owning icon pack.

Icon packs. Modification under main thread guard, copy-on-write, free-threaded access.

Check that all icon names are unique across the product. In assertion mode only.

Assign to the icon slot for which there's no info, to avoid subsequent exceptions on calls to the icon.

An array (cells agree to ) of icon data. Each cell is a list of themed drawings. Lazy-loaded (free-threaded manner).

Loads the pack data from resources and into the field. Does this free-threaded, might be loading in parallel on several threads.

Loads the Avalon resource with BAML serialization of the , then calls .

Reads the serialized format, as emitted by the build task.

If the exact set and order of the IDs is known, validates that the loaded set is the same. On the format. Each dictionary entry is a of some icon for some theme. It has two attributes, attached property is the icon ID, and the attached property is the theme of this icon image. The dictionary keys on entries have no meaning, but define the sorting order. In that order, images are sorted lexicographically, first by icon ID, then by theme. This way, you're guaranteed to read all images of the same icon in a row.

Per icon per theme drawing.

Exposes some of the internals for serialization tools.

Composes an icon out of images of other icons.

An icon with effects applied to its image.

Creates an icon with an effect.

The base icon whose image should be transformed with an effect. Optional. Transparency effect, in the [0..1] range, where 1 means no transparency effect is applied. Optional. Turns the icon into a monochrome image, with given color as the tint. to have no tint (grayscale monochrome), Null to have no monochrome effect. A non-zero value denotes the blur radius to be applied to the icon.

Optional. Transparency effect, in the [0..1] range, where 1 means no transparency effect is applied.

A non-zero value denotes the blur radius to be applied to the icon.

Optional. Turns the icon into a monochrome image, with given color as the tint. to have no tint (grayscale monochrome), Null to have no monochrome effect.

Implements applying effects to icons.

An object which maintains some kind of s and can yield actual images for that type of icons. was designed when Avalon s were primary icon image media, and produces the new primary image type, , which is cross-platform and can convert into Avalon / GDI+ / SVG. should be implemented by all new icon owners and older ones should be upgraded so that they supported cross-platform execution.

Type of the -inherited class served by this Icon ID Owner.

Gets the icon image for the given theme. Called by . Notes to impelmentors. You should return some image for each theme given. If you don't understand the theme, return the default image. Some themes might be composed or derived from others, use images for base themes in this case. You don't have to do caching on what you return, even if you're running some calculations to produce the themed image. You will be called only once for the current theme (unless theme is changed to another and back), and the result (together with rasterization, if needed) will be cached by . The cache might be dropped by expiration, but it's considered to be OK to calculate the icon image anew in such a case. If your icon id owner implements , then would prefer to ask for a and render an Avalon out of that, to make sure it matches the provided .

Identifier of the icon whose image is to be retrieved. This ID must be of type specified in . It is an error if an identifier of another type is passed here. Theme (see for details on combining and deriving). Allows querying for other icon images if needed to compose the icon for an ID. How the image retrieval errors could be reported. The image for this theme, or fallback image for base/default theme if not available. NULL means an error obtaining the icon, or that there is no icon available for this specific ID (icon manager would report an error and use the placeholder icon in that case).

Collects and dispatches icon images throughout the application. Applies theming to icons to support different application styles. Generally, you should not be getting icons from it directly. Look for strongly-typed accessors auto-generated in the assembly which loads the icons.

Gets the current theme selected for icons, and notifies of changes.

Gets the icon image in vector or raster form for use with GDI+ WinForms or WPF UI. You should be operating on objects for as long as possible, and only render an icon to the actual theme image when you have to present it. This is the main method for getting the actual theme image for an icon, either for the current theme or changing live with the theme.

For performance reasons, getting an icon does not validate that an icon ID is valid and an image for it exists until you actually try getting some imagery.

Api methods for use as backend by .

An alternative to . Gets an icon by its class identifier rather than object identifier. This way code completion works a bit better because the generic type is guessed through the base type constraint.

Core of the which calls for icon image creation and caches the results for the current theme.

Gets the Avalon image source (via ), converts into a GDIP bitmap, and caches the result. Logs an exception (first time only) and returns a fallback image on failure.

Gets the Avalon image source for the icon and caches the result. Logs an exception (first time only) and returns a fallback image on failure.

Gets the TiImage for the icon and caches the result. Logs an exception (first time only) and returns a fallback image on failure.

Tries to get the Avalon image for the icon. Does not log exceptions on failures, returns Null instead of a fallback value. The result is cached only if successful.

Tries to get the TiImage for the icon. Does not log exceptions on failures, returns Null instead of a fallback value. The result is cached only if successful.

Api methods for use as backend by .

Allows to create ad-hoc temporary icons for use with themed-icons-aware infrastructure which are only available at runtime and have not been compiled into the code. Icons are theming-aware and allow to supply multiple images for different theme aspects.

Just serves images out of for the .

UI assembly theme-sample icons.

Settings for the and Themed Icons subsystem.

Loads and publishes as the theme aspect the generic icon theme settings.

Exposes the current value which would be used in place of Auto in settings. See .

Gets theme aspect for theme selection. It is expected to have no auto/default values (see ).

Substitutes definitive values for autoselections (defaults).

Might have automatic values, those will be substituted by using . Should not have automatic values. Non-automatic values only.

Represents a single strongly-typed icon accessor along with the component instance that is required to render the icon image.

This method does not specify the desired image resolution, so it should not be used. No valid image is retrned by the current implementation.

Gets the icon GDI+ raster image for use in WinForms UI. This image only fits the current theme. You should watch changes and request a new image, or use . The icon is rasterized with device-independent 96dpi for this method. In screen UI, you should better use for higher-resolution icons.

If the icon with such an ID is not registered with the system, an exception is logged and a placeholder image of the standard 16x16 size is returned, and execution continues. The icon (of its natural size), or the standard 16x16 image if the icon is not registered.

Gets the icon GDI+ raster image for use in WinForms UI. This image only fits the current theme. You should watch changes and request a new image, or use . The icon is rasterized with DPI resolution of the current display device. This is preferrable for use in screen UI.

Gets the icon image for use in WPF UI. Note that this might be either a vector image or a raster bitmap. This image only fits the current theme. You should watch changes and request a new image, or use .

Icon identifier.

Don't use. For private use of DotCover only.

Gets the icon GDI+ raster image for use in WinForms UI. This property tracks the active theme and updates the image source upon theme change. The icon is rasterized with device-independent 96dpi for this method. In screen UI, you should better use for higher-resolution icons.

If the icon with such an ID is not registered with the system, an exception is logged and a property with a placeholder image of the standard 16x16 size is returned, and execution continues. The icon (of its natural size), or the standard 16x16 image if the icon is not registered.

Gets the icon GDI+ raster image for use in WinForms UI. This property tracks the active theme and updates the image source upon theme change. The icon is rasterized with DPI resolution of the current display device. This is preferrable for use in screen UI.

Gets the live icon image for use in WPF UI. Note that this might be either a vector image or a raster bitmap. This property tracks the active theme and updates the image source upon theme change.

Gets the live icon image in the original cross-platform Themed Icon Image format. Note that this might be either a vector image or a raster bitmap. This property tracks the active theme and updates the image source upon theme change.

Gets the icon manager which governs the presentation of this icon.

Collects and caches Icon Moniker Owners.

Creates an instance on an explicit iconowners set.

Owner lookup by icon id type.

cannot be a component on itself because its interface, , is exposed by and the component implements it, so there would be two implementations. Previously, would create an instance for itself. However, this caused everyone who required the themed icons early on startup to instantiate the whole theming aggregate. Introduce a separate component for them.

type.

For performance reasons, getting an icon does not validate that an icon ID is valid and an image for it exists until you actually try getting some imagery.

Caches properties with live images (which follow theme changes). Purposes: (1) no explicit lifetiming or strong references so that this stuff could be addressed from WPF; (2) reuse of existing property instance. Maps: strong ref to icon id => weak ref to property. Properties should be gone when they're not needed anymore, but should be held while they're of any use. If icon IDs are transient monikers, they might get wasted before their icon goes off scope, or then recreated => should not drop the entry when IconID is not explicitly used if the property is still there. Properties are not bound explicitly to avoid strongreferences. Instead, they're all bulk-updated when theme changes.

Caches props, see class doc for details. Access must be protected with .

Gets the still-existing property, or creates a new one and does not hold a strong reference to it.

's data for the current theme, caching images after they're first accessed.

Cache what has returned, to let it not be thinking about caching, plus some of the products. Dictionary threading: thread-safe data structure. Data threading: all dispensable; fields can be filled independently and re-calculated freely.

Calls the Icon ID Owner for retrieving the image from it. Should be cached by caller if successful. Because some owners return Ti as native format and some Avalon, this function always returns the native format for caching, and the other format only if requested by caller. Caller should cache all that's been returned.

NULL until calculated; never NULL after that. When cache is dropped, the whole object gets forgotten, and the field does not get NULLed.

If the recent calculation were a no-error one ("TryGet"), but resulted in a value which is going to be cached, and there were errors calculating such a value => store the error until we ask for the value with an error-allowing ("Get") function, and report the error in there.

NULL until calculated; never NULL after that. When cache is dropped, the whole object gets forgotten, and the field does not get NULLed.

Last time this icon was asked for, in units, for cleaning the cache.

When producing an image for this icon and reporting the errors is not allowed (with TryGet- methods family which should not err), records the exceptions which might indicate failures in loading icons so that to report them later.

When asking for this icon with error reporting allowed, yield any pending messages which were recorded while asking with error reporting not allowed (with no-fail TryGet methods).

Build configuration, such as Release or Debug (null - can't determine)

For AssemblyLocation.Location For (BundleFileEntryLocation.BundleLocation, BundleFileEntryLocation.FileEntryIndex) For AssemblyLocation.Location For (BundleFileEntryLocation.BundleLocation, BundleFileEntryLocation.FileEntryIndex) For AssemblyLocation.Location For (BundleFileEntryLocation.BundleLocation, BundleFileEntryLocation.FileEntryIndex) For AssemblyLocation.Location For (BundleFileEntryLocation.BundleLocation, BundleFileEntryLocation.FileEntryIndex)

blessed means that this assembly will not be deleted, changed, etc. For instance - .net framework assemblies

The base key for all hacks.

Service interface to allow AssemblyInfoDatabase communicate with installed platforms

Tries to calculate target framework for the assembly location. Checks if the specified assembly located in platform or nuget folders with known target framework id

Blessed Assembly - this assembly will not be deleted, changed, etc. in the file system. For instance - .net framework assemblies

Fires everytime platforms are going to be recalculated

Fallback usage only

This interface is implemeted in JetNativeHooks.dll. Do not modify it unless NativeHooks.IDL is changed.

This interface is used in JetNativeHooks.dll. Must be synchronized with NativeHooks.IDL.

Coclass for DLLs implementing the hook handler.

This object is exposed in JetNativeHooks.dll. Do not modify it unless NativeHooks.IDL is changed.

Dummy implementation.

The per-window collection of all the available messages.

Gets a virtual message that corresponds to all the messages received by the window specified.

Gets a particluar message on a particular window.

Gets the window whose messages are being accessed via this collection.

A reference to a window to be hooked.

Gets the collection of messages available for this window. To subscribe to or unsubscribe from an event, pick the message you're interested in from this collection.

The hooking manager.

A handle to the current window. Null means “all the windows of the process”.

A particular message of a particular window that could be subscribed to.

Gets the owning hooker.

Gets the WINAPI code of this message.

Gets the window whose message this is.

Advises an event that fires after the message described by the is processed by the .

Lifetime. Not implemented yet. Message handler to be invoked.

A selector of a window to be hooked.

Gets a virtual window that captures the messages for all the windows in the process.

Gets a window from the collection by its handle.

Gets a window from the collection.

Gets a window from the collection by its handle.

Event arguments for the notification.

Gets the hook data as a . Valid for some messages only. Valid within the hook callback only. LIVE, do not modify unless that's intentional.

The per-window selector of all the available messages.

Gets a virtual message that corresponds to all the messages received by the window specified.

Gets a particluar message on a particular window.

A reference to a window to be hooked.

Gets a selector of messages available for the window. To subscribe to or unsubscribe from an event, pick the message you're interested in from this collection.

A particular message of a particular window that could be subscribed to.

Gets the WINAPI code of the message.

Gets the window whose message this is.

Advises an event that fires after the message described by the is processed by the .

A hook lifetime. Allows to notify the handler outside the hook callback function. Executing managed .NET code over the hook function might be undesired at times. Message handler to be invoked.

A selector of a window to be hooked.

Gets a virtual window that captures the messages for all the windows in the thread.

Gets a window.

Gets a window by its handle.

Provides a set of methods to hook Windows messages in the current thread and notify the listeners of them.

A selector of the window and message to be hooked.

Usage: IWindowsHookManager hookman; hookman.Windows.All.Messages.All.Advise(lifetime, false, action); hookman.Windows.All.Messages[WM_msg].Advise(lifetime, false, action); hookman.Windows[wnd].Messages.All.Advise(lifetime, false, action); hookman.Windows[wnd].Messages[WM_msg].Advise(lifetime, false, action);

Advises specific or all Windows messages to specific or all windows in the current thread.

Lifetime. Handle to the window, or Null for all the windows. Windows message to listen to, or 0 for all the messages. Is not implemented yet. Message handler to be invoked.

Advises specific or all Windows messages to all windows of a given window class in the current thread.

Lifetime. Window class name to be advised. Windows message to listen to, or 0 for all the messages. Is not implemented yet. Message handler to be invoked.

Advises all keyboard and mouse messages in the current thread.

Lifetime. Message handler to be invoked.

Advises application active state changes.

Lifetime A boolean property that reflects the current application active state. The behavior of the hook when focus goes to a window of another thread depends on implementation. The old managed implemetation is able to track the main thread only and reports application deactivation when the main thread loses the focus. The new unmanaged implementation monitors all threads of the process and reports deactivation when focus goes to another application.

Advises screen coordinates changes of the specified window.

Lifetime. Handle to the window to watch. A property that reflects current window screen coordinates. The hook does not control whether the window is alive or not. If the window is destroyed the property keeps its last value. When the lifetime is terminated, the property is set to an empty Rect.

Advises root parent window changes of the specified window.

Lifetime. Handle to the window to watch. A property that reflects the current root parent window of the watched window. When the window gets invalid (destroyed) or the lifetime is terminated, the property gets the IntPtr.Zero value.

Fixes mouse wheel behavior so that the mouse wheel scrolls the hovered window instead of the fucused one.

Advises that the foreground thread is about to become idle.

Lifetime. Action to be invoked.

Hooks to all the windows messages in the main thread and notifies the listeners of them.

We have to listen to both WH_CALLWNDPROCRET and WH_GETMESSAGE hooks because they return nonintersecting subsets of messages.

The object that winds up the WH_CALLWNDPROCRET Windows hook.

The object that winds up the WH_GETMESSAGE Windows hook.

Identifies the owning thread.

The quick-lookup map of windows & messages to handlers. Null window handle and 0 message are wildcards. Maps: HWND -> (MSG -> (entry)).

Maps: Window class -> Message -> Handler

The object that winds up the WH_FOREGROUNDIDLE Windows hook.

Dumps the object.

Removes all the event subscriptions by the object.

Internal implemetation of method.

Implements adding/removing the message handler to the map, possibly, with its children.

Handle to the window, or Null for all the windows. Message to listen to, or 0 for all the messages. The handler to be invoked. The external handler that will be used to unsubscribe from this event. Whether to listen to parent windows also, illegal if is Null. Whether to add or remove.

The raw adder-remover of the to the map.

The entry to add/remove, specifies all the keys of the map and the value. Whether to add or remove.

Adds/removes window class message handlers to/from map.

Gets the all-entries enumerator.

Either hooks or unhooks the underlying WinAPI hook, depending on whether there are any clients in the map.

Either hooks or unhooks the WH_FOREGROUNDIDLE hook, depending on whether there are any clients.

The hook has caught some message, call the listeners. Should return True so that the chained callers would succeed in processing the message.

Removes all the hooks.

An entrty in the hooks list.

Inits all the fields of the instance, see corresponding attributes for comments.

Handler to be invoked on capture.

Code of the message to capture. 0 is a wildcard.

Gets the handler that the external user passed in when subscribing to the event. Needed to look up all the events from a particular user in case it bulk-unsubscribes.

The original window, as specified by the client when subscribing, a child of . Not listened by this hook entry. It's rather a mark that the hook entry has been added in order to listen all the parents of the window. Needed to remove all of such entries when unsubscribing.

The target window that should be spied in response to this hook entry. Null is a wildcard.

Dumps the entry.

A selector of the window and message to be hooked.

NOTE: isDeferredProcessingAllowed ignored by this implementation

Returns a that represents the current .

A that represents the current . 2

Wraps 's direct hooking features into the interface.

Native Windows hook implementation.

Identifies the owning thread.

A selector of the window and message to be hooked.

Implements hooking to local and global windows messages by the means of .

External handler for the hook events.

Handle to the hook, assigned by .

Hook code.

Hooks the given event-handler to the messages specified by the code.

Code for the messages to hook. External event handler.

An internal constructor.

Code for the messages to hook. External event handler, Null for none. Internal WinAPI hook handler, Null to use the stock one that notifies the .

Determines whether the hook is a global scope only hook and needs a HINSTANCE specified etc when hooking. All the other hooks could be set either as a global or a per-thread.

Uninstall the hook.

event-like delegate for the external hook event handlers.

Whether to call next handlers in the chain (True), or drop the request at this point (False).

Manages the windows hooks. Creates a native implementation wherever possible, or substitutes with a managed one when native not available.

Native Windows hook DLL name.

Instance (could be native or managed).

Gets the current instance of a WindowsHookManager.

A selector of the window and message to be hooked.

Advises specific or all Windows messages to specific or all windows in the current thread.

Lifetime. Handle to the window, or Null for all the windows. Windows message to listen to, or 0 for all the messages. Is not implemented yet. Message handler to be invoked.

Advises specific or all Windows messages to all windows of a given window class in the current thread.

Lifetime. Window class name to be advised. Windows message to listen to, or 0 for all the messages. Is not implemented yet. Message handler to be invoked.

Advises all keyboard and mouse messages in the current thread.

Lifetime. Message handler to be invoked.

Advises application active state changes.

Lifetime A boolean property that reflects the current application active state.

Advises screen coordinates changes of the specified window.

Lifetime. Handle to the window to watch. A property that reflects current window screen coordinates.

Advises root parent window changes of the specified window.

Lifetime. Handle to the window to watch. A property that reflects the current root parent window of the watched window.

Fixes mouse wheel behavior so that the mouse wheel scrolls the hovered window instead of the fucused one.

Advises that the foreground thread is about to become idle.

Lifetime. Event handler to be invoked.

Arguments for the -emitted messages.

Gets the windows message hooks manager you're subscribed to.

Gets the handle to the window that is receiving the message.

Gets the safe handle to the window that is receiving the message.

Gets the message ID.

Gets the "WORD" parameter.

Gets the "LONG" parameter.

Gets or sets the message result. Applicable to the WH_CALLWNDPROCRET hook only. For other hook types always IntPtr.Zero.

The cursor position, in screen coordinates, when the message was posted. WH_GETMESSAGE hook returns this value, for other hook types we get it using GetCursorInfo().

The main entry point to access misc data stored in files/ Windows registry/ Windows credentials etc. This data is persisted between product runs or even shared between products.

Returns existing or creates new file access. Works on any platform.

Absolute path to the file Access purpose File access for the specified path

Returns existing or creates new Windows registry access on Windows or on other platforms.

Windows registry key location Key name Access purpose Registry access on Windows or Isolated storage access on other platforms

Returns existing or creates new Windows registry access on Windows or file access on other platforms.

Component to access product settings location Application host details (Shared in most cases) Key name Access purpose Registry access on Windows or file access on other platforms

Returns existing or creates new Windows credential access on Windows or on other platforms

Key name Access purpose Windows credential access on Windows or empty

Returns existing or creates new protected data file access on Windows or on other platforms

Component to access product settings location Application host details (Shared in most cases) Key name Access purpose Protected data file access on Windows or empty

Access to some data shared between projects. The date can be stored pretty much anywhere: file on disk, registry, windows credentials.

Which data is stored. What for.

Where it is. Could be file path, registry key, etc

Generates batch script to remove the data

The script to remove the data

Tries to removed the data.

Whether succeeded

An option a user may accept or decline

Id of the option. Used in exchange with server

Version of the option. Its text etc. may vary in time

Presentable consent option title

Text the users accepts or declines. May include html a tags. I.e. JetBrains Privacy Policy

Default consent state or the last known state if AcceptedTime is true

Milliseconds since 1/1/1970 when user most recent time made his mind

Whether the option is removed on server

All known consent options and their opertaions

All not removed constent options. Value may be null until initialized

Checks whether consent option accepted

The option in question Consent option

Sets consent option values according to user's choice

Pairs of consensent options with their accepted state Server, user or API

Fired when something changed in consent options so the user needs make his mind about them

Processes consent option changes received from server

Response string

Fired when user accepted or rejected any options.

Relevant when is because the usage is calculated differently and will start later than the evaluation itself

For testing purposes. Normally it is regulated by

Use to report license entity usage on current date. The signal is safe to be called numerous time during the same date.

Sets today as last used date and updates . Returns true if anything changed.

Sets today as last used date and updates but only if the evaluation has been started by an explicit signal. Returns true if anything changed.

Marker interface for description objects which should not produce user notifications or be shown in the overall status despite containing warnings

Optional notification title

Optional notification body

Optional URIs to open

Document that need to be accepted in order to continue work with the product

Enumerates all known documents

Returns document state

Sets document state. If is not the will appear in

The dicument that requires user consent to allow the product running

Display name of the document

Version of the document

Document text in HTML

Name passed to

Provider of the documents that require user consent. Environment or Shell Component.

Why dialog will be shown

Licensing view model

Documents that need to be accepted. I.e. privacy policy, EULA etc.

Consent options

Current licensing region

Collection of entities licensed at the moment

Shows license dialog using handlers registered with

why the dialog is shown

Register handler that will be called to show license dialog. Normal reasons to show: 1. when shell is started and there're changes in all/ allowed entities list comparing to previous product start 2. allowed entities list is about to change when license goes off and similar 3. user's request to show license information

Handler lifetime Callback to show dialog Callback to decide whether license dialog is to be shown in spite of there is no change to the previous start

Fired after license view model is persisted.

Access current view model. Normally, the action is called synchronously, but the behaviour may change

Lifetime while the action still makes sense to execute Action to be executed over the

Access current view model. Normally, the action is called synchronously, but the behaviour may change. Silences requests to show license dialog.

Lifetime while the action still makes sense to execute Action to be executed over the

Returns information about licensed entities

Returns license check info for all licensed entities.

True if there's no previous data

Environment specific: List of entities subject to license check last time the product is started in given environment.

Environment specific: List of entities that passed license check last time it was performed in given environment

Result with description objects. In a simple case we will use ToString to produce text and/ or user notifications in case of warnings. Use when you need something custom. Objects in must be equatable (implement Equals, GetHashCode if necessary).

Objects must be equatable (implement Equals, GetHashCode if necessary)

Collection of entities the check for which is successful

Fired when result is changed, but AllowedEntities may remain intact. I.e. one more checker allowed entity that is allowed already

License check info if applicable

ILicensedEntity is an entity that represents a product if we use former terminology. The entity describes all the way it can be licensed and the zones it enables if properly licensed. If the product is free its should have the following property values * is null * is null * is empty * is empty If license to ReSharper Ultimate suits to the product make sure: * . contains value * contains value * contains value Zones marked with must be allowed by any of running. The zones allowed are determined by property. or can be used to generate signature. See https://jetbrains.team/p/net/repositories/dotnet-licensing/ for more details. Mark your licensed entity with to provide icons

Name of the entity used to store entity-related data. Should not be changed between product versions unless product differs

Name of the entity used in presentations

Version of the entity. Since the entity more or less corresponds the product it is the product version

Product code corresponding to the products consisting of the only license entity

Optional custom description when no license found

Optional description that will replace in the UX

Optional custom description when product is properly licensed.

Optional result with description that will be combined with the license description in the UX

A list of values corresponding to entities which have to be active in order for the functionality behind this licensed entity to work.

Text which is shown when any of the requirements are not satisfied.

Can be used to mark licensed entities which are not in the Products section but still can be turned on and off.

Implement the interface by the if the entity supports free evaluation.

Supported trial modes

Guid (with braces), that is used to store Date marker

Number of days, free trial period lasts

Number of free trial days, after which feedback is requested. Negative value means feedback is never requested.

Identifies, when to start informing user that, his free trial period ends up

Identifies the way the entity considered used. If the value is every day corresponding is running will be count automatically. If is used fire every time the entity is used.

Opt-in subscriptions ids and their text to pass to

Every time the licensed entity is enabled it is considered used

Every time the licensed entity is enabled it is considered used for each day since last check

The licensed entity is considered used if and only if the signal is fired. Normally, the signal is fired from corresponsing actions

The evaluation starts without user input but does not expire initially. The licensed entity is considered used for the first time if and only if the signal is fired. After the signal is fired for the first time, every time the licensed entity is enabled it is considered used for each day since the last check.

When checking subscription license we need to verify product creation time against subscription period. If we just use IApplicationDescriptor.BuiltOn there might be situation when version X.0 is eligible to use because issued within subscription period, but bugfix X.0.1 is issued when the period is over. To handle this the property is set to the date of X.0 release. Normally, TeamCity build parameter TC_DateTimeForSubscriptionCheck is used (). If subscription is not available one may return

Implement the interface by the if the entity supports user licenses if form of user name/ license key.

License agreement in rich text. NULL if no license agreement is necessary to show when license is entered

Determines whether the product should check for multiple instances running simultaneousely over the network.

Implement the interface by the if the entity supports obtaining tickets from locally installed license server.

JetBrains license server supports ProductFamily as guid without braces !!!

Version to request from license server. Normally it equals to product major version * 1000 () If the product supports subscription only use version equal to buildDate.Year*10000 + buildDate.Month*100 + buildDate.Day.

Edition to request from license server.

Return true if your product had subscription previously. In the case will be used to issue ticket in case of old license server.

Url to show the user who uses pirated blacklisted license server. See MKT-6044

Product name used for presentation

Product code to be requested from JetBrains license server

Product edition to be requested from JetBrains license server

Version to request from JetBrains license server. Normally it equals to product major version * 1000 () If the product supports subscription only use version equal to buildDate.Year*10000 + buildDate.Month*100 + buildDate.Day.

Used to turn on/ off

The compound model. Set when it is initialized

License data to store

Default checker by product version and subscription

Product's public key Product version in the form of (major*1000+minor*100). Normally, just major is used. Minor is used if and only if it is payed, which is not expected to happen under normal circumstances. Date of the release build which is used for subscription check. Use if no subscription available. Additional check if necessary. Default checker by product version and subscription

Helper property used to distinguish current data from old

JetBrains account used last time

User id corresponding to the account

JWT token corresponding to the account

Account info if exists (Name, Last Name etc)

Asset ids used

Encoded data about all the assets available to the account

Time of the next check

Time until which assets must be validate

Removes corrupt/ duplicated asset data

Squeezed data or null if nothing to squeeze

Loads JetBrains account access information from registry corresponding to ProductSettingsLocationFlag.AnyProductAnyVersion (HKEY_CURRENT_USER\Software\JetBrains\Shared\vAny\JBAccount)

Loads JetBrains account access information from registry corresponding to ProductSettingsLocationFlag.AnyProductAnyVersion (HKEY_CURRENT_USER\Software\JetBrains\Shared\vAny\JBAccountSettings)

Logging in with user name and password Or userId instead

JetBrains account name password userId. Used for testing purposes

Validates asset data.

AssetData to validate True if validation should continue. False on network error.

Next check time is last time returned from server, but if no data returned use random time between 1 and 2 hours

Next check times returned from server Next check time adjusted

Loads JetBrains account access information shared with Idea/ Toolbox (HKEY_CURRENT_USER/Software/JavaSoft/Prefs/JetBrains.JetProfile.UserId) (HKEY_CURRENT_USER/Software/JavaSoft/Prefs/JetBrains.JetProfile.UserLogin) (HKEY_CURRENT_USER/Software/JavaSoft/Prefs/JetBrains.JetProfile.IdToken)

Shows license dialog using handlers registered with

why the dialog is shown

Modifies successful license check info with warning received from license server

License check info to update Warning message or null License check info type Updated license check info or the one passed

Modifies not failed license check info with error received from license server

License check info to update Error message or null License check info type Updated license check info or the one passed

Old license server version. In case of subscription must be year*10000 + month*100 + day.

New license server data. VersionNumber = major * 1000

New license server data. Release date for subscription check in the form of year*10000 + month*100 + day

Helper constructor.

Product version to send (Normally, major * 1000) Release build date to check subscription (y*10000 + m*100 + d) Old license server compatibility. True if there was a subscription previously) Optional string to be added to authorization header

Helper constructor.

Server error. Should be treated as plus maybe extra notifications

Action requested to execute by server (see RSRP-460838)

Product code is required by API but never used

Comma-separated LicenseIDs of enetered licenses

JBA userId if in JBA mode

Last known CRL version

Last known black list version

Product code is required by API but never used

Name of the document to ask

Last known version

Comma-separated LicenseIDs of enetered licenses

JBA userId if in JBA mode

Consent options in the format of: consentId1:version1:accepted1;consentId2:version2:accepted2;... consentId - consent option id (e.g. mkt.newsletter.webinar) version - current consent version (e.g. 1.5) accepted - parameter showing if a user has given a certain consent (0 - true, 1 - false)

Product build date in the format of YYYYMMdd

Whether it is EAP build or RTM

HTML text of the document requested. Null or empty when no new document available

New document name. I.e. privacyPolicy -> eula

Consent option changes if any.

UserAgent to pass to to identify us later

When is and both urls are not empty it means that OAuth is required

Product code is required by API but never used

Old format license key (we do not need user name to lookup in database)

Assignee's first name. Ignored if is personal

Assignee's last name. Ignored if is personal

Assignee's email. Ignored if is personal

New license key if exchange is applicable

Null means not available

Describes OAuth URIs, supported providers etc. Null means OAuth is not supported

ProductCode for ObtainAgreementRequest and maybe something else. Calculated base on

Details of the JetBrains account obtained from JWT token or accountInfo endpoint as described in https://jetbrains.team/p/bad-public-docs/documents/License-Server/a/IDE-OAuth-Authorization-Flow { "full_name": "John Doe", "jba_login": "john", "email" : "john@doe.com", "userpic_url" : "http://example.com/image" "account_id" : 12345, "user_id" : "qwerty", }

Product code for which trial license is requested

Not used actually

Product version requested as major*1000+minor*100

Release date for subscription check in the form of year*10000 + month*100 + day

User id obtained by JetBrains account credential check.

Product code as stated in products.json on a server

Not used actually

Product version requested as major*1000+minor*100

Release date for subscription check in the form of year*10000 + month*100 + day

Milliseconds to revalidate the license

Period in milliseconds to perform successful validation. If the period expires validation considered failed.

User id obtained by JetBrains account credential check.

Product code for which trial license is requested

Not used actually

Product version requested as major*1000+minor*100

Release date for subscription check in the form of year*10000 + month*100 + day

Options to receive tips etc. Comma-separated option ids with value See https://docs.google.com/document/d/1OAMSstNVTpnyHtF7YQv-tupJ-Kty9oU8br2INf6gGqs/edit?ts=60bf4fcc#heading=h.7ax1c9cqhswr

ID of the license with which IDE is licensed. Relates to

Product code is required by API but never used

License Key entered by user. Licensee name is not necessary.

License hash for new keys. Used to check if regeneration is necessary.

Product version requested as major*1000+minor*100

Release date for subscription check in the form of year*10000 + month*100 + day

Seconds to revalidate the license

New license key if changed.

User id obtained by JetBrains account credential check.

Asset id to be validated

Product code as stated in products.json on a server

Not used actually

Product version requested as major*1000+minor*100

Release date for subscription check in the form of year*10000 + month*100 + day

Hash of the license included in AssetData

Milliseconds to revalidate the license

Period in milliseconds to perform successful validation. If the period expires validation considered failed.

New license key corresponding to the asset

Handling ticket properties according to https://jetbrains.team/p/bad/repositories/JetProfile/files/4407b142ef8dfc31619a39f933e9ed26b26f4f0b/license-service/client-api/src/main/java/com/jetbrains/ls/responses/TicketProperties.java?tab=source&line=1&lines-count=1 https://jetbrains.team/p/bad/repositories/JetProfile/files/4407b142ef8dfc31619a39f933e9ed26b26f4f0b/license-service/client-api/src/main/java/com/jetbrains/ls/responses/ObtainTicketResponse.java?tab=source&line=38&lines-count=1

Loads license server info from registry corresponding to ProductSettingsLocationFlag.AnyProductAnyVersion (HKEY_CURRENT_USER\Software\JetBrains\Shared\vAny\IdeServicesAIConfig)

Loads license server info from registry corresponding to ProductSettingsLocationFlag.AnyProductAnyVersion (HKEY_CURRENT_USER\Software\JetBrains\Shared\vAny\LicenseServer)

Loads license server info from registry corresponding to ProductSettingsLocationFlag.AnyProductAnyVersion (HKEY_CURRENT_USER\Software\JetBrains\Shared\vAny\LicenseServerSettings)

Name of the model. Used to distinguish between current/ temporary etc.

License data used when model is created.

Signal is fired when Data is changed. Used to save data when necessary.

All licensed entities involved in license check process. TODO: who deals with entities that are not licensed if any?

All licensed entities involved in license check process with their as key.

Submodels responsible for certain aspects of licensing. I.e. evaluation period, user licenses etc.

Overall licensing status

All new license datas

Root certificate for user license and other checks

Root certificate for license server response verification

See https://jetbrains.team/p/bad-public-docs/documents/Licensing/a/License-metadata

Metadata format version

IDEA-334533 Since has one of the following string values: COMMERCIAL, PERSONAL, OPENSOURCE, CLASSROOM, STUDENT

IDEA-334533 Since is set to identify the trial

IDEA-334533 Since is set to enable/ disable AI by the license

Fired when Notification for certain license data is about to be shown. Will be shown if any subscriber set true to Out argument.

Can be null if licensed entity does not support JBA

OAuthenticator's overall state

URI to open in browser while authentication process

URIs used to perform authentication

Whether OAuthenticator is ready to use: either no auth required, tokens are received or there was an error

Won't be used

Should be passed in Authorization header

Used to refresh

Expiration period in seconds

When the tokens were obtained or refreshed

Provider of built-in options. Normally, the options are read

The method is called on background thread just once.

Built-in consent options

Allows not to show certain consent options to the user.

Checks whether specified relevant to the user

Consent option in question True if relevant, false if not relevant, null if not sure

For UI Interactive tests. If true prevents showing dialogs to user

Provide access to cached document data Privacy policy locations: HKEY_CURRENT_USER\Software\JetBrains\Platform\JetBrains.AcceptedPrivacyPolicy HKEY_CURRENT_USER\Software\JavaSoft\Prefs\jetbrains\privacy_policy\accepted_version %appdata%\JetBrains\PrivacyPolicy\Accepted %appdata%\JetBrains\PrivacyPolicy\Cached

Document technical name

Relative path to the file with accepted version. Shared with Idea.

Relative path to the file with cached document. Shared with Idea.

Registry key name for accepted document version for .NET products. For backward compatibility only. May be empty

Registry key name for accepted document version shared with Idea.

Shared storage access for accepted version

Loads user license from files located in ProductSettingsLocationFlag.AnyProductAnyVersion folder Folder: C:\Users\qx\AppData\Roaming\JetBrains\DotNet\vAny File mask: *license*.txt

Name of license for presentation

To whom the license belogs. for old licenses.

To whom the license is assigned. Should be ignored if empty of equals to

License identifier used for broadcasting. for old license, for new one.

License hash. for old license, for new one.

License restrictions string.

Date of license expiration if ever. for old licenses.

True if concurrent use is prohibited

Overall description for presentation

Get license status

Actual license data

Loads user license from registry corresponding to ProductSettingsLocationFlag.AnyProductAnyVersion (HKEY_CURRENT_USER\Software\JetBrains\Shared\vAny\UserLicenses)

Loads user license from registry corresponding to ProductSettingsLocationFlag.AnyProductAnyVersion (HKEY_CURRENT_USER\Software\JetBrains\Shared\vAny\UserLicenseSettings)

Loads user license from registry corresponding to ProductSettingsLocationFlag.AnyProductAnyVersion (HKEY_CURRENT_USER\Software\JetBrains\Shared\vAny\VKR)

Returns - NULL if license failed to decode. - data of first successful check - data of first failed check if no successful

Returns presentable asset (manually entered user licese or asset obtained from JetBrains account) description.

Licensee name License restrictions if any (i.e "for non-commercial development only") End of maintainence subscription. When no subcription use End of license. Use for endless assets Presentable asset description

Creates license data using licenseKey, userName and company name. If only one type of licenses is acceptable, normally returns new LicenseData(...). Otherwise some additional processing should take place

Guid (with braces), that is used to store Date marker

Number of days, free trial period lasts

Number of free trial days, after which feedback is requested. Negative value means feedback is never requested.

Identifies, when to start informing user that, his free trial period ends up

License agreement in rich text. NULL if no license agreement is necessary

Gets the URL that takes to the “Buy Product” page.

Determines whether the product should check for multiple instances running simultaneousely over the network.

JetBrains license server supports ProductFamily as guid without braces !!!

Return true if your product had subscription previously. In the case will be used to issue ticket in case of old license server.

Product code withod edition. In case of ReSharper it should be RS.

Detect edition by asset's product code

Product code from asset returned by ObtainLicenseResponse Product edition decoded does stored checksum corresponds to the username's one? checksum occupies 16 bits gets OmniaMea version stored in the license code occupies 16 bits gets type of the license stored in the license code occupies 8 bits gets license generation date stored in the license code occupies 16 bits gets license expiration date stored in the license code occupies 16 bits gets license subscription end date stored in the license code occupies 16 bits

Simple implementation of license support that fetches all the possible data from product

Creates a new instance of that watch duration of all measured operations (via ) Unit: milliseconds (ms)

If the cumulative duration of operations exceeds inside a single , an error will be logged with a stack trace of the last operation.

Creates a new instance of that watch duration of all measured operations (via ) under the given .

Sets for this . should be not null when policy is not

Logs the total time of all measured operations when lifetime is terminated. (applicable in playback tests).

Logs the of times of all measured operations when lifetime is terminated. (applicable in playback tests).

Logs the pre-defined quantiles (0.5, 0.75, 0.9, 0.95, 0.99, 1) of times of all measured operations when lifetime is terminated. (applicable in playback tests).

We queue a "Probe" method on the primary thread with the given interval. This method updates the timestamp of the last probing and requeue itself.

We queue a "Control" method on our own Controller thread with the given interval. This method checks the difference between the current timestamp and last probing timestamp.

Once the measured delta in a "Control" method is greater than the given interval, we will print a warning about it.

A set of reasons to suppress dump/snapshot collecting (e.g., container initialization, modal dialogs, etc.)

All available scenarios

All namespaces enabled manually, not bound to any trace scenario

All namespaces enabled manually or via scenarios

for sake of simplicity

Creates new user notification.

Notification lifetime. Notification severity. Notification title. Optional. Notification message. Optional. Additional description. Optional. Handler to be called when user activates the notification. Handler to be called when user closes the notification. True if the notification should be closed once clicked to. Icon of the notification. Optional Silent notifications shown only in notification log. Optional Additional commands. Optional

Creates expirable new user notification.

Notification lifetime. Period of time after which the notification is closed. handler is not called. Notification severity. Notification title. Optional. Notification message. Optional. Additional description. Optional. Handler to be called when user activates the notification. Handler to be called when user closes the notification. True if the notification should be closed once clicked to. Icon of the notification. Optional Silent notifications shown only in notification log. Optional Additional commands. Optional

Silent notifications shown only in notification log

Thig to store and reuse single perfomance switch handler extended description, title and id

Handler of the switch

State of the option

Handler behaviour. Is it live etc.

What is to be done when conflict is found

The component that accumulates all the known and manages their state/ updates etc.

Adds Performance switch for some lifetime

Switch's lifetime Switch to add

All switches registered in the system

Refresh state of all or specified switches.

Lifetime to perform the refresh An optional collection of

Async set switch states as requested

Switches to set to recommended value. No params mean all

Provider of switch handlers

All handlers returned by the method will be added to

Handlers to add

Fired when handlers might have changed

Detailed info of performance switch state

State for the performance monitor

Human-readable current value

The thing that is able to check, modify and monitor the state of a setting that may affect performance (i.e. TFS Git plugin in Visual Studio)

Switch Id. Must be unique.

Group of handlers this one belongs to

Textual information about handler Id, Title, Description, Severity etc.

Human-readable name of the switch

Human-readable recommended value for better performance

Where to locate the switch iun settings

Whether can set switch state programmatically. Some of VS settings simply don't work

Monitors external changes made to the options for

Lifetime for which monitoring should be performed Signal that will be fired when state changes externally

Forces state update.

Lifetime as cancellation token Task with the updated state

Tries to set new state to the option.

Lifetime as a cancellation token State to set. Must be or Task with updated state.

see https://docs.microsoft.com/en-us/windows/win32/api/winbase/ns-winbase-memorystatus

Returns results and clears stored results.

Record value to TC build statistics

Runs action and records its duration

Enumerator that stores enumerated values into cache, and them from cache

For CleaningEnumerator and RemoveCurrent

Special overload to prevent double optimization. fails always (not to run too fast).

Removes all the elements that match the conditions defined by the specified predicate.

Throws DB exception and optionally free memory

Always returns True

Only one map per DB table is supported. No cache coherency! Thread-safe.

When set to true enumerating through the values will try to get current value from cache if it is presented, otherwise current value will be obtained from underlying storage

Fot performance reasons in specific scenarios. Should be used to store information into that some key is absent. Info is stored as .

Value that will be stored in to denote that corresponding key is absent

Always return 'true' !!!

If you changed something in caches schema you MUST change this number. Increase this number to force rebuild all caches. How to change version: Increment number in prefix and write your branch version. E.g. 27:192-winnie.solbuilderprototype 28:192-branchfornavigation 29:net193-threading

Ordered list of paths

This method should be used with Process.Start. JetProcessStartInfo is not a live object, it doesn know about any toolset changes.

Can be useful if we want to run runtime with some arguments. E.g.: `mono --version`, `dotnet restore`

Use the same runtime as the host process: - In R#, we use .NET Framework - In Rider on Unix, we always use bundled .NET Core - In Rider on Windows, we use bundled .NET Core or .NET Framework depending on the current host runtime

Mono or Windows .NET Framework

.NET Core

StartInfo should not be patched

Can be executed on any thread

Pre-compile-time defined constants that emulate the C++ #define that has a value.

The set of #defines and their default values are given in an MSBuild file. The defauls could be overridden on the build server.

#define CompanyName JetBrains Short company name.

#define DateTimeProductBirth 2003-01-01 The date when the product was founded. Used for the lower copyright year and so on.

#define GuidProductUpgradeCodeInstallationCenter {2D580069-BF69-4B47-BDEA-AF2986412F11} Upgrade Code for the Installation Center family setups. In use starting with Platform-4.

#define IsModeStatistics False Whether statistics should be collected by the Statistics class. Default is OFF.

#define IsMsiIncludePdb True Whether PDBs for product binaries should be packed into the Setup. If True, it is an error if a PDB is missing.

#define IsMsiIncludeXmlDoc True Whether XmlDocs for product binaries should be packed into the Setup. If True, it is an error if an XmlDoc file is missing.

#define IsMsiProductBinariesStrongName True Whether product binaries packed into MSI must have strong names. If True, Setup build will fail unless assemblies have strong names.

#define IsReleaseLicenseAgreement False Whether the Release license RTF file should be embedded into the installer. Default is False, which takes the pre-release file.

#define IsReSharper True Demo Define.

#define IsReSharperMisbehavesEnabled False

#define LicenseSeed RLA90VMnIfMXmT4jbUVOo64qnJqs6APs7SgNXcQVoeeLMp5BpmU4fdw+impX+Wpd The license state written to the Registry by the installer, which provides for a free trial.

#define ModeAssertName JET_MODE_ASSERT Name of the IsModeAssert-induced conditional compilation symbol.

#define ModeStatisticsName JET_MODE_STATISTICS Name of the IsModeAssert-induced conditional compilation symbol.

#define NumLicenseAppVersion 8000 Application version for the licensing subsystem. Usually changes along with the ProductVersionMajor, but has its own numbering plan.

#define NumLicenseFeedbackRequestDays 10 Number of days after installation and before feedback of whatever kind is requested.

#define NumLicenseFreeTrialDays 30 Free trial days for a newly-installed product.

#define NumLicenseLeftDaysNotification 3 Number of days before license expires to notify the user of that.

#define NumTimeBombDays 0 The product will be inoperational when this time since build date expires. 0 means never expire (release mode), which is the default.

#define NUnitCpu x86 CPU platform of the NUnit runner process. Tests will be executed in this environment. Values: x86, x64, ANY.

#define NUnitInParallel True Allows running NUnit in parallel (one process per assembly, max CPU-count processes total).

#define NUnitRuntime v4.0 CLR version of the NUnit runner process. Tests will be executed in this environment. Values: v1.1, v2.0, v4.0, ANY.

#define NUnitVersion NUnit-2.6.1 Version of the NUnit runner used on TeamCity server. The special ReSharper make does better formatting of exception stack traces (without reversing the stacks).

#define PragmaOnce_Platform_Defines_Targets True Pragma Once.

#define PragmaOnce_Product_Defines_Targets True Pragma Once.

#define ProductStandaloneApplicationCaps None

#define ProductVisualStudioIntegrationCaps Required A required parameter of a platform-based MSI Setup which defines the VS integration capabilities of the product. Defines whether the installer should suggest integrating the product into Visual Studio. Possible values are: “None” — the product has no VS integration capabilities. Example: early versions of some products like DotTrace Memory, Peek. “Optional” — the product can be used without VS, but also provides VS integration. Example: DotTrace Performance. “Required” — the product only exists as a VS extension and usually should not be installed without VS integration. Example: ReSharper.

#define UriBuy http://www.jetbrains.com/resharper/buy/index.html URI of the Webpage where the user could buy the product.

#define UriCompany http://www.jetbrains.com URI of the company Website.

#define UriEvaluate http://www.jetbrains.com/resharper/download/index.html URI of the Webpage where the user can download an evaluation version of the product.

#define UriProduct http://www.jetbrains.com/resharper/ Main product webpage URI. Also used for ARPURLINFOABOUT in the installer.

#define UriProductCommunityNewsgroups news://news.jetbrains.com/jetbrains.resharper.community URI to the product community (support/discussion) newsgroups.

#define UriProductHelp http://www.jetbrains.com/resharper/documentation/index.html URI to Product Help. Used for Online F1 in the product and ARPHELPLINK in the installer. NOTE: UriProductHelp points to the SINGLE page for all R# versions starting with v4.0. See ReSharperWebHelp class on how the complete URI is producted out of this base: exact product version is appended, plus the options keyword whose help page should be opened. Based on the version number, user is redirected to help for his exact version. Thus, you cannot easily change this URI in a newer version without affecting already-released products.

#define UriProductSupportEmail mailto:support@jetbrains.com Email to request for product support. The default is suitable for all JetBrains products.

Literal versions of the properties.

Use these const fields only where use of a constant is mandatory. Otherwise use the static readonly field in the outer class, which stands better in the compiled assembly.

#define CompanyName JetBrains Short company name. Use this const field only where use of a constant is mandatory. Otherwise use the static readonly field in the outer class, which stands better in the compiled assembly, and has a more concrete type for non-primitive-type properties.

#define DateTimeForSubscriptionCheck 9999-12-31T23:59:59 The date when the recent product's 2-digit version is released. Used for subscription license check. If the date is not set, product build time is used. Do not change DateTimeForSubscriptionCheck here, edit the property on TeamCity instead Use this const field only where use of a constant is mandatory. Otherwise use the static readonly field in the outer class, which stands better in the compiled assembly, and has a more concrete type for non-primitive-type properties.

#define DateTimeProductBirth 2003-01-01 The date when the product was founded. Used for the lower copyright year and so on. Use this const field only where use of a constant is mandatory. Otherwise use the static readonly field in the outer class, which stands better in the compiled assembly, and has a more concrete type for non-primitive-type properties.

#define GuidProductUpgradeCodeInstallationCenter {2D580069-BF69-4B47-BDEA-AF2986412F11} Upgrade Code for the Installation Center family setups. In use starting with Platform-4. Use this const field only where use of a constant is mandatory. Otherwise use the static readonly field in the outer class, which stands better in the compiled assembly, and has a more concrete type for non-primitive-type properties.

#define GuidVsDynamicCommandSet {E272D1BE-8216-4919-AFA3-EEB57FAB3537} Command set GUID for the dynamic commands to be registered by the product at runtime. In a VS-integrated product, must be overridden with a meaningful GUID. Use this const field only where use of a constant is mandatory. Otherwise use the static readonly field in the outer class, which stands better in the compiled assembly, and has a more concrete type for non-primitive-type properties.

#define GuidVsGroupsCommandSet {9142D617-6500-478F-9DE9-3185145372D0} Command set GUID for the VS Command Groups that are generated to accomodate commands (created from IExecutableActions) in menus (created from IActionGroups). The IDs are entirely autogenerated by VSCT/CTO tool. In a VS-integrated product, must be overridden with a meaningful GUID. Use this const field only where use of a constant is mandatory. Otherwise use the static readonly field in the outer class, which stands better in the compiled assembly, and has a more concrete type for non-primitive-type properties.

#define GuidVsPackageCoClass {0C6E6407-13FC-4878-869A-C8B4016C57FE} GUID of the VS Package COM object CoClass. Used on the autogenerated VS package class, and everywhere in the Registry. In a VS-integrated product, must be overridden with a meaningful GUID. Use this const field only where use of a constant is mandatory. Otherwise use the static readonly field in the outer class, which stands better in the compiled assembly, and has a more concrete type for non-primitive-type properties.

#define IsModeAnnotateCallStacks False Whether call stacks should be annotated when calling standard object methods. If there's a graph of standard objects identifyable only by names (eg IProperty, ICollection, ISignal, etc), a callstack of their interaction does not give out the names of the entities, unless this option is turned on. Has a perf impact. Default is ON. OFF for production builds. Use this const field only where use of a constant is mandatory. Otherwise use the static readonly field in the outer class, which stands better in the compiled assembly, and has a more concrete type for non-primitive-type properties.

#define IsModeStatistics False Whether statistics should be collected by the Statistics class. Default is OFF. Use this const field only where use of a constant is mandatory. Otherwise use the static readonly field in the outer class, which stands better in the compiled assembly, and has a more concrete type for non-primitive-type properties.

#define IsMsiIncludePdb True Whether PDBs for product binaries should be packed into the Setup. If True, it is an error if a PDB is missing. Use this const field only where use of a constant is mandatory. Otherwise use the static readonly field in the outer class, which stands better in the compiled assembly, and has a more concrete type for non-primitive-type properties.

#define IsMsiIncludeXmlDoc True Whether XmlDocs for product binaries should be packed into the Setup. If True, it is an error if an XmlDoc file is missing. Use this const field only where use of a constant is mandatory. Otherwise use the static readonly field in the outer class, which stands better in the compiled assembly, and has a more concrete type for non-primitive-type properties.

#define IsMsiProductBinariesStrongName True Whether product binaries packed into MSI must have strong names. If True, Setup build will fail unless assemblies have strong names. Use this const field only where use of a constant is mandatory. Otherwise use the static readonly field in the outer class, which stands better in the compiled assembly, and has a more concrete type for non-primitive-type properties.

#define IsReleaseLicenseAgreement False Whether the Release license RTF file should be embedded into the installer. Default is False, which takes the pre-release file. Use this const field only where use of a constant is mandatory. Otherwise use the static readonly field in the outer class, which stands better in the compiled assembly, and has a more concrete type for non-primitive-type properties.

#define IsReSharper True Demo Define. Use this const field only where use of a constant is mandatory. Otherwise use the static readonly field in the outer class, which stands better in the compiled assembly, and has a more concrete type for non-primitive-type properties.

#define IsReSharperMisbehavesEnabled False Use this const field only where use of a constant is mandatory. Otherwise use the static readonly field in the outer class, which stands better in the compiled assembly, and has a more concrete type for non-primitive-type properties.

#define LicenseProductFamily 5931F436-2506-415E-A0A9-27F50D7F62BF A license GUID identifying the product family of the license. Now as we're using version numbers in the license (unlike early versions of ReSharper), this should be persisted throughout the product lifetime. Use this const field only where use of a constant is mandatory. Otherwise use the static readonly field in the outer class, which stands better in the compiled assembly, and has a more concrete type for non-primitive-type properties.

#define LicenseSeed RLA90VMnIfMXmT4jbUVOo64qnJqs6APs7SgNXcQVoeeLMp5BpmU4fdw+impX+Wpd The license state written to the Registry by the installer, which provides for a free trial. Use this const field only where use of a constant is mandatory. Otherwise use the static readonly field in the outer class, which stands better in the compiled assembly, and has a more concrete type for non-primitive-type properties.

#define LicenseSupportIdentifier AD0738CD-C5DC-4650-A216-F4AF3E651058 An identifier for the evaluation license. Change it to reset the evaluation period. Note: do not change LicenseSupportIdentifier here, edit the property on TeamCity instead. Use this const field only where use of a constant is mandatory. Otherwise use the static readonly field in the outer class, which stands better in the compiled assembly, and has a more concrete type for non-primitive-type properties.

#define ModeAssertName JET_MODE_ASSERT Name of the IsModeAssert-induced conditional compilation symbol. Use this const field only where use of a constant is mandatory. Otherwise use the static readonly field in the outer class, which stands better in the compiled assembly, and has a more concrete type for non-primitive-type properties.

#define ModeStatisticsName JET_MODE_STATISTICS Name of the IsModeAssert-induced conditional compilation symbol. Use this const field only where use of a constant is mandatory. Otherwise use the static readonly field in the outer class, which stands better in the compiled assembly, and has a more concrete type for non-primitive-type properties.

#define MsiSupportedVsVersionsList 8.0;9.0;10.0;11.0;12.0 The list of VS Versions the installer should be able to install. Note that adding a new version requires modification of WiX code (and maybe some of the C++ code too). Removing versions from this list should generally go smoothly. Must follow the C++ vs versions lsit format, which is semicolon-separater major.minor. Use this const field only where use of a constant is mandatory. Otherwise use the static readonly field in the outer class, which stands better in the compiled assembly, and has a more concrete type for non-primitive-type properties.

#define NetfxRequiredVersionBuild 0 The minimum .NET Framework version (Build component) required for installing & runnning this product. The platform default is the minimum version required by the platform itself. Usually it's the same for the product. Use this const field only where use of a constant is mandatory. Otherwise use the static readonly field in the outer class, which stands better in the compiled assembly, and has a more concrete type for non-primitive-type properties.

#define NetfxRequiredVersionMajor 3 The minimum .NET Framework version (Major component) required for installing & runnning this product. The platform default is the minimum version required by the platform itself. Usually it's the same for the product. Use this const field only where use of a constant is mandatory. Otherwise use the static readonly field in the outer class, which stands better in the compiled assembly, and has a more concrete type for non-primitive-type properties.

#define NetfxRequiredVersionMinor 5 The minimum .NET Framework version (Minor component) required for installing & runnning this product. The platform default is the minimum version required by the platform itself. Usually it's the same for the product. Use this const field only where use of a constant is mandatory. Otherwise use the static readonly field in the outer class, which stands better in the compiled assembly, and has a more concrete type for non-primitive-type properties.

#define NetfxRequiredVersionRevision 0 The minimum .NET Framework version (Revision component) required for installing & runnning this product. The platform default is the minimum version required by the platform itself. Usually it's the same for the product. Use this const field only where use of a constant is mandatory. Otherwise use the static readonly field in the outer class, which stands better in the compiled assembly, and has a more concrete type for non-primitive-type properties.

#define NumLicenseAppVersion 8000 Application version for the licensing subsystem. Usually changes along with the ProductVersionMajor, but has its own numbering plan. Use this const field only where use of a constant is mandatory. Otherwise use the static readonly field in the outer class, which stands better in the compiled assembly, and has a more concrete type for non-primitive-type properties.

#define NumLicenseFeedbackRequestDays 10 Number of days after installation and before feedback of whatever kind is requested. Use this const field only where use of a constant is mandatory. Otherwise use the static readonly field in the outer class, which stands better in the compiled assembly, and has a more concrete type for non-primitive-type properties.

#define NumLicenseFreeTrialDays 30 Free trial days for a newly-installed product. Use this const field only where use of a constant is mandatory. Otherwise use the static readonly field in the outer class, which stands better in the compiled assembly, and has a more concrete type for non-primitive-type properties.

#define NumLicenseLeftDaysNotification 3 Number of days before license expires to notify the user of that. Use this const field only where use of a constant is mandatory. Otherwise use the static readonly field in the outer class, which stands better in the compiled assembly, and has a more concrete type for non-primitive-type properties.

#define NumTimeBombDays 0 The product will be inoperational when this time since build date expires. 0 means never expire (release mode), which is the default. Use this const field only where use of a constant is mandatory. Otherwise use the static readonly field in the outer class, which stands better in the compiled assembly, and has a more concrete type for non-primitive-type properties.

#define NUnitCpu x86 CPU platform of the NUnit runner process. Tests will be executed in this environment. Values: x86, x64, ANY. Use this const field only where use of a constant is mandatory. Otherwise use the static readonly field in the outer class, which stands better in the compiled assembly, and has a more concrete type for non-primitive-type properties.

#define NUnitInParallel True Allows running NUnit in parallel (one process per assembly, max CPU-count processes total). Use this const field only where use of a constant is mandatory. Otherwise use the static readonly field in the outer class, which stands better in the compiled assembly, and has a more concrete type for non-primitive-type properties.

#define NUnitRuntime v4.0 CLR version of the NUnit runner process. Tests will be executed in this environment. Values: v1.1, v2.0, v4.0, ANY. Use this const field only where use of a constant is mandatory. Otherwise use the static readonly field in the outer class, which stands better in the compiled assembly, and has a more concrete type for non-primitive-type properties.

#define NUnitVersion NUnit-2.6.1 Version of the NUnit runner used on TeamCity server. The special ReSharper make does better formatting of exception stack traces (without reversing the stacks). Use this const field only where use of a constant is mandatory. Otherwise use the static readonly field in the outer class, which stands better in the compiled assembly, and has a more concrete type for non-primitive-type properties.

#define PragmaOnce_Platform_Defines_Targets True Pragma Once. Use this const field only where use of a constant is mandatory. Otherwise use the static readonly field in the outer class, which stands better in the compiled assembly, and has a more concrete type for non-primitive-type properties.

#define PragmaOnce_Product_Defines_Targets True Pragma Once. Use this const field only where use of a constant is mandatory. Otherwise use the static readonly field in the outer class, which stands better in the compiled assembly, and has a more concrete type for non-primitive-type properties.

#define ProductDisplayName ReSharper The user-friendly name of the product in the short form (no company, no version). The default choice if you want to mention the product name in UI. See Remarks on IApplicationDescriptor::ProductDisplayNameName for details. You MUST NOT use this define where an Application Descriptor is available (this includes any time when Shell is running). This is ONLY for out-of-shell and build-time uses. Use this const field only where use of a constant is mandatory. Otherwise use the static readonly field in the outer class, which stands better in the compiled assembly, and has a more concrete type for non-primitive-type properties.

#define ProductFullName ReSharper 9.0 EAP The expanded marketing product name, which is typically the <see cref="ProductDisplayName"/> plus the marketing version number, beta/EAP/RC designation, etc. See Remarks on IApplicationDescriptor::ProductDisplayNameName for details. You MUST NOT use this define where an Application Descriptor is available (this includes any time when Shell is running). This is ONLY for out-of-shell and build-time uses. Use this const field only where use of a constant is mandatory. Otherwise use the static readonly field in the outer class, which stands better in the compiled assembly, and has a more concrete type for non-primitive-type properties.

#define ProductName ReSharper The bare technical product name in the shortest form (no company, no version, no spaces, identifier-syntax-compatible). See Remarks on IApplicationDescriptor::ProductDisplayNameName for details. If there're multiple products built on these sources, their least common generic name. You MUST NOT use this define where an Application Descriptor or IProductNameAndVersion is available (this includes any time when Shell is running). This is ONLY for out-of-shell and build-time uses. Use this const field only where use of a constant is mandatory. Otherwise use the static readonly field in the outer class, which stands better in the compiled assembly, and has a more concrete type for non-primitive-type properties.

#define ProductStandaloneApplicationCaps None Use this const field only where use of a constant is mandatory. Otherwise use the static readonly field in the outer class, which stands better in the compiled assembly, and has a more concrete type for non-primitive-type properties.

#define ProductUpgradeCodeLegacyVS0800 {F790F14F-E662-4D25-89A0-9CC8677DE27A} Main historical Upgrade Code for the R# product line. In 3.0 era, was used by the VS80 branch only. Not used by the new products. Used by Installation Centers for detecting pre-Platform-4 products in VS80. Empty by default. Not a GUID type just to allow empty string values. Use this const field only where use of a constant is mandatory. Otherwise use the static readonly field in the outer class, which stands better in the compiled assembly, and has a more concrete type for non-primitive-type properties.

#define ProductUpgradeCodeLegacyVS0900 {5595D9CA-0517-4A8E-9129-F973460986E0} Side Upgrade Code for the R# products. Was in use in the 3.0 era only, was used by the VS90 branch that had an upgrade line separate from that of VS80. Should be checked for when detecting older versions. Used by Installation Centers for detecting pre-Platform-4 products in VS90. Empty by default. Not a GUID type just to allow empty string values. Use this const field only where use of a constant is mandatory. Otherwise use the static readonly field in the outer class, which stands better in the compiled assembly, and has a more concrete type for non-primitive-type properties.

#define ProductUpgradeCodeLegacyVS1000 Same as other ProductUpgradeCodeLegacy, but empty in all the products. Introduced for safe looping thru VS versions. Not a GUID type just to allow empty string values. Use this const field only where use of a constant is mandatory. Otherwise use the static readonly field in the outer class, which stands better in the compiled assembly, and has a more concrete type for non-primitive-type properties.

#define UriBuy http://www.jetbrains.com/resharper/buy/index.html URI of the Webpage where the user could buy the product. Use this const field only where use of a constant is mandatory. Otherwise use the static readonly field in the outer class, which stands better in the compiled assembly, and has a more concrete type for non-primitive-type properties.

#define UriCompany http://www.jetbrains.com URI of the company Website. Use this const field only where use of a constant is mandatory. Otherwise use the static readonly field in the outer class, which stands better in the compiled assembly, and has a more concrete type for non-primitive-type properties.

#define UriEvaluate http://www.jetbrains.com/resharper/download/index.html URI of the Webpage where the user can download an evaluation version of the product. Use this const field only where use of a constant is mandatory. Otherwise use the static readonly field in the outer class, which stands better in the compiled assembly, and has a more concrete type for non-primitive-type properties.

#define UriProduct http://www.jetbrains.com/resharper/ Main product webpage URI. Also used for ARPURLINFOABOUT in the installer. Use this const field only where use of a constant is mandatory. Otherwise use the static readonly field in the outer class, which stands better in the compiled assembly, and has a more concrete type for non-primitive-type properties.

#define UriProductCommunityNewsgroups news://news.jetbrains.com/jetbrains.resharper.community URI to the product community (support/discussion) newsgroups. Use this const field only where use of a constant is mandatory. Otherwise use the static readonly field in the outer class, which stands better in the compiled assembly, and has a more concrete type for non-primitive-type properties.

#define UriProductSupportEmail mailto:support@jetbrains.com Email to request for product support. The default is suitable for all JetBrains products. Use this const field only where use of a constant is mandatory. Otherwise use the static readonly field in the outer class, which stands better in the compiled assembly, and has a more concrete type for non-primitive-type properties.

#define UriProductUninstallFeedback http://www.jetbrains.com/resharper/uninstall/resharper.jsp An URI to submit the Uninstall Feedback from the installer. This URI has query string parameters that are defined in the installer itself (one of its CAs). Use this const field only where use of a constant is mandatory. Otherwise use the static readonly field in the outer class, which stands better in the compiled assembly, and has a more concrete type for non-primitive-type properties.

#define VsPackageLoadKey JetBrains s.r.o.;ReSharper;9.0;standard;AHR2RRIDC0RRA9ZMJMEQPPR8ICZZH1D3ZREDEZRRRJR0AARDEPEIC0IAZHQ2KAR8D1QKH3AKIZJCJKHEITIEIJRHHTZEDCIJJ1P8CPAEE2A2JKH9MHMPZPJ9HKHII3HM VS PLK, as received from the Microsoft website. See “Changing Product Name and Version SOP” on how to do that. Format: “CompanyName;ProductName;ProductVersion2;VsMinEdition;PLK”. See VsPackageClassEmitter::PackageInfo for format details. Use this const field only where use of a constant is mandatory. Otherwise use the static readonly field in the outer class, which stands better in the compiled assembly, and has a more concrete type for non-primitive-type properties.

Can execute a task.

This object is stateless, and thus not disposable. Execution of each of the tasks is an action in itself, with its own disposable scope.

Executes the task without exiting the method until the task is completed.

Task title, short form. This is used for the progress window title by the UI progress indicators. The long form of the task caption should go to the of the 's . Prepended with the product name automatically. Might be empty, in which case the product name will be used. The task to execute. Whether the task could be canceled by the user, if the task progress indication provided by supports canceling. The pattern is supported, which means that an is plugged on the task thread to throw a when called for a check with a False; such an exception is called by the task executor and converted into a False return value. Whether the task has completed execution (i.e. was not canceled). Note that even a task could be canceled by setting to False or throwing a or letting some other exception out of the task function. If you would like to return any values from the , assign them to local variables within the closure.

Executes the task without exiting the method until the task is completed.

As the original is free-threaded, wraps it into a new that fires its changes on the primary thread only.

As the original is free-threaded, wraps it into a new that fires its changes on the primary thread only. Note: you should call the version whenever possible.

For an , tracks the actively running tasks.

Name of the execution session. A UI Task Executor has three strings at any moment: the global Execution Name, passed in when creating the session, cannot be changed, makes into the progress window caption; the Task Name, in , is the name of the current big logical step of the task, presented as the bigger text on the progress; Item Name, in , is the name of the current atomic item being executed (e.g. the file being processed).

The full progress model.

A task executor that just calls the task method.

Pushes progress indicator as an interruption check

Whether an task could be user-canceled.

The task does not quite support canceling, so there's no use in displaying the "Cancel" button to the user. Note that the task might still be canceled and your run might still return False in some cases, like throwing from the task implementation.

The task supports canceling, looks for , and user should be presented with the "Cancel" option in the progress UI.

An is given this callback upon construction to notify the owner of any running sessions.

The extra task execution options

Whether the task could be canceled by the user, if the task progress indication provided by supports canceling. The pattern is supported, which means that an is plugged on the task thread to throw a when called for a check with a False; such an exception is called by the task executor and converted into a False return value. Marks the progress indeterminate (for processes that can't estimate the amount of work to be done) or determinate (for processes that can display the fraction of the work done using

The extra task execution options

Marks the progress indeterminate (for processes that can't estimate the amount of work to be done) or determinate (for processes that can display the fraction of the work done using

Rd implementation of that maintains the same order of items on both sides. Uses to ensure items appear in the same sequence even when added concurrently. However, note that performing modifications on one side and retrieving by positional index on the other concurrently will not synchronize automatically.

Used by rd reflection serializers.

Used as a unique comparable key for sorted list to maintain eventual consistency in order of added items on both sides. UId - double coordinate reflecting the position of insertion. Site - 0/1 identifies site. OpSeq - sequence number of the insert operation. (Side-local, incremented only to handle cases of removals and insertions at the same position.)

Gets double insert coordinates using a right-boundary strategy, optimized for case when inserts usually happen at the end

Used by base class and IListEvents to provide common list (get) operations, prohibits modifications

Selected region

jetbrains.com website

JetBrainsResourceMapping.json -- URI mapping

JetBrainsAccount.xml -- config for JetBrains account access

JetBrainsAIPlatform.json -- config for JetBrains AI service

dotnet-ea-service.xml -- config for Exception analyzer service

dotmemory.json -- [TODO config for dotMemory]

Specific action handler for actions typically available on a result list.

A semantical equivalent of VS's “Edit.GoToNextLocation” action. This method should update the action status and yield a non-Null function only if it's ready to execute the action.

Lifetime for the duration of this action execution. The returned functor will only be valid within this lifetime (and the same guard/readlock). Action context. Current action presentation state. The action executor function, if the action is available.

A semantical equivalent of VS's “Edit.GoToPrevLocation” action. This method should update the action status and yield a non-Null function only if it's ready to execute the action.

Upgrade a value in specified mount point

Used to get a value from prev layer to upgrade to. Must be sorted from high priority to low priority

Retrieves the data to be stored in settings cache.

Lifetime of the external request validity. The caller can cancel the request from any thread, thus the reader can check if lifetime is terminated and stop reading the settings for this request.

Data is cached by reader instance equality

Gets the logger to be used within the Settings subsystem. Assertions and algorithm consistency failures are reported to the central logging system immediately, while the outer-world and user-data exceptions are considered nonfatal and somewhat not quite unexpected in the real life, so they're stored for reading on request.

Intercepts all of the exceptions in the Settings subsystem and treats them specially.

Gets the logger which is collecting outer-world failures in exceptions (like invalid data file format). Note that, unlike , this member is not overridable. If an inheritor is replacing the logger, its exceptions will not be tracked by this object.

When you're passing your own logger to the Settings subsystem, wraps it and exposes as the proper interface.

Helper class for registering a single file-based storage and a single mounting point with the Settings Store.

The file-based storage (along with serialization) created by this component. Its property is promoted to the under the .

The mounting point for the storage created by this component and promoted to the .

Optimizes for the case when the dictionary has zero or one items by allocating no mem. Not thread-safe.

Gets if this instance is NULL, i.e. is a piece of an uninitialized zero memory. An empty dictionary must be explicitly created manually with the ctor. This safeguards from leaked NULL fields.

Slow version.

Mostly for debugger display. Does not throw on a NULL instance but returns NULL.

Interns string contents of the path components. Being a concurrent dictionary, needs no additional locking. Maps any key to the interned version.

The implementation of the settings storage entrails. Operates on strings, so has to convert each key-path-components based access. Its load & save are externally driven in terms of entries (serialization formats are not this object's responsibility).

Limiting lifetime for the storage objects. Diagnostics name of this storage.

diff: what should be applied to the settings storage on save to ensure merging of the conflicts. Protected with . Set to Null when empty to enabled lock-free checks for the “no-dirty” state.

The settings storage entries, as read from the persistent storage. Maps keys to values. In-memory changes are stored in until persisted to the storage. Protected with the .

Commits the diffs dictionary to the main dictionary, respecting recorded adds and removes. Normally is non-throwing.

Main dictionary. Will be overwritten by commit with changes from . Might be Null if there's no diff yet.

Held while a save or load process is in progress to avoid runnnig one more in parallel.

Does a batch-set to the out-of-transaction storage when committing a transaction. Writer lock on diff-to-stream must be held by the caller.

Transaction changes to apply. Keys which were changed by the batch-change must be written here.

The transaction is currently implemented as one more storage which actually implements all reading & writing. That's it.

In case of nested transaction, the nearest outer storage (storage from the parent transaction). Otherwise, .

The same storage, but outside all transaction. That's the interface which the outer world uses for accessing the storage.

Creates the currently-preferred impl of the storage.

An implementation of the settings storage which natively operates on key-path-components and stores them in a flat hashtable. Its load & save are externally driven in terms of entries (serialization formats are not this object's responsibility).

diff: what should be applied to the settings storage on save to ensure merging of the conflicts. Protected with . Set to Null when empty to enabled lock-free checks for the “no-dirty” state.

The settings storage entries, as read from the persistent storage. Maps keys to values. In-memory changes are stored in until persisted to the storage. Protected with the .

Held while a save or load process is in progress to avoid running one more in parallel.

Interns string contents of the path components. Locked with (rational: we write-access diff-to-stream more often than entries-in-stream, and we do not need interneds apart from writing anyting => better reuse that lock).

Caches enumeration of level-2 children (Enum() with nTakeChildLevelOnly=2, which is a common case for enumerating settings store indexed keys/entries). Locked with . Invalidated by any write to the second level or any massive change to storage, filled by Enum() when it encounters a cache miss.

Locks access to the dictionary only, its member classes have their own locking.

Commits the diffs dictionary to the main dictionary, respecting recorded adds and removes. Normally is non-throwing.

Main dictionary. Will be overwritten by commit with changes from . Might be Null if there's no diff yet.

Does a batch-set to the out-of-transaction storage when committing a transaction. Writer lock on diff-to-stream must be held by the caller.

Transaction changes to apply. Keys which were changed by the batch-change must be written here.

The transaction is currently implemented as one more storage which actually implements all reading & writing. That's it.

In case of nested transaction, the nearest outer storage (storage from the parent transaction). Otherwise, .

The same storage, but outside all transaction. That's the interface which the outer world uses for accessing the storage.

The storage key string (full name) is a slash-separated list of local names. Each local name must comply with the identified rules (Ll,Lu,Lt,Lo,Lm,Nd,Pc).

Value “equals” to take possible byte arrays into account. Possible raw storage value types include a few primitive POD types, strings, and byte arrays. The latter need some special Equals handling.

If the serializer choice () is , picks a specific serializer based on the actual value type (). Otherwise, returns the serializer choice AS IS.

Gets the type by which this entry would be represented in the settings key-value storage. The settings store only supports primitive types; complex ones are serialized, and their storage type depends on the particular serializer used.

When a value has to be specified on an attribute, its type is limited to primitive types. Also, the primitive types might not match if an integer is specified where a floating-point type is expected. Conversion logic: basically, it's the , but with the addition that the default value for a string is "" instead of NULL (because generally settings entries only store non-NULL values).

Gets an object with a default non-Null value for the given storage type (e.g. it'd be an empty string and an empty blob instead of Nulls).

An implementation of the settings storage which natively operates on key-path-components and stores them along their hierarchy, in a tree structure. Its load & save are externally driven in terms of entries (serialization formats are not this object's responsibility).

The object is for keying, to correctly process the case when the same action is added twice under different lifetimes. This might happen as we're sharing the same sinklist among all transactions.

Root node in the hierarchical structure which stores all the data. The nodes are trie-like, by key path components. This root is a fake node (empty component value) with list of actual roots. RW-locked with .

Interns string contents of the path components. Being a concurrent dictionary, needs no additional locking. Maps any key to the interned version.

Held while a save or load process is in progress to avoid runnnig one more in parallel.

Commits the diffs dictionary to the main dictionary, respecting recorded adds and removes. Normally is non-throwing.

Main dictionary. Will be overwritten by commit with changes from . Might be Null if there's no diff yet.

Updates to match . Adds the operations to .

A node in the hierarchy tree.

A non-root node .ctor, component must be specified.

Root node ctor, does not take a component.

Child nodes. Operations: lookup by component (most often), enum, add/remove. Null until first filled. Currently never deleted back to Null.

The key path component of this node.

Gets if this node is totally empty (no value or children).

As a tree structure, the nodes trie can operate in the Copy-on-Write mode. This is useful for sharing the parts of the tree between transactions, without the need to always clone the whole tree. Frozen nodes are readonly forever and might be used for free-threaded reading regardless of the locks taken. The frozen state must always propagate to the bottom, and lifting the frozen state requires cloning the nodes up to the top.

The value of this node which is in effect. If there're any in-memory changes to this node which have not been saved, it's different from until the next save. If the storage is not dirty, it's the same as . All read/write APIs are operating with this value.

Value of this node, as present in the serialization backend. takes precedence.

Creates the root node (does not have a component specified).

Does Copy-On-Write on the node. Re-mounts its children AS IS.

Protects this hierarchy.

The root node of the hierarchy.

Implements the write.

Whether the effective value has changed.

Walks the nodes tree in a way which supports copy-on-write when needed. Your function is called on every descendant node, DFS. If you see that you should change the node, and the node is readonly, yield from the function. You'll be called once again on the writable clone of the node. If you make the node empty, it will be removed from the tree for you automatically. Note that you might be called more than once for some nodes (if we're retracing after making smth writable).

Key path of the current node, to call into the user callback. Modifiable. Node to start the walk from (inclusive). Operations cache. Your handling function. If called from the rootmost node, always will be OK (as it's always writable). Otherwise, you must

We're limiting the set of value types which can be held in the storage, this method checks if the limit is obeyed.

When returned from a call, means “make my node writable and call once more with the same parameters”.

The transaction is currently implemented as one more storage which actually implements all reading & writing. That's it.

The context of our own transaction, this is the transaction ID as visible to outer users of the storage, while this class (transaction data) is the actual object implementing the transaction for this specific storage.

The same storage, but outside all transaction. That's the interface which the outer world uses for accessing the storage.

For a first-level transaction (opened under a “bare” storage), NULL. For a nested transaction, the context of the outer transaction.

In case of nested transaction, the nearest outer storage (storage from the parent transaction). Otherwise, .

An implementation of the settings storage which natively operates on key-path-components and stores them in a flat hashtable, adding a trie for hierarchical lookup. The trie is employed used for child-enumerating needs, but has to be maintained by all write-operations. Its load & save are externally driven in terms of entries (serialization formats are not this object's responsibility).

Cached binary search lookup delegate.

diff: what should be applied to the settings storage on save to ensure merging of the conflicts. Protected with . Set to Null when empty to enabled lock-free checks for the “no-dirty” state.

The settings storage entries, as read from the persistent storage. Maps keys to values. In-memory changes are stored in until persisted to the storage. Protected with the .

Root node in the hierarchical structure which enables child enumeration on key paths. This root is a fake node (empty component value) with list of actual roots.

Locks access to the structure. It does not take parts in regular reads, so it's not RW-optimized.

Held while a save or load process is in progress to avoid runnnig one more in parallel.

Commits the diffs dictionary to the main dictionary, respecting recorded adds and removes. Normally is non-throwing.

Main dictionary. Will be overwritten by commit with changes from . Might be Null if there's no diff yet.

Gets the hierarchy root, if there's an up-to-date version available.

Ensures the key exists in the hierarchy. Requires an outer lock.

Ensures the key does not exist in the hierarchy. Requires an outer lock.

Some settings have changed in the dictionary storage. Update the hierarchy to stay in sync. Note that this happens out of the dictionary storage lock, so the hierarchy state is out of sync at times. The consideration is that in absence of external synchronization we're not able to observe the difference in clients, and concurrent changes are not a problem because in this handler we'd be always updating hierarchy to the up-to-date

Does a batch-set to the out-of-transaction storage when committing a transaction. Writer lock on diff-to-stream must be held by the caller.

Transaction changes to apply. Keys which were changed by the batch-change must be written here.

A node in the tree which maintains the keys hierarchy to speed up children enumerations.

True on nodes which are terminal in some key path component paths. False if the node is there just for holding some children, but does not correspond to any actual nodes in the dictionary storage.

The transaction is currently implemented as one more storage which actually implements all reading & writing. That's it.

The same storage, but outside all transaction. That's the interface which the outer world uses for accessing the storage.

In case of nested transaction, the nearest outer storage (storage from the parent transaction). Otherwise, .

When storage is loaded from the external source, varies its behavior.

The storage contents is dropped, no events are fired for newly-loaded items. Good for first-time loading of the storage.

Applies diff from the source, fires all of the events appropriate.

Normally, you should export interfaces of and on your component so that they became available to the Settings Store. In case this is undesirable, those storages and mounts can be added to the items collections on this class to be exposed on behalf of this class.

Currently, this is the only way to expose storages/mounts from child containers (like Solution/Project) to the shell-level container, because child containers won't be traversed for interfaces.

Live collection of storages. Exposed to the shell-level component container.

Live collection of mounting points. Exposed to the shell-level component container.

Default implementation for .

Creates a new empty transaction context without storages in it. You may call then (see method documentation).

Transaction lifetime. All of the uncommitted changes will be reverted. It's not necessary to call explicitly. . If this is a nested transaction, identifies the outer transaction.

Copy-on-write, so has lock-free read access.

User settings: the storage serving the Global context, specific to the current product.

Helpers for working with global settings layers (per-product and all-products).

Binds to the application-wide context so that writes were SmartSaved to the All-Products Settings layer (affecting any higher-priority writable layers if they contain conflicting values).

Identifies the This-Product-Global-Settings user-friendly settings layer. To get the layer, obtain or create a instance and ask it for the layer by its ID.

Helper function for binding to a smart-save context which turns the specified readonly mount into a writable one and specifies it as the last-wide-context-mount (which means that no writes will go to lower-priority layers, and higher-priority layers will be updated to agree to the setting being written).

Represents serialization of the BLOB type as a BASE64 string.

Packs character ranges in string content of a into a single DWORD.

Offset of content.

Length of content, plus 1, if defined. If 0, then the content length is unlimied (take up to the end). This is the default value in the structure.

The union of offset and length. 0 means the substring is not limited and the content should be taken as the whole string.

Whether the whole content should be taken.

Gets a content substring for getting whole content.

Interface to the key-value settings storage (representing a physical storage on disk or a file from the Web).

Gets the user-friendly storage name. This is used for telling storages apart in the mount points list

Tries to get the value of the key.

Key. Either a value of one of the predefined types (), or Null if the value for this key is not set.

Sets or resets the value of the key.

Key. Either a value of one of the predefined types () to assign, or Null to reset the value of the given key.

Advises changes to the stored values. A change happens both when setting a new value thru and when synchronizing to external changes to the disk storage.

Enumerates keys and values in the storage. The lock is held throughout the whole enumeration process, so you should minimize your callback activities as much as possible.

The root key from which the enumeration should start. Its children or subtree will be enumerated. To enumerate the whole storage, pass in an empty (but non-Null) key path list here. This function MIGHT modify the key path list in the on each step by appending the child/ancestor key path components to it. The path prefix which you pass in is never modified though. Upon function exit, the original value is restored. If nonzero, ancestors of the specified level will be enumerated (such keys whose key path is the plus one components). If 0, the whole subtree will be enumerated, which includes the itself (if there's a value for it in the storage), and any ancestors (to whom path is a prefix). Your callback which is invoked on every iteration for each key-value pair encountered in the enumeration. The callback parameters are the key and non-Null value of the item. Note that the implementation MIGHT reuse the path you passed in as to be modified on each iteration to point to the current key path. You should not be performing lengthy operations or calling the storage recursively within this callback because the storage lock is held during the whole operation.

Makes sure this storage is attached to the specific transaction. This method only guarantees that read-repeatable within the transaction will not see any data written to the storage after this point.

Transaction context in which this storage should work in transactional fashion. The current transaction context, if we're opening a nested transaction. Transaction data of this storage.

Erases the given key, as well as its whole subtree. Pass in an empty list of key components to erase the whole storage contents.

Tries to get the value of the key.

Key. Either a value of one of the predefined types (), or Null if the value for this key is not set.

Sets or resets the value of the key.

Key. Either a value of one of the predefined types () to assign, or Null to reset the value of the given key.

A contract to require both interfaces.

Denotes a transaction opened over a group of objects. To create a new transaction, you create an instance of this interface and add storages to it (or access storages passing them the new context, which also adds them to the transaction).

A name to tell transactions apart.

Adds storages to the transaction. It's OK to pass storages which are already in this transaction, or to pass the same storage multiple times. Calling storage APIs with this transaction context without adding them to the transaction first is also OK, but in such a case the read-repeatable isolation starts working upon the fist call. Invoking this method on all the storages of interest begins read-repeatable on them.

Reverts all of the in-transaction modifications. The transaction remains operable until its lifetime terminates.

Commits all of the in-transaction modifications. The transaction remains operable until its lifetime terminates.

Helper method for the storages themselves. Gives them the per-storage-per-transaction data associated with this transaction.

An interface for settings storage transaction to talk to the storage in its transaction.

Gets the storage this transaction has been created for. Note that even though new objects might be created to server the transaction, this is always the same object as the out-of-all-transactions storage.

Commits all of the in-transaction modifications. The transaction remains operable until its lifetime terminates.

Reverts all of the in-transaction modifications. The transaction remains operable until its lifetime terminates.

A single entry in the storage key path contained in .

String content providing the path component as a substring. If Null, then this object is in an uninitialized state (semantically Null).

Defines which substring of the should be used.

Optional character prefix of the path component, prepended to the substring of . 0 for no prefix.

A generic equality comparer. Use it with data structures if you would like to avoid boxing on any comparer operation.

Renders the content substring and the prefix as a string. Might do substrings and concatenation, so is possibly slow.

Writes self into a stringbuilder. Does not create any intermediate strings, but writing to a stringbuilder is not too good in mem/perf anyway.

Normalizes the component for interning, so that the optimal representation of the component were stored.

A list of objects which constitute a settings storage key path. The path is operated as splitted into -splitted components because in most use cases it's composed from such components based on the context of access. When path originates as components, this allows to avoid concatenating strings for lookup. When path originates as a whole string, the components are pointing into character ranges within that string instead of actually creating substrings, so this scenario does not have memory penalty anyway. This class is a typed wrapper for a list of components.

The list of components. Might be Null when this struct is just created, so take care.

Parses a set of components over a string. There is always at least one component. Leading and trailing slashes are ignored, any other slashes separate components, even if zero-length. Components are pointing into character ranges within instead of creating substrings.

Parses a set of components over a string following some invariants: certain chars are prefetched into prefix, and the strings are interned. There is always at least one component. Leading and trailing slashes are ignored, any other slashes separate components, even if zero-length. Components are created over individual strings, which are interned.

The reverse to , should not be using in practice because it actually writes everything into a string-builder. Leading slash is an option, trailing slash is never added.

Interns strings in all path components.

Even though this wrapper is a structure (to save on allocating an object), the list of path components inside is a reference object, so it will be shared when this value is passed along. If you'd like to persist the value you have received, you have to clone the list.

The of the components in the cloned instance is always a , can call a concrete type bypassing the interface if used locally.

Args for .

The list of the keys which were assigned to a new value or whose value was reset.

A structure which adds one DWORD to the string pointer to identify a substring within a string without acyually producing the truncated string.

Applies offset and length to get the substring.

State machine for reading settings entries from a possibly-broken XML stream.

The XML reader actually used for reading. Non-NULL while we're operational. Could be either directly the reader passed in, or the wrapping positional XML reader, if we're recording positions.

Wrapping XML reader to know the positions, if we're recording positions. Otherwise, NULL. Also indicates whether we're recording positions. When non-NULL, points to the same object as .

What we've read from the stream up to the current moment.

Records positions of the entries encountered as pairs of entry key and position. Note that entry keys are not unique here because each entry might be encountered multiple times in the stream (which is not valid, but possible). The count might be larger than for that reason. Note that this list might contain positions of invalid entries (without a key, with an invalid value, and so on). Empty unless in ctor.

Records positions of elements (normally the root element holding all of the entries) encountered in the stream. A valid stream should have exactly one, at the root, parenting all of the entries. Empty unless in ctor.

Runs the reader. Fluent.

XML Space (preserve/default) will be applied to value content after reading it thru, when we'll be positioned on the next element already, must use the actual entry element's value.

The key is in the x:Key attribute on the entry element. As our entry elements are only convertible from a string value (cannot be assigned thru a property in either attribute or element syntax), the value must be given as text content of the element (this cannot be mixed content, XAML parser fails on that "Cannot have property elements on objects created via TypeConverter"). Thus there's no place to give x:Key in element syntax, and it can be only in the attribute.

When reader is at an element (opening tag of an element, or an empty element), checks the element fq name to see if it's a settings entry element. Throws if it's not.

Gets if the current element is a resource dictionary.

When reader is at an element (opening tag of an element, or an empty element), checks the element fq name to see if it's a settings entry element. Null if it's not.

Before stepping.

Default reading state. Waiting for an entry element.

When done.

We've encountered an element which is likely an entry, called when the reader is positioned on this element to acknowledge entry type/key and start reading its value.

After acknowledging the entry element, initializes into value reading. Still positioned on the entry element.

We're thru with reading entry value content nodes, store the entry value and proceed to generic-read.

The reader is positioned inside the value content, we're reading the nodes and collecting the content. Looking for either end tag of content element (checking by reader depth) or for any other entries which might erroneously be placed inside (eg when an element closing tag is lost during merge).

Whether to record locations of the entries when scanning through the XML document.

Utility for writing settings entry into an XML stream based on the existing possibly-broken XML stream with entries and various other XML data. The writer must persist the existing non-settings element and order of the already-existing entries.

Runs the task.

The entries to be written. Opens the reader to the previously existing XML stream which should be updated with the new entries. Might be called up to two times, first for choosing the writing positions for the new entries, then for streaming into the output writer. Yield NULL if there were no pre-existing stream (e.g. writing for the first time). Note: and cannot be on the same stream (file, etc) because they might be created at the same time to pipe the content thru. Opens the writer to emit the new XML stream (which includes the new entries and any other nodes from the previously existing stream, if there were any). If this function is never called during the run, then the output is empty and you might delete the storage altogether. Note: and cannot be on the same stream (file, etc) because they might be created at the same time to pipe the content thru. Logging facility used by the entries reader reading the existing entries stream. Logging facility used by this class when writing data.

For simple node types, writes them thru. Based on , but only handles single-node types and never calls Read on the reader. The above mentioned std method is only good for elements. When called on a text node, also kills the next element ('cause it awaits for some kind of EndElement to stop).

Pipes the opening tag of an element thru.

Looks up quickly if there're any entry positions child to the element identified by the position.

Sorted actions list. Index of the current position in the sorted actions list. Must be AFTER a lookup for the current position. Position of the element we're checking for child entries.

Looks up quickly if this element is the first child of an entry. Removing the first entry child element “reveals” the content nodes of the parent that were previously blocked by this element.

Sorted actions list. Index of the current position in the sorted actions list. Must be AFTER a lookup for the current position. Position of the element we're checking for being the first child. How: look into the previous position, if it's our parent => we're the first child.

Looks up the next sequential item in the sorted list.

What's been done to the output stream, and how you should treat it.

The XML Writer creator was called, the new significant content (different from the previous one) has been written. Should be persisted to media.

There're no changes to do to the content, the old one could be used. If a file, just don't touch.

There're no entries to write. The XML Writer creator was called, the insignificant content (any non-entry elements encountered in the input stream) has been written. Generally, should be persisted to media (to maintain any content we don't understand, eg from newer versions).

There're no entries to write, and there were no insignificant content (any non-entry elements encountered in the input stream). The XML Writer creator was called, and the settings storage XML stream infrastructure has been emitted, but there's nothing else. If the file presence is important (e.g. per-project settings), the file might be freely deleted.

Safely gets the value out of the map, checks that it's of a valid type, and gets its Type ID. This method throws all of its errors out.

Modifies behavior of the settings storages on the filesystem. The fully-functional implementation to use with real storages.

Request environment (like integrated SCC in the VS) if the file can be modified. Can only be called on the main thread.

Modifies behavior of the settings storages on the filesystem.

Add a token here to prevent file settings storages from being loaded from disk. This also suppresses save because saving a non-loaded storage would destroy the data.

You should not be loading from disk or saving to disk if this is False.

You should not be saving to disk if this is False. Note that when gets False, this property also gets False automatically.

All settings-related logging should go into this logger.

Add a token here to prevent file settings storages from being saved to disk.

Request environment (like integrated SCC in the VS) if the file can be modified. Can only be called on the main thread.

Allows to publish behavior flag from your component instead of adding them to . This way, your class is implicitly imported into rather than the other way, which guarantees that all other clients of get your all-time suppressions from the very beginning.

You will be called by when it's time to tweak its behavior. The call might be placed on any thread. This happens before the properties become visible to anyone else, and sequentially with other behavior providers. Do the modifications to the behavior in this method, or remember the value to manipulate further on your state changes.

Request environment (like integrated SCC in the VS) if the file can be modified. Can only be called on the main thread.

The basic serialization interface for the default storage implementation. Works right on in-memory representation of the storage entries.

Loads entries into the storage. If the storage has any in-memory changes, they remain intact.

Storage calls this function when it needs to read the entries. This makes sure it sets any applicable locks around the read operation.

Saves the entries from the storage.

Storage calls this function on the exact entries to be saved. The return value indicates whether the save succeeds (if the storage can assume in-memory diff applied).

Adds caching capabilities to storage serialization.

This method takes precedence over . If you provided data on previous , and it's still up-to-date, you'll have a chance to load from the cached data instead of parsing the XML anew. If you implement this method and your called understands the interface and there's cache data available, on the first-load you'll be called for this method instead of . If you cannot read the binary cache data, fallback to reading . The caller might always call instead. If you throw an exception out of this method, caller assumes reading the cache did not succeed and calls into .

If were loaded OK. If not, then the caller assumes has to be called, and that the binary cache file is corrupt and has to be deleted.

This method supercedes the regular . If you implement this method, and your caller understands the interface, you'll be called into this method and not into .

As in . You must provide entries to this function. Specific to this method. Fast-save a binary cache presentation of your state in your own format so that to get it into .

Gets the user-friendly storage name. This is used for telling storages apart in the mount points list

Gets the list of entries changed in-memory (Null value means it should be reset). Used mostly for diagnostics needs. Creates a copy of the dictionary (so use sparingly), because the actual dictionary access is lock-protected.

Gets whether the storage has any dirty (in-memory) changes pending for save. Free-threaded.

Gets if there're no entries in the storage. This includes both entries-from-stream and dirty entries. This allows for optimized behavior if we've got nothing to save. Yields Null when it's a bit too expensive to calculate the result.

Handles binding settings storage to some physical media exposed as a stream. If you got some stream (e.g. a file stream), you can use this interface to serialize storages.

A wrapping XML reader that can tell the (stable enough) position of the current node. These positions have linear order and can be used to identify the same node when reading the document for the next time.

Hierarchical index of the current element (if it's the current node), or the element containing the current node for non-element nodes (such as text, comments, whitespace, etc). The first item is the index of the top-level element (always 0 in a valid XML document, could be above zero in XML fragments), the second is the index of its child element, and so on.

If the current node is the element tag, 0 for opening, closing, and self-closed tags (see for kind). If the current node is not an element tag, the number of nodes encountered since the last element opening, closing, or self-closed tag (see for kind: means the node is after the opening tag and is a child of that element; or means it's after the closing or self-closed tag, i.e. the node is on the same level as the element).

For an element tag node: the kind of that tag. For a non-element node: means that points to the parent element of this node (there were no previous sibling elements to address from yet), and other values mean that is some prev-prev-...-sibling of this node, and nodes are counted starting with its closing tag (which is =0), or the self-closed tag.

Gets the depth of the node indicated by the position, just the same way as would do.

Snapshots the position.

Gets whether this node is either an element opening tag or an empty element's self-closed tag.

Creates a node position from an XML element in an XML document.

Looks up an element in the XML document by this position.

Creates a copy of the current node hierarchical position (contains a list of indices, so a snapshot is required of you'd like to store it for later use).

Returns a view on the current position (without cloning its byref part). Cannot be stored for later use because will be invalidated on the next step.

Zero-based absolute index of the node. Note that this depends on reader settings (whether to autoexpand entities or not) and read process decisions (whether to resolve into each particular entity or not), so it's recommended to use the , which is accurate on element nodes.

Special implementation for simple one-time storages.

Helps with binary caching of the XML settings storages content.

Creates a writer with all of the parameters (e.g. encoding must match when reading and writing).

On the first load, try reading the cached binary representation of the settings file, if exists.

Same as , but for a long-run.

Deletes the storage disk file once the caller finds it necessary.

Helpers for serializing Settings Storage entries to and from XML.

XML NS alias for the System.Windows namespace (and a couple others).

XML NS for the System namespace in mscorlib (CLR NS form only, no URI alias).

XML NS alias for the System.Windows.Markup namespace.

XML NS alias for our CLR namespace that contains the BLOB class.

Tries to resolve XML namespace URI in any form to one of the known kinds (could be a CLR namespace, an alias URI, etc).

Operates over (whose serialization works on entries' in-memory representation). Uses and to convert it into XML serialization over the given stream.

Operates over (whose serialization works on entries' in-memory representation). Uses and to convert it into XML serialization over the given stream. Supports the binary cache to avoid re-parsing the XML stream on each run, if the storage implements .

Reports results of the function.

Where the loaded data came from.

There was no data (e.g. XML file did not exist on disk).

Parsed the XML stream.

Got an up-to-date binary cache for the source and executed treebuilding off it.

Gets the result of writing the XML form of the storage.

Call to flush the binary cache (when the identity is already known, which only happens after the XML stream is saved successfully to disk and gets its final timestamp and file length, but the lock is not released yet).

Binds to a disk file.

Path is supplied as a property. Whenever the property value changes, or the file content pointed to by the path changes, the settings storage is reloaded. Behavior depending on the path and its file conditions (when discovered): • Path is Null: means the disk storage is not available, operate in-memory only (e.g. temp solution — doesn't have the file yet). Action: memory storage operates normally (do not clear), no reload actions are taken. We hope to have some path for the final save, but if not, the settings will be dropped. • Path is non-Null, but the file does not exist: possible causes: either the storage got empty and the file has been deleted, or the file has been temporarily deleted during a write or merge operation, or the storage path has changed to the new location. Action: if path has changed, save in-memory storage ASAP to the new location; otherwise, keep memory storage intact for some amount of time or until a forced save is requested; at then, reload as if from the empty storage (all in-memory content but for the dirty diff is deleted). • Path is non-Null, the file exists, but its content is invalid: keep the in-memory copy for as long as possible; when forced to save, overwrite the corrupted content. • Path is non-Null, the file exists, and its content is valid: read to replace the from-stream cache of the storage, the dirty diff remains as-is.

A failed reload is reschedulled.

A failed save is reschedulled.

What loads and saves from the stream on our file. The path to the file, or Null if the file location is not currently available. The value is used for reading (Null will cause a clean storage) or writing (Null will skip writing and keep all changes in memory). Also the path is watched for changes to reload new content when the file is modified (e.g. from SCC or another instance). When you point the path at the new location, it gets overwritten with the current in-memory changes. Enables watching for external changes.

Schedulles save operation when the storage gets dirty.

Requests that the save operation be done soon. Can be called on any thread, does not wait for save to be completed. Normally schedulles save on another thread.

Protects the file read-write operations in the whole. Also synchronizes lifetime termination on this object.

Whether the file should be deleted if there're no settings in it (and no unrecognized content we're obliged to keep).

Updates whether there's a pending reload reschedulled.

Updates whether there's a pending save reschedulled.

This function is called when the file we're about to reload is missing from disk. If the file we're trying to reload is reported missing, wait for it for some time to reappear (e.g. user is in process of replacing the file with another version). This means that for some time we're not treating the missing file as an empty storage to load, but keeping the in-memory content in hope to load the actual file.

Whether the reload process should be aborted and wait for the file to reappear.

Reads the file stream while loading with appropriate locking and lockwaiting, throws out if the lock cannot be achieved in the time alotted.

Requests that the storage be saved to disk immediately and synchronously, on the main thread. Thread affinity is enforced to enable placing calls which are affined to the main thread. If you're calling from a background thread, or do not care about synchronous execution, use .

Queries into the behavior whether the file could be written. Main thread only, due to SCC limitations.

Opens the file stream exclusively, which constitutes the interprocess lock.

Applies written data to the on-disk file. As we're now writing into an in-memory stream, this means writing the stream into the file.

Normal behavior. The modifications done to the storage are applied to what we got on disk.

Any on-disk content is ignored, in-memory loaded content & changes are forced onto disk. This is the behavior when storage is relocated to the new path (otherwise, all of the settings would be lost).

Just some new settings have been written to the storage, and that would be a nice idea to save it to the disk.

We really have to save now. For example, we're exiting and there're dirty changes.

See remarks to class. When the file disappears, we expect it might come back within this amount of time.

See remarks on the class. Means we should not auto-overwrite the settings, assuming the corruption might be due to the SCC conflict and might be fixed soon. Only overwrite on forced save if there is dirty content (but make a backup in such a case).

Initial interval before file access retry attempts, in milliseconds. Doubled with each next try.

The maximum waiting time to gain access to a stream when loading, in milliseconds.

If can't get lock for reading the file, reschedulles the next reloading.

This flag helps with to only wait for disappeared files (which were ever seen existing). If the file has never been ever seen, it can be overwritten or treated as missing immediately, without the delay.

What to do when we're about to save a settings file that has no content.

Save a valid empty file. After the first save, a file will appear on disk.

Delete the file from disk. Preferrable for SCC-keeped files (otherwise, empty storages would be created for all solutions/projects).

Implements a storage with a disk XML file backend.

The path to the file, or Null if the file location is not currently available. The value is used for reading (Null will cause a clean storage) or writing (Null will skip writing and keep all changes in memory). Also the path is watched for changes to reload new content when the file is modified (e.g. from SCC or another instance). When you point the path at the new location, it gets overwritten with the current in-memory changes.

Whether the file should be deleted if there're no settings in it (and no unrecognized content we're obliged to keep).

Requests an async reload of settings from disk in some near future.

Reloads from disk synchronously.

Requests an async saving of settings to disk in some near future. Note that the settings are saved even if there're no in-memory changes (there's no need to request a save with in-memory changes because it will occur automatically).

Saves to disk synchronously.

The default extensions for Settings Storage files in XML format.

Prefetches all indexed values from the store (=snapshot) and stops reading from the actual store (=freeze).

Non-Null when live, Nulled when we get snapshot&frozen.

Null until we do a snapshot.

Prefetches all indexed values from the store (=snapshot) and stops reading from the actual store (=freeze).

Attaches key getting/setting to the instance of this object to enable caching of some data required for speedup.

Gets the values of all of the settings key's entries and returns them in a settings key class. This is always non-Null for a simple (non-indexed) key whose parents are also all simple. If there's no data on that key in the storage, default values will be returned for all of its entries. For an indexed key, or a key with an indexed ancestor, this will be Null if no instance is defined for the particular index value specified in .

The settigs key to be read. If this key is parented by one or more indexed keys or is indexed itself, the indices to those keys. It is an error to have an index omitted for an indexed key. An instance of the key class with non-indeexed entries read with and indexed entries exposed as with .

Stores the values of all of the settings key's scalar entries. It's semantic is equivalent to calling for each scalar entry of the key. The settigs key to be written. The value to be written. Must be of the CLR type specified in the settings entry If is indexed itself or is parented by one or more indexed keys, the indices to those keys. It is an error to have an index omitted for an indexed key.

Accesses the mounted settings storage taking its mounting path into account.

Accesses the mounted settings storage taking its mounting path into account. must be specifically prepared for calling this method.

Accesses the mounted settings storage taking its mounting path into account.

Accesses the mounted settings storage taking its mounting path into account. must be specifically prepared for calling this method.

Accesses the mounted settings storage taking its mounting path into account.

Accesses the mounted settings storage taking its mounting path into account. NOTE: for enumerating the whole mount, your key path must contain exactly the first NULL component NOTE: the key MIGHT contain mountpaht in the first component when your callback is invoked. must be specifically prepared for calling this method.

Copies the contents of the mounting point as raw storage physical data (the part of the storage mounted under this mount point).

Optional. If only a part of the mounting point's contents should be copied, specifies the root key of the data to copy. If Null or an empty string, the whole storage under the mounting path will be copied.

Erases all of the storage contents under the mounting point.

NULL or empty to erase the whole mounted content. A specific path to erase all the content under it.

Erases all of the storage contents under the mounting point.

Empty (but for the placeholder) to erase the whole mounted content. A specific path to erase all the content under it.

Wraps the list so that it appears as if missing one first item.

Wraps the list so that it appears as if having one extra first item.

Gets the dummy implementation which does not do any optimizations. This is a placeholder. In performance-critical real-life uses, import from your container and use this instance in place of this parameter.

Gets the default static optimization cache. It is still preferrable to import the optimization as a component.

Pass params thru hierarchy in a special class to save stack space when recursing.

Don't use this unless you really know what you're doing!

Resets the value in the most concrete store of the given context. The local value in the store will be removed. A value from one of the underlying stores, if any, will be used. If none, the default value will be used.

Creates a dictionary-like object for reading indexed entry values by index.

The settings entry, the value of whose indexed instance is to be read. If this entry is parented by one or more indexed keys, the indices to those keys. It is an error to have an index omitted for an indexed key. An object.

Ensures that the instance of an indexed key is marked as created in the highest-priority storage of the current context. This accounts for these two basic scenarios: • Create an instance of the key which has all of its entries in their default values (without setting any entries on the key). • Mark an instance of an indexed key inherited from a lower-priority storage as defined in this higher-priority storage so that it were available even when the lower-priority storage is removed. In most other cases, like when you're setting entries on an indexed key, the indexed key instance will be reported as existing in the current combination of layers (the existence status might be coming from a lower-priority storage).

An index to the key to be created, as well as indices to any parent indexed keys of that key.

Checks whether the instance of an indexed key is marked as created in any mounted storage of the current context.

An index to the key to be checked, as well as indices to any parent indexed keys of that key.

Gets the live value of the setting in the given context.

Value type. Settings key class owning the settings entry. Duration. Identifies the context in which the retained-state value should be maintained. As the data context is lifetime-bound and expires on guard release, needs a function to produce the context at need. This function is guaranteed to be called on the primary thread under a guard. The entry whose value is to be monitored. A property that changes live as the setting changes.

Gets the live value of the setting in the given context.

Value type. Duration. Identifies the context in which the retained-state value should be maintained. As the data context is lifetime-bound and expires on guard release, needs a function to produce the context at need. This function is guaranteed to be called on the primary thread under a guard. The entry whose value is to be monitored. A property that changes live as the setting changes. The settings entry whose value is to be read. If this entry is parented by one or more indexed keys, the indices to those keys. It is an error to have an index omitted for an indexed key. The value, as set in the highest-priority storage which is not restricted for overriding. The settings entry default value otherwise (Null if not available).

Advises the settings entry change event. Fires on any change in settings entries in any child key, in any settings context. To sink changes in a specific context only, bind the store to that context and use its method.

Duration. Entity to be watched for possible changes. Executes when the change is detected.

Advises the settings key change event. Fires on any change in settings entries in any child key, in any settings context. To sink changes in a specific context only, bind the store to that context and use its method.

Duration. Entity to be watched for possible changes. Executes when the change is detected.

Copies all of the settings defined in the current context into the given context.

Source context. Target context to copy the settings into. Handles errors in this specific routine. Note that any of the store access errors will still go to the logger of that store. Optional. If Null, the whole store available in this context is dumped. If non-Null, only those values under the given schema key are included. Optional. Indices to , if it's specified.

Gives out all of the indexed entry indices currently present in the store. Note that reading indexed entry values by some of these indices might actually return Null due to: • Multithreaded access to the setings store. • Some technical info leftovers present in the store under this index, but not the actual value. • The entry indexed value is set in a base layer and then removed in a higher-priority layer, in which case the removal technical entry will report the index as present, but the actual value will be missing.

Identifies the indexed entry. If this entry is parented by one or more indexed keys, the indices to those keys. It is an error to have an index omitted for an indexed key. An enumeration of the index objects. The CLR type of these objects is defined by the settings entry declaration.

Gives out all of the indexed key indices currently present in the store. Note that checking by some of these indices might actually return False due to: • Multithreaded access to the setings store. • Some technical info leftovers present in the store under this index, but not the actual value. • The key indexed instance is defined in a base layer and then removed in a higher-priority layer, in which case the removal technical record will report the index as present, but the actual key instance will be missing. • You're enumerating indices to an indexed key which is a descendant of another indexed key instance which is not defined itself.

Identifies the indexed key. If this key is parented by one or more indexed keys, the indices to those keys. It is an error to have an index omitted for an indexed key. Note that this should not include the index to the itself because its possible indices are to be enumerated, but it's not an error if it's present. An enumeration of the index objects. The CLR type of these objects is defined in the settings key attribute.

The settigs key to be read. If this key is parented by one or more indexed keys or is indexed itself, the indices to those keys. It is an error to have an index omitted for an indexed key. Allows to operate whole settings keys faster by applying object-specific optimizations. An instance of the key class with non-indeexed entries read with and indexed entries exposed as with .

Stores the values of all of the settings key's scalar entries. It's semantic is equivalent to calling for each scalar entry of the key.

The settings key to be written. The value to be written. Must be of the CLR type specified in the settings entry If is indexed itself or is parented by one or more indexed keys, the indices to those keys. It is an error to have an index omitted for an indexed key. Allows to operate whole settings keys faster by applying object-specific optimizations.

Don't use this unless you know what you're doing

Returns the sequence of mounting points applicable to the specified context, sorted by priority ascending.

Filtering context. Sequence. This delegates to , where there are additional overloads for multiple synchronous queries and asynchronous lock-safe execution.

Binds the context to the explicitly specified mount points. The context would be live and the mounts list might also change with time.

For old APIs which cannot pass the origin correctly. WARNING: slow, as it takes the call stack. Upgrade to the newer APIs with an explicit origin.

Binds the context to the explicitly specified mount points. This means just creating a new bound store on the mount points.

Binds the context to a mount point so that setting values could be written to it even if they are default values.

Binds the context to the explicitly specified mount points. This means just creating a new bound store on the mount points.

Binds the context to the explicitly specified mount points. The context would be live and the mounts list might also change with time.

Defines the lifetime of this live context, because it tracks the live list of mounts and watches for changes. The live list of mounts. This is allowed to change in a free-threaded manner. If changing the mounts set causes certain settings to change their values in this context, the appropriate change would be fired asynchronously and with a slight delay. Additional parameters for the context created.

Core implementation for context bound settings stores.

Cached delegate.

Builds storage keypath for the settings key, and checks that all the indexed keys in the path are marked as defined in the store. NOTE: this function is used in much less cases now in favor of , see NP-624.

Builds storage keypath for the settings key, and checks that all the indexed keys in the path are marked as defined in the store. NOTE: this function is not used anymore in favor of , see NP-624.

Builds storage keypath for the settings key, and checks that all the indexed keys in the path are marked as defined in the store. NOTE: this function actually always returns True , but marks the places which used to check for the key to be defined before the design was changed to always read the actual entry value, see NP-624.

Builds storage keypath for the settings key. Does not check that all the indexed keys in the path are marked as defined in the store (but checks that all the key indices are supplied with ). NOTE: this function is identical to , but marks the places which used to check for the key to be defined before the design was changed to always read the actual entry value, see NP-624.

Builds storage keypath for the settings key. Does not check that all the indexed keys in the path are marked as defined in the store (but checks that all the key indices are supplied with ).

Backend for . Unlike the functor in the ctor, does not necessarily force refreshing the value before returning. This does not have to be a ctor param because we never have to call it from the ctor. This MUST NOT be called in ctor.

Called by the base implementation when it needs to get the current mounts list (and recalculate it synchronously if required). This MUST NOT be called in ctor.

Indexed entry value writer (gets come storage key info precached). Supports indexed entry values removal in higher-priority layers.

True if we've seen a removal record for this index.

Layer identity to combine entry deletion records with entry values.

Value serialized to a primitive storage type, as residing in the storage. Must be non-Null for a correct value record after the layer is processed. Can only be Null if we have encountered a value-removal record before the actual value record ( is True). Such a situation after the layer is fully processed means the record should be ignored.

Delegates to ' .

Creates and manages live value properties for . Allows free-threaded property creation, so there's an object per each thread () managing that thread's properties.

This lifetime has been synchronized with termination (via ).

Has async threads. This lock makes sure the threads are all in a determinate state when the object is terminated on its home thread. Background threads take the reader lock when they're busy and cannot have the lifetime terminated. Foreground thread terminates the lifetime under a writer lock.

Per-apartment valueprop objects in MTA, all of them together, lazy-created. Protected with . See also .

Per-apartment valueprops (within each thread there're no problems with threading issues). STAs per their thread. Protected with . See also .

Call initiated by settings-store-change-sink, forwards the change to all apartments with properties.

Gets cached value property, or creates a new one. The property is bound to your and not limited by the lifetime of the object because the latter might be terminated on any thread which would fire acknowledgement events on a thread not expected by your code. The property will live to the lifetime you pass in here. In all correct scenarios, this is not wider than .

Demand-creates per-apartment property support objects.

Creates and manages properties in the single apartment on behalf of . Changes to properties which originate in the settings store are fired within the same apartment only.

Identifies the home apartment of this object: either an STA dispatcher scheduler, or JetScheduler for the MTA. Can only be used-accessed on home thread. The only exception is which is called on the change-dispatching background thread.

Properties which are alive. Protected with .

is synced with (both borrowed from the owner).

This function is called on an arbitrary thread so that this object analyzed possible changes for its properties (on that thread) and then marshalled to the destination thread to update the property value, as appropriate. NOTE: this function is async, so owner calls this function without any termination synchronization, we should take precautions when accessing critical parts.

Gets or creates the property (in responce to a user's call to ). Must be called in the home apartment of this object. NOTE: shutdown synchronization lock must be held by the caller.

Works when the property has to be created. Must be called on home thread of this object.

Base untyped nongeneric property class to enable managing properties of all types in a loop.

Cached key getter for dictionary-like bin-search arrays.

When a property change is annotated with this token, then it's due to a sync to the settings store change.

Adds one more user request for this property to keep it alive.

Returns the typed version: casts if it's really the proper type, or thows if this is a property of some other type.

Re-reads property value from the Settings Store. NOTE: caller must synchronize with termination.

Wraps functioning of a single SettingsStore bidi-bound property.

NOTE: must be synchronized with termination by caller.

Property is attached to each of the user's lifetimes, to be terminated when there're no clients for the property. NOTE: shutdown synchronization lock must be held by the caller. NOTE: myOwner.myLockPropertiesAndTheirLifetimes must be held by the caller.

Default implementation of a non-lifetimed (transient) context-bound settings store.

Default optimized group hosts just one item for which there was never ever a fitting group found. It does not accept any other items so that not to steal good items from their specialized groups.

Tells if the item has not only been advertised by also actually added thru groups API.

Helps with mounting your storages representing the default settings of the product: you cannot specify default values for indexed entries and keys, you have to mount a storage which provides them at the lowest-priortity level. You could use this component to load them from resources and such.

Loads a settings storage from an XML resource and mounts into the settings store into the global context at a low priority. NOTE: you SHOULD rather implement for pull-providing the default settings storage instead of calling this method push-style.

Loads a settings storage from an XML stream and mounts into the settings store into the global context at a low priority. NOTE: you SHOULD rather implement for pull-providing the default settings storage instead of calling this method push-style.

Lifetime for the storage. Storage name. The stream in Storage XML format to read the storage contents from. You can dispose of the stream immediately after calling this method. Optional identity to binary-cache the loading of this resource.

Our class is the settings storage façade, and this field implements the actual place where all the stuff collected from default settings providers is stored. Delay-created under , lock free reads.

Lazy-inited. Tossed by root keys they provide, or to the legacy list. Delay-created under , lock free reads.

Process delay-initing objects which must be unique. Avoid pumping on Monitor Lock to prevent nested execution due to reentrancy.

Delayed-executes loading settings from a provider.

Root of the tree orgainized by settings storage key components. Providers which can tell their root keys are added to this tree on first access, and then executed and removed from this tree when smb first queries into that subtree. The root node represents the first key path component, but does not check its name, because that's the mount path and it does not matter. The root node's lists the legacy providers which do not have their key specified.

We need to operate on the given key, so execute all possible providers ABOVE this key (a provider might contribute to any subkey, so all levels above are needed). handles a special case when we're interested in all subkeys under this key as well (eg when doing an enumeration), which requires all providers BELOW this key to execute as well. Possibly leaves unexecuted providers in siblings to the key.

Triggered on the end of the key path in the rare case we need to execute all providers BELOW. Happens in case of an enum. Examples: an enum of all the live templates. Would trigger providers into live templates. Or a total enum, would trigger all providers at all.

NULL or empty when no children. Sorted by for binsearching. Threading: after inited in ctor, might be changed by removing nodes. Removed nodes remain valid and might still be walked by threads who captured them before removal. Copy-on-write with CAS modification to remove stale nodes.

The key path component of this node, one per node.

Lock for Providers. Does not use the Monitor lock because it might incur pumping and nested reentrant execution in a totally unexpected spot.

List of providers until they are executed, NULLed after that are all executed. Provides for this node (key path from root), or legacy unspecified-keys providers, if on the root node. Threading: when decided to execute, execution and NULLin must all happen under a lock on this node object.

Specify the root settings key, the deepest common key of all the settings you provide, so that your provider were only called when someone reads from there. Specify the root settings key, the deepest common key of all the settings you provide, so that your provider were only called when someone reads from there.

This is a helper intended for use by generated stuff which would emit settings as text. Instead of making an XML file and then parsing it with settings xml serialization every time, you can supply the list of key names and values here directly, and save CPU time on that. NOTE that this operates in Storage paths/values, same as get written on disk, rather than Store entries and their custom value types. So the values are in serialized form in primitive data types, as listed in . For example, if you would be generating a file which would look like this:


            <wpf:ResourceDictionary … >
              <s:Boolean x:Key="/Default/PatternsAndTemplates/LiveTemplates/Template/=c8f9a18b9bc45c7685965edcc8fe8b44/@KeyIndexDefined">True</s:Boolean>
              <s:String x:Key="/Default/PatternsAndTemplates/LiveTemplates/Template/=c8f9a18b9bc45c7685965edcc8fe8b44/Shortcut/@EntryValue">col</s:String>
            </wpf:ResourceDictionary>

you would instead call this function with a generated array like this:


            [
              ("/Default/PatternsAndTemplates/LiveTemplates/Template/=c8f9a18b9bc45c7685965edcc8fe8b44/@KeyIndexDefined", true),
              ("/Default/PatternsAndTemplates/LiveTemplates/Template/=c8f9a18b9bc45c7685965edcc8fe8b44/Shortcut/@EntryValue", "col")
            ]

Groups together the information on the mount points that constitute this context-bound settings store, in a single immutable object instance.

Gets the mounting point out of outside of which (with lower priority) writes are not allowed. NULL means that writes are unconstrained and could go into any of the writable mounts in this context.

Gets the mounting points present in the context at the moment.

Constructs an -like interface which operates on the stack of mount points involved in this context, reading from the whole stack and writing into the part of the stack limited by . Respects the mounting path of the mount points. All operations on this storage should only use the default mounting path.

A lightweight operation, no allocations.

Convert ContextRange into the mounts list — non-live.

When getting a list of mounts filtered to a context range, prepares the query to be executed by .

Availability function which tells whether the owner is avwailable in the given . Default implementation.

Always available.

Never available.

Constructor wrapper for smart completion.

Groups all of the items that are always available. Just pours them into the list.

Groups all of the items that are never available. Just skips them all off the output.

Checks availability by comparing a dataconstant in the datacontext to the predefined value.

The limiting lifetime for the you supplied. The value will not be used after the lifetime terminates. The data constant to get from the data context. The value of in the datacontext must be equal to this for the availability to be True. Optional locks. If specified, data context access will be protected with a reader lock.

Hashmap of available items set by data constant value.

Protects access to . Expecting rare writes and often concurrent reads. Only trivial operations are lock-protected, so not expecting deadlocks or lengthy blocking.

Stores the mounts, optimized for querying by values of this data constant. Protected with , so that a set of queries could be executed on exactly the same set of mounts.

Defines the strategy for dispatching changes in settings.

Gets the task for the current pending/running settings change dispatch activity. After you make a change to the settings store, either by writing to one of the storages or by changing the set of mount points, this would be an incomplete task which would change its state to completed as soon as all the clients finish processing their dispatch callbacks.

Registers with a grouping-event-like interface for doing the dispatch. Call the returned function when you want to schedule a dispatch, and your will be called on an undefined thread when it's time to (in the same manner as grouping event's incoming-outgoing).

Registration. The handler which would be called when you have requested processing and it's time to do the processing. If you run async operations within your callback, yield here a task of that activity so that to avoid reentering and running other change dispatch tasks in parallel. Also, settings store clients might learn when all of the initiated settings change activities are completed if this tasking is wired correctly. The functor which you invoke when you see a need to be called back for changes processing. Safe to invoke multiple times, only one callback would happen.

Prevents changes from being dispatched on this thread. You must thoroughly dispose of the value returned from this method.

Maintains a live list of mount points based on a context range for an operation of a live .

Updated under .

Falls when we see events in mount changes. The set isn't recalculated immediately to offload these operations from the main thread.

Forces a synchronous update of the mounts list, eg when smb is reading from the bound store and must see the new values already.

Deferred notification on change in set of possible mounts, update the .

We have both sync and async calculations, possibly running in parallel Want to make sure we never overwrite a fresher calculation by an older one Unfortunately, we do not have a global snapshot number of the configuration, because calculating the mounts list form the context range involves data context queries to arbitrary stuff So run the calculations until nobody else has written a value (older? newer? no way to tell) during out run

Default implementation of the interface.

Creates a new storage and reads XML stream contents into it.

Simple interface for accessing the Settings Store on a single mounting point only.

Builds storage keypath for the settings key, and checks that all the indexed keys in the path are marked as defined in the store.

Builds storage keypath for the settings key. Does not check that all the indexed keys in the path are marked as defined in the store (but checks that all the key indices are supplied with ).

Stub when no tasks are running.

The current implementation of delegate's hash code in >NET yields the same value for *all* the delegates, turning a hashset into a list. Differentiate over methods and targets. Our equality: don't allow implicit delegate equality because we're not doing “-=” on new method group delegates, so we're checking equality on references. Our hashcode: don't ask for method-info because it might be slow in getting out of the delegate, just check the closure instance; NOTE: now calling Object::GetHashCode nonvirtually on the instance to get its default instance-specific hashcode.

Maximum time we'd await for async change handling clients before we drop their chain of tasks (to complete independently, if ever) and proceed along with our chain and report the global status as done processing. This is needed to avoid cases when a client loses a chain of tasks accidentally and blocks changes processing forever. The timeout is thus a large one to allow for any reasonable activity to happen, but still protect in edge cases.

Backs . The instance swaps from completed to non-completed under (such as the list with requests). The instance swaps from non-completed to completed under (such as the list with requests) and (to make sure there're no requests), but the task instance should not change its state to completed under either lock to avoid running arbitrary code under the lock. The prev task must be set to completed state outside the lock, to avoid possible deadlocks. Cannot be lazy-inited because otherwise it's hard to synchronize with the case when all the stuff has been taken out from the requests list but have not completed processing.

Modified under .

Protects and .

Prevents dispatches running in parallel (mostly for the case of a manual commit). NOTE: not using because we sometimes need to wait on it

Suspend/resume counter, plus the box on which the lock is taken when reading/writing.

Cached delegate.

Async case: grouping event's outgoing action has fired.

Just requests gevent dispatch, after all of the internal structs are configured for that.

Returned from as a cached delegate in .

Forces pending changes in the settings to be processed immediately. Not expected in production scenarios.

Runtime settings store values are freehand CLR types, while writing them as settings storage values or as parts of settings storage keys (as indices) requires serializing them to primitive types. Here are common accessors, and the class contains raw serialization routines.

Settings Storage value serialized to a primitive type => settings store settings entry value of a CLR type.

Settings Storage value serialized to a primitive type => settings store settings entry (indexed) value of a CLR type.

Settings Store settings entry value of a CLR type => Settings Storage value serialized to a primitive type.

Settings Store settings entry (indexed) value of a CLR type => Settings Storage value serialized to a primitive type.

Serializes an index to an indexed entry or an indexed ket for storing as a settings storage value (for info only; useful form of indices is within the settings storage key).

Settings Storage key part serialized to a string => settings store indexed settings entry index of a CLR type.

Settings Storage key part serialized to a string => settings store indexed settings key index of a CLR type.

Settings Store indexed settings entry index of a CLR type => part of the Settings Storage key serialized to a string.

Settings Store indexed settings key index of a CLR type => part of the Settings Storage key serialized to a string.

Contains raw serialization routines.

Deserializes a value in the settings storage back into the CLR type.

Note: serialization for taking part in a settings storage key has much more limitations than serializing for storing in the settings storage value, that's why there're two sets of serialization functions.

Serializes a runtime CLR object for storing the value in the settings storage.

Deserializes a value taken out of a settings storage key part back into the CLR type for use as an index to indexed keys/entries.

Serializes a runtime CLR index to indexed keys/entries object for using as a local name part of a settings storage key.

Serializes an arbitrary string so that it fit the charset of a local name within a storage key. The secondary objective is to retain “good” strings unmangled, i.e. if a string fits the charset already, it should be written as is to save space, speed, and human-readability. Currently the algorithm lets latin alphanumerics through, and all other characters are encoded similar to QuotedPrintable, but with an underscore as a designator instead of an equality sign. To ensure identity on all serializations of the same key, we state that [0-9A-Za-z] are always let thru AS IS, and all others are encoded with an underscore followed by four uppercase hex digits of the UTF-16 character code, starting with the most significant one.

The char which leads the quoted-printable escape sequence. Followed by four uppercase hex digits.

Serializes an arbitrary strings into a localname-fitting form.

Deserializes a previously serialized string back into the original string.

If the char could be let thru. Note that even though an underscore is allowed within a local name, we reserve it for an escaping character and do not let thru.

Default implementation for a mountpoint.

The name of the mouting point. Usually, this is the same as the storage name. However, it is possible to mount different subpaths of a storage separately, in which case individual mount names should be provided. Null to use the storage name automatically.

A special typed wrapper for the mounted path. Its main goal is to provide a convenient shortcut to the default value for the mounting path.

Value inside the typed wrapper. TODO: minimize use of this value, because its behavior around slashes is inconsistent

Value inside the typed wrapper.

The default value to be used in most cases.

Accumulates all advertised settings storage mount points and optimizes typical access to them.

Gets an instance without any mountpoints at all.

Locks access to .

Same mounts as in and , but here they're gathered into groups of the same priority and same availability, with an option to quickly calculate availability of the whole group. The groups (all items in group of the same priority) are sorted by priority, ascending. For access for modification and when the is outdated only.

A lock-free cache of . When Null, should be recalculated from source. Recalculation is not performed on every modification because there might be many modifications in a row and here we get a chance to realloc the array only once. Reads are lock-free, writes are protected with the same lock as reads of .

Gets all of the mount points currently registered in the system as a live collection which only updates under the Reentrancy Guard.

Gets the mount points that are available in the given , checking their against that context (or rather calling where applicable).

Gets the mount points that are available in the given context, checking their against that context (or rather calling where applicable). Allows to execute multiple queries on a consistent set of mounts.

Self-check for calling only in consistency-checking mode.

When cached value in is not available, takes the lock and updates it. Cold path.

Whether the owning class should be doing slow self-checks on any modification to ensure consistent modification of the optimization groups.

Constructed by Shell to run the real product without this slow self-check.

Emulates settings-storage-like API on a group of settings storages mounted with mounting points. This involves: (1) Dispatching access to mounting points favoring storage key translation against the mounting path of each mounting point. (2) When reading: looking thru the stack of the mounting points, along their priority, for the highest-priority defined value. (3) When writing: either writing to the highest possible mounting point, or implementing the SmartSave strategy.

Copies the contents of this layered storage to the target mounting point.

Reports outer errors with copying. Note that in-storage failures will go to the logging facility of the respective storage. Optional. If only a part of the mounting point's contents should be copied, specifies the root key of the data to copy. If Null or an empty string, the whole storage under the mounting path will be copied.

Enums keys from all the mounts. Duplicates are removed.

Enumerates all of the mounted storages, either under a specific key, or the whole mounted section.

Storage key to the root to be enumerated (with the first empty slot for MountEnum). Calls you back on each encountered storage key. Includes the mountpath in the first component (whatever it is, not necessarily default/empty). Might call multuple times for the same path if it's present in more than one mountpoint.

Erases all of the data in all the [writable] layers under the given key.

Gets the value along with the exact storage in which the value was found. If the value is not found in either storage, the whole return value is Null, not only the tuple components.

Gets whether we should be writing into the mounting point, favoring its writeability flags and whether we're in the ignore-readonly-flag mode.

A shortcut to .

Sets a value, according with the SmartSave strategy.

Here's a detailed description of what SmartSave startegy is about. We operate on a layered structure of settings mount points, ordered by priority, some of them writable and some not. A typical picture (as per specific context of a project file) would be: • Global User Settings (writable, lowest priority) • Solution Shared Settings (R/O) • Solution User Settings (writable) • Project Shared Settings (R/O) • Project User Settings (writable, highest priority) Besides that, non-indexed entries have default values defined for them in the Schema, which take effect when neither of this layers has a value defined for the entry. SmartSave follows the policy: (1) As we set the value, the effective value of this context must be read from the deepest layer possible (Defaults is the best choice). (2) The value assigned must also be effective in all the “parent” contexts of this context. These rules guarantee that if user changes a setting here he will also see the effect in other files/projects/solutions, unless explicitly overridden there. To fullfill rule 1, we shouldn't be writing into more-specific layers unless we really have to. By default we're writing to the global layer, wiping out all of the more specific overrides. If there're any readonly overrides, we also set the desired value into the lowest availavble writable layer above which there're no overrides for this setting in readonly layers. To fullfill rule 2, we're covering each override defined in a readonly layer with a higher-priority override in the nearest writable layer. Even though of all such overrides only the highest one can bee “seen” in exactly this context, overriding intermediate ones guarantees the new value is consistent through all contexts. Extension for the secondary value smart-set simultaneousely: this allows to smart-set the primary value almost as usual plus some additional value to have the desired value on all of the mounts which have the primary value assigned, if possible. This is to implement the indexed value removal flag: it's queried for only on the same mount as the value itself, and when setting/removing an indexed value it must take the correct true/false form. In our algorithm, besides writing one more value, this affects the detection of whether we have to cover an override in a readonly layer: the primary value might be OK but the secondary one is bad => both must be written to a higher-priority writable layer for correct behavior. Storage key to the value (with the first empty slot for MountGet/MountSet). A non-Null value to set. You cannot set value to Null in terms of the SmartSave strategy (but setting to default value is likely to have such an effect), the set-to-Null operation is only applicable when writing to specific mounting points. If we're co-setting the secondary value ( is non-Null), specifies the replacement key path component for the last path component of the primary value (). Hence, the secondary value can differ in the last path component only. Passed byref to save on params stack. If we're co-setting the secondary value, gives the non-Null secondary value ( define whether it's the default value). If Null, we're not co-setting.

Warning! This method is slower than calling manually because here it has to cut the first path component out of the mount-enummed data.

Set: does not favor when looking for the mount to write to. Not set: writes only to mounts.

Some values have implicit defaults which take effect when a value is not set on any layers. When we're setting a value which is the same as the defaults, the preferrable behavior for SmartSave is toIf during SmartSave we're able to wipe out all of the values set in layers so that reading the storage returns Null

Same as , but applies to the secondary value of the method.

The replacement dummy empty ('cause we don't need its data at the moment and want to keep the stack memory low, and don't want to drop all of the code yet, it's useful for debug and such).

This is the real . Has been replaced by a dummy to save on stack traffic because right now we seemingly do not need the thing. If it's ever required again, just rename it back.

Index of the as a layer in the layered structure.

The mount which provides the newly-set value. Returned non-Null in SmartSave case if succeeded to set the value (can fail if writing to writables only and another value is set in a higher-priority readonly mount), Null otherwise (because direct-write does not read any values).

Whether we succeeded to make the given value the effective value of the context.

The list of mounting points we've written to. In non-smart-save case, just the highest-priority [writable] mounting point. In smart-save case, when setting a Null value, all of the mounting points we've removed value from. In smart-save case, when setting a non-Null value: could be empty if non-must-write, or just the wide mounting point, or wide than narrow (if writing to wide didn't have effect for layered reading).

Assigns the result-outlining properties.

Why this layer is listed.

Index of the as a layer in the layered structure.

The mounting point the write was performed into.

Encountered a value in a readonly layer which was equal to the desired value.

Encountered a value in a readonly layer which was not equal to the desired value.

Was about to write a value to a writable layer (to cover defaults or readonlies), but the layer is already set to the desired value.

Wrote the desired value to a writable layer.

Erased a value from a writable layer.

Main implementation of the Settings Store.

Creates a new store instance.

This schema must include all of the keys and entries you intend to access thru this store. The list of mounting points which are layers with settings, filtered for availability when you bind to a context. Non-Null if this store is accessing settings within a transaction. New transactions must be opened by the calling party (e.g. method). Helper for creating data contexts. The store itself does not quite need it, but it's required by helper APIs for binding to the context conveniently. Logging facility of the Settings subsystem.

The component container ctor.

Implements sinking changes in mount point storages for the .

Individual changed keys, as should be dispatched to clients. The key path components of the change contain a placeholder for the mounting path.

Whole mount contents change, as should be dispatched to clients.

Maps mounts to the clients which are listening for those mounts at the moment.

Entry point for sinking any changes.

Your client lifetime. Who originated creating this client, for diagnostics. The mounts you got initially, and any further changes to the mounts set. Changes will be fired for contents of any mounts not present initially.

Entry point for sinking any changes.

Does processing the recorded changes (storage keys and mountpoints set) on a background thread when the grouping event ticks. NOTE: threading policy depends on the strategy.

For each known mount, sinks its changes while its known.

Called when a client wants to register one more mount for it, for the lifetime specified. Also called for initial lifetimes, is False for such mounts.

Given out when someone advises settings store changes

Identifies the originator of this client registration for the settings store changes.

Like , but allows to spawn an async activity in response to the change. The main profit is that the change originator can then track when all of the activities by processing the change are complete.

Defines translation between in terms of end-user Settings Store entities (, ) to string keys in the Settings Storage which physically holds the values.

Schema

The schema is the logical schema on settings keys / settings entries, exposed to the application for getting/setting values of arbitrary user types. It is collected by reading classes with (which produces hierarchy of keys) and inspecting their members for (which produces key entries).

Physical Storage

Physically, all of the data is stored in the settings storage, which is a key-value store with string keys and values of a few primitive types. The logical schema maps into the settings storage keys. For each settings key or settings entry there might be zero or more metadata values written into the storage under a storage key corresponding to one of the metadata items of the key/entry. Some metadata items are required for storing/reading the value, and others are purely informational and might be used for storage browsers and human-readability.

Storage Keys

(note: there are Settings Keys, which are logical entities of the Settings Schema and which contain Settings Entries; and there are Settings Storage keys which are string values keying the physical key-value storage actually holding raw values, which is actually written to disk) Storage keys are slash-separated strins: /one/two/three/four/@metadata. The format of the storage keys strings vaguely resembles that of an XPath request. Speaking in terms of XPath, we're only addressing “xml attribute values” in the physical storage. In the storage key string, this means it always ends with “/@metadataname” (a path-separating slash, metadata prefix and name of some metadata). Here are syntax definitions of valid settings storage keys pointing to some schema-originating metadata. Settings Key metadata:


               KeyPathSeparator MountPointPathInStorage 
            
               (
                   KeyPathSeparator KeyLocalName
                   [ KeyPathSeparator ValueInLocalNamePrefix SerializedIndex ]  // Indexed keys only
               )+                                                               // Each key in parent keys chain
            
               KeyPathSeparator MetadataPrefix MetadataName

Settings Entry metadata:


               KeyPathSeparator MountPointPathInStorage 
            
               (
                   KeyPathSeparator KeyLocalName
                   [ KeyPathSeparator ValueInLocalNamePrefix SerializedIndex ]  // Indexed keys only
               )+                                                               // Each key in parent keys chain
            
               KeyPathSeparator EntryLocalName
               [ KeyPathSeparator ValueInLocalNamePrefix SerializedIndex ]      // Indexed entries only
            
               KeyPathSeparator MetadataPrefix MetadataName

Legend: KeywordMeaning KeyPathSeparator“/”. Constant. Defined in as .Separates local names of settings keys and entries, index values on indexed keys and entries, and tailing metadata name in the path making the settings storage key. Analogous to the XPath separator. ValueInLocalNamePrefix“=”. Constant. Defined in as .When one of the storage key path components are formed from a user-supplied value (for example, indices of indexed keys or entries), denotes such keys for telling them apart from key path components coming from keys/entries' local names.If this prefix appears after a settings key or entry local name component in the storage key path, means the key or entry is indexed rather than simple. MetadataPrefix“@”. Constant. Defined in as .The last component of the settings storage key on which actual data is stored is a metadata name, which is denoted by this prefix to tell apart from other key components. MountPointPathInStorageThis is not in the scope of this class.This path is added by the mounting point when it mounts a path of a physical storage for access in a specific context.As the single storage file might host several independent mount points, they're designated with a prefix on the storage key actually written to the file.The mounting point handles appending/removing of this prefix when exposing the storage, so store-to-storage translation does not have to deal with this prefx. KeyLocalNameLocal name of the Settings Key. Defined by . EntryLocalNameLocal name of the Settings Entry. Defined by . SerializedIndexAn index to a particular instance of an indexed key or an indexed entry, in a serialized form. Defined by the actual index value passed to the key/entry access functions. MetadataNameName of the metadata on this key or entry. Possible names defined in , see descriptions and possible usages below.

Settings Key

There is no required metadata for a Settings Store Settings Key because keys themselves have no values in Settings Store. Only entry values are written to the storage. A key is just an organizational unit in the logical schema which helps with early-bound key values and typed deserialization. A Settings Key maps to the storage key formed by concatenating local names of it and all of the parent keys. For example, WebProxy under Internet under Environment under root makes the /Environment/Internet/WebProxy settings storage key. Common Settings Key metadata: Metadata stored for a settings key, supposing /K/E/Y is its key path: (note: these are not settings entries of the key yet, just optional metadata for the logical settings key in the physical storage) KeyMeaning /K/E/Y/@KeyDescription(String) Description of the key, as specified in . Optional, non-vital, written when setting value, could be used by settings storage browsers. Non-indexed Settings Key metadata: No special metadata on a non-indexed key — just the all-keys common items. Indexed Settings Key metadata: The storage key for an indexed key includes the serialized form of a particular index which defines the specific instance of an indexed key: /K/E/Y/=IndexSerialized. This applies to all of the indexed keys in the parent keys path. For example, if key K is also indexed, the sample path would look like /K/=KIndexSerialized/E/Y/=YIndexSerialized. When reading samples for entry storage keys below, take into account that any indexed key in entrie's parents has also to include its index value. KeyMeaning /K/E/Y/=IndexSerialized/@KeyIndexDefined(Boolean) True means there is an instance of an indexed key defined for this index. Note that there might be no entry values written to the storage for this key instance if they're all in their default values, still the key instance will be marked as existent.False means the key might be defined on some of the lower-priority layers, but has been revoked at a higher-priority layer and all of its entries must be ignored.{no value} means the key instance is not defined for this index (even though there might be some leftovers of settings entry values in the storage). If this value is undefined in all the layers, the key instance will not be present in the logical Settings Store. However, if it's defined to True on at least one layer's storage, all of the entry values on all the storages on any layers, even those without the KeyIndexDefined set, will take part in entry values composition. Required. Vital, an indexed key instance will be treated as non-existent without this value.

Settings Entry

All information on a Settings Entry is stored under the key path of its parent Settings Key, plus the local name of the settings entry. Example settings storage key: /K/E/Y/EntryLocalName Common metadata for indexed and non-indexed settings entries (all optional and non-vital): KeyMeaning /K/E/Y/EntryLocalName/@EntryDescription(String) Description of the entry, as specified in . Optional, non-vital, written when setting value, could be used by settings storage browsers. Non-indexed Settings Entry metadata: KeyMeaning /K/E/Y/EntryLocalName/@EntryValue(any type) The serialized value of the entry. Required. Vital for reading the entry value. /K/E/Y/EntryLocalName/@EntryType(String) Full name of the CLR type of the settings entry member which was serialized into the settings storage primitive type. Optional, non-vital. /K/E/Y/EntryLocalName/@EntrySerializer(String) enum member name representing the value serializer used when writing the value. Optional, non-vital. Indexed Settings Entry metadata: Indexed entries are mapping a simple index to a simple value. The following metadata is added to the entry itself, stored under the /K/E/Y/EntryLocalName storage key: KeyMeaning /K/E/Y/EntryLocalName/@EntryIndexType(String) Full name of the CLR type of the indexed settings entry index. Optional, non-vital. /K/E/Y/EntryLocalName/@EntryIndexSerializer(String) enum member name representing the value serializer used when writing the index. Optional, non-vital. /K/E/Y/EntryLocalName/@EntryIndexedValueType(String) Full name of the CLR type of the indexed settings entry value. Optional, non-vital. /K/E/Y/EntryLocalName/@EntryIndexedValueSerializer(String) enum member name representing the value serializer used when writing the indexed value. Optional, non-vital. An indexed entry is a set of (index, value) pairs, which should have fast lookup by index. Such pairs are units of storage. For each pair, its data is stored under the /K/E/Y/EntryLocalName/=IndexSerialized storage key. KeyMeaning /K/E/Y/EntryLocalName/=IndexSerialized/@EntryIndexedValue(any type) The serialized indexed value of the (index, value) pair. Required. Vital for reading the indexed value stored for a specific index. /K/E/Y/EntryLocalName/=IndexSerialized/@EntryIndex(any type) The serialized index of the (index, value) pair. Optional. Non-vital. Useful for reading the storage because the "IndexSerialized" representation is serialized into a restricted charset and is often unreadable with a bare eye, while in this place a more permissive regular entry value serializer is put to use. /K/E/Y/EntryLocalName/=IndexSerialized/@EntryIndexRemoved(Boolean) True to force removing the indexed value from the indexed entry values set. This has an effect when a stack of storages is merged, and the indexed entry has has a value for this index in some lower-priority storage, which a higher-priority storage wants to remove altogether as if it has never been set.Note that for EntryIndexRemoved to work as intended, EntryIndexedValue must also be set to some (dummy) value on the same storage. For performance reasons, storage lookup through layers is only done for EntryIndexedValue, and EntryIndexRemoved is only checked on those storages found during this lookup. Optional. Vital for removing indexed values in an overriding storage. The serialization behavior for index values taking part in storage keys (IndexSerialized in the above examples) differs from that of the indexed values and scalar entry values (and EntryIndex metadata) because we're enforcing strict rules on key local names character set.

Appends a serialized index value.

Base key. MUST NOT be slash-terminated. Index value. Composed string. MUST NOT be slash-terminated.

Appends a serialized index value.

Base key. MUST NOT be slash-terminated. Index value. Composed string. MUST NOT be slash-terminated.

Appends metadata name.

Base key. MUST NOT be slash-terminated. Metadata name to append. MUST NOT include the metadata prefix. Composed string. MUST NOT be slash-terminated.

Appends the local name as the next key component.

Base key. MUST NOT be slash-terminated. Local name to append. MUST NOT include leading or trailing (or any) slashes. Composed string. MUST NOT be slash-terminated.

When settings store data is written into the physical settings storage, all of the storage keys end with the last path component containing metadata names (prefixed with for distinction). Taking an analogy to XPath syntax, we're only addressing attributes, so all of the expected storage keys end with “/@metadataname”.

Individual elements for composing full storage key paths out of individual local names, index values, and metadata names.

Separates local names of settings keys and entries, index values on indexed keys and entries, and tailing metadata name in the path making the settings storage key. Analogous to the XPath separator.

The last component of the settings storage key on which actual data is stored is a metadata name, which is denoted by this prefix to tell apart from other key components.

When one of the storage key path components are formed from a user-supplied value (for example, indices of indexed keys or entries), denotes such keys for telling them apart from key path components coming from keys/entries' local names. If this prefix appears after a settings key or entry local name component in the storage key path, means the key or entry is indexed rather than simple.

Aggregates one more changed key into the total changes delta tree.

Writes key path to the settings key into the empty components list. Leaves one empty leading slot for mounting path component. Throws out exceptions for caller: missing key index.

Writes here. Must be empty. Settings key (its parents and its own components will be written, as well as key index components). Indices to the indexed keys in path. Logger. Callback to be invoked after writing an index for each indexed key. If False, processing is aborted and False is returned. Whether any of the calls returned False. If so, results might be incomplete.

Tracks lists of mounts with defaults for reuse by all clients, most notably, user friendly settings layers.

The current state of the mounts-with-defaults, as a live property which holds an immutable list, with updates on the main thread.

The current state of the mounts-with-defaults, as a live list with updates on the main thread.

Defines the target apartment to dispatch change notifications in.

NULL for MTA, or an STA thread for a STA.

Sets up for the MTA apartment (any MTA thread).

Sets up for the STA apartment of the primary thread (identified by ).

Sets up for the STA apartment of this thread (the thread must be STA).

Delegate for an event sink for the Async Changed signal, like with . See there for comments.

Marks components which implement or interfaces. Logically, they are on the Shell level. The special attribute is required so that those classes could declare the settings keys for which they supply default values. This way their operations could be delayed up until the moment the respective settings keys are queried for. An alternative way is to add the interface to your component and specify the root key through its generic specialization. From now on, all default settings providers are required to specify their root settings key, one way or another.

Declares the settings keys for which the component provides default values.

A type reference to a or a class. All of the default settings provided by this component must be for this settings key or its child keys in the settings schema tree. This MUST be specified for any non-legacy default settings provider because it is required to defer its execution until its settings are actually needed (which could even be never). Instantiation settings

Use this attribute to mark those fields and properties of a settings key class that should be settings store simple entries.

The default value for this entry. You do not need to initialize the field itself in the inline initializer or the constructor. Instead, you MUST set this to the desired initial value, for serialization to work consistently. The possible values are: • Null, which means the default value for the of the field (Null for reference types and zero memory for value types). • Some value of the same type as the of the field, or a value type convertible to it. • An invariant string representation of a value that cannot be presented inline in the attribute ctor. value of the same type as the of the field, or a value type convertible to it. The appropriate is used for reading the value. The string that explains the setting for the means of human-readable settings serialization or settings browser.

The default value for this entry. You do not need to initialize the field itself in the inline initializer or the constructor. Instead, you MUST set this to the desired initial value, for serialization to work consistently. The possible values are: • Null, which means the default value for the of the field (Null for reference types and zero memory for value types). • Some value of the same type as the of the field, or a value type convertible to it. • An invariant string representation of a value that cannot be presented inline in the attribute ctor. value of the same type as the of the field, or a value type convertible to it. The appropriate is used for reading the value.

Uses Reflection to get the entry default value from the loaded runtime type. Avoid using wherever possible because it needs a loaded assembly. For use in static context where settings store is not available and the settings key/entry class is about to be used anyway. NOT for use in any of the Settings Store infrastructure code.

Identifies the entry.

Base attribute for settings entries.

The string that explains the setting for the means of human-readable settings serialization or settings browser.

Gets the string that explains the setting for the means of human-readable settings serialization or settings browser.

Null to use the field/property member name as the settings entry local name in the settings schema. Non-empty to override the local name with a custom string (must comply to key/entry local name rules).

Gets or sets how the value of the field/property should be serialized for storage.

By a name of a primitive mscorlib type, gives out the storage type that will be holding this type (possibly, after coersion).

Applies local name override. The member name is just committed to a runtime string. It's returned so that the runtime string instance could be reused between the local name and the member name in the most likely scenario they're the same.

If the value serializer type is , guesses the actual type by the member type.

Use this attribute to mark those fields and properties of a settings key class that should be indexed store entries. Such an entry declares a set of values accessible with an index, which works as a dictionary or a list in a settings store. The field or property annotated with this attribute must be of type where generic parameters define the index type and the value indexed type.

While simple enables storing atomic values, this option allows to stores dictionaries with arbitrary keys and lists. A list has to be represented as a dictionary because it requires an identity (an index) to define rules for overriding when store is composited from layers. If your list items bear their identity themselves, use them as indices and define values as a simple boolean. If an additional identity is required, use the index as the identity and values as the payload information.

The string that explains the setting for the means of human-readable settings serialization or settings browser.

Gets or sets how indices should be serialized for storage.

Reads the key serializer, also resolves into a specific type.

Marks a class that will be used as a frontend to settings. Represents an indexed settings key which exists in multiple copies per different index values.

The parent settings key. denotes top-level settings keys. You should only have a few in the product. Consider mounting to an existing category instead of creating an new one. The string that explains the setting for the means of human-readable settings serialization or settings browser. Type of the indices to this indexed key.

Gets or sets how indices should be serialized.

Gets the type of the indices to this indexed key.

Reads the key serializer, also resolves into a specific type.

Marks a class that will be used as a frontend to settings. Represents a settings key.

Base attribute for settings keys.

Gets the string that explains the setting for the means of human-readable settings serialization or settings browser.

By default, the class name is used as the settings key name (but for the "Settings" suffix). If this property is non-empty, its value will be used as the key name instead.

Gets the parent settings key. denotes top-level settings keys. You should only have a few in the product. Consider mounting to an existing category instead of creating a new one.

Reads the parent specification out of the attribute, returns its type info (unless it's pointing to the special root type).

Groups info for a single query to an . Allows to place multiple queries so that their set of mounts were consistent for both queries.

The context against which the availability of the items in the group should be checked.

A shortcut to skip all procedures in an availability group if the data context of this query is empty. Since the actual data context is a delegate, allows for a quick check. You may leave False if not sure, though this will result in a slightly worse behavior.

Target list to which the fitting items of this group should be added (to the end, in an undefined order).

Does not write into readonly mounting points. This is the default behavior.

Writes into readonly mounting points.

If we are trying to write a default value for some setting, prefer erasing it from all the mounting points to let the default value (as set on ) have effect. If the defaults layer is present, it also has the same effect. This is the default behavior.

Setting values could be written to it even if they are default values.

Specifies a range of contexts for BindToContext-family methods on .

Gets the widest allowed context of the SmartSave. NULL if the context is not limited on the wide edge (e.g. SmartSave writes can go to the whole range of the narrow context mounts).

Makes a data context on-demand.

Defines the lifetime of the data context.

Converts from a system .

Converts from a string. Ideally, the string must match for format and convert just 32 hex uppercase chars. Does not throw if something goes wrong: uses zeros for missing bytes.

Creates a GUID out of raw data. Ideally, the data should have exactly 16 bytes. Does not throw if something goes wrong: uses zeros for missing bytes.

Converts to the default format string: 32 uppercase hex digits without any other decorations.

Converts to the classic GUID.

Converts to a GUID string using the format specifiers.

Operates the same / API idioms as , but is bound to the specific context (which is defined by with specific mounts selected).

Gets the value of a non-indexed settings entry. Note that you will always get a meaningful value (the entry default value), even if the entry value has not been set, or if the entry parent key does not exist (if there's no instance for such indexed key index). If you're reading entries of an indexed key or its ancestors, verify that key instance exists first.

The value, as set in the highest-priority storage which is not restricted for overriding. The settings entry default value otherwise (Null if not available).

The settings entry whose value is to be read. If this entry is parented by one or more indexed keys, the indices to those keys. It is an error to have an index omitted for an indexed key. The value, as set in the highest-priority storage which is not restricted for overriding. The settings entry default value otherwise (Null if not available).

Executes for a series of entries in a row, which has performance benefits over getting them one by one. All the entries must belong to the same key. For all details, see .

Entries of the single key. If this entry is parented by one or more indexed keys, the indices to those keys. It is an error to have an index omitted for an indexed key. An array of values of the same length as where each value corresponds to the entry at the same index. See for details on the entry values returned.

Sets the value of a non-indexed settings entry.

The settings entry whose value is to be written. The value to be written. Must be of the CLR type specified in the settings entry. If this entry is parented by one or more indexed keys, the indices to those keys. It is an error to have an index omitted for an indexed key.

Resets the value of a non-indexed settings entry in the highest-priority storage. It will have the value in the next storage or the entry default value.

The settings entry whose value is to be read. If this entry is parented by one or more indexed keys, the indices to those keys. It is an error to have an index omitted for an indexed key.

Gets the value of an indexed settings entry.

The settings entry, the value of whose indexed instance is to be read. An index to the indexed entry instance. If this entry is parented by one or more indexed keys, the indices to those keys. It is an error to have an index omitted for an indexed key. The value, as set in the highest-priority storage which is not restricted for overriding. The settings entry default value otherwise (Null if not available).

Sets the value of an indexed settings entry.

The settings entry, the value of whose indexed instance is to be written. An index to the indexed entry instance. If this entry is parented by one or more indexed keys, the indices to those keys. It is an error to have an index omitted for an indexed key. The value to be written. Must be of the CLR type specified in the settings entry.

Removes the value of an indexed settings entry.

The settings entry, whose indexed instance is to be removed. An index to the indexed entry instance. If this entry is parented by one or more indexed keys, the indices to those keys. It is an error to have an index omitted for an indexed key.

Indexed settings key to create an instance of. An index to the to be created, as well as indices to any parent indexed keys of .

Ensures that the instance of an indexed key does not exist anymore in the current layered context. All data for this key index is wiped from the highest-priority storage. If the key still remains defined because of some lower-priority storage, a special revocation flag is written to the highest-priority storage.

Indexed settings key to delete an instance of. An index to the to be deleted, as well as indices to any parent indexed keys of .

Gets whether the instance of an indexed key for particular index is defined in the current layered context. Also checks all possible parent indexed keys of this key, and their indices in . It is valid to pass in a non-indexed key as , in which case its indexed ancestor keys will be checked. If there are none, the key is always assumed as defined.

Indexed settings key to check. Might be a non-indexed key itself to check its possible indexed parents. An index to the to be deleted, as well as indices to any parent indexed keys of . Note that this can be Null if you're testing an arbitrary settings key without checking if it's indexed or not first.

Exposes the mount points that take part in this context. For a transient (non-live) bound context, this value never changes. For a live context, you would get a consistent snapshot for the current moment, see the live property to get events when it changes.

Gets the parent Settings Store which has been bound to the context.

Gets the Settings Schema of the parent settings store.

Gets the flags which were used when a Settings Store were bound to a context.

Gets the snapshot of the Settings Store content in a form of Settings Key and Settings Entry instances.

Optional. If Null, the whole store available in this context is dumped. If non-Null, only those values under the given schema key are included. Optional. Indices to , if it's specified. Delta with extracted settings store values.

Enumerates all the indices of the defined entry indexed value instances, and those values.

Gives out all the indexed key indices currently present in the store. Note that checking by some of these indices might actually return False due to: • Multithreaded access to the settings store.

Returns a layer where a scalar settings entry has explicit value (usually non-default, but it depends)

The settigs entry whose value is to be read. If this entry is parented by one or more indexed keys, the indices to those keys. It is an error to have an index omitted for an indexed key. The highest-priority storage where value is explicitly set or null

Returns a layer where an indexed settings entry has explicit value

The indexed settings entry whose value is to be read. An index to the indexed entry instance. If this entry is parented by one or more indexed keys, the indices to those keys. It is an error to have an index omitted for an indexed key. The highest-priority storage where value is explicitly set or null

Sets the value of a non-indexed settings entry.

The settigs entry whose value is to be written. The value to be written. Must be of the CLR type specified in the settings entry. If this entry is parented by one or more indexed keys, the indices to those keys. It is an error to have an index omitted for an indexed key. Value should be written to this mount point or to mount point with more priority

Sets the value of an indexed settings entry.

The settigs entry, the value of whose indexed instance is to be written. An index to the indexed entry instance. If this entry is parented by one or more indexed keys, the indices to those keys. It is an error to have an index omitted for an indexed key. The value to be written. Must be of the CLR type specified in the settings entry. Value should be written to this mount point or to mount point with more priority

Removes the value of an indexed settings entry.

The settigs entry, whose indexed instance is to be removed. An index to the indexed entry instance. If this entry is parented by one or more indexed keys, the indices to those keys. It is an error to have an index omitted for an indexed key.

Live version of the context-bound store. Is bound to a lifetime, watches for newly-appearing mounting points, retranslates change events.

Adds to the base interface's property: as the live context might see its mount points set change, fires when this happens so that any consumers could update on the new . Note that this does not happen immediately when the set of globally available mount points in changes. Instead, an update is schedulled onto a background thread. The update will be performed sooner if you try to use the context bound store for read/write operations. After the change the mount points set is reflected in this property, there would be an additional delay until respective changes are processed and fired thru or .

Previously, there would be an , but with free-threaded modifications, so it were hard to process its events consistently on clients.

Gets the value of a non-indexed settings entry as a live property. When the value changes in the Settings Store, the property will also change its value (and fire change events) after a slight delay on the same STA or MTA where you made the call to . For instance, if you call it from the STA main thread, you will get all changes on the main thread as well. If you set a new value to the property, the new value will be applied to the settings entry in this bound context using the SmartSave strategy. To ensure correct behavior, only set new values in the same apartment as the initial call to this method, so that change notifications for your changes also complied with the property threading policy. Note that you will always get a meaningful value (the entry default value), even if the entry value has not been set, or if the entry parent key does not exist (if there's no instance for such indexed key index). If you're reading entries of an indexed key or its ancestors, verify that key instance exists first.

The lifetime in which the property listens to the changes in the settings store. The settings entry whose value is to be read and written. If this entry is parented by one or more indexed keys, the indices to those keys. It is an error to have an index omitted for an indexed key.

Same as , but allows to pass the desired apartment for notifications. This allows to make a component which processes its changes on the main thread but can be initially created on any thread.

Marks components which implement or interfaces. The type parameter declares the settings keys for which they supply default values. This way their operations could be delayed up until the moment the respective settings keys are queried for. An alternative way is to mark your component with . This interface is useful when you have a base class, because the base class can explicitly require the type parameter from all is inheritors, while an attribute cannot be explicitly required at design time, and omitting it would only fail at runtime. From now on, all default settings providers are required to specify their root settings key, one way or another.

If you got default settings to be always preloaded into the Settings Store, you can expose by implementing this interface. The component should be marked with and state the settings keys under which defaults are provided. This component should be ready to be factored and queried on any thread and at any moment.

The name for the mounting point which will be mounting your settings stream into the settings store.

If you got default settings to be always preloaded into the Settings Store, you can either push them into the (NOT recommended) or expose by implementing this interface. In the latter case, they will be available immediately upon composition, and the composition will be more performant. The component should be marked with and state the settings keys under which defaults are provided. This component should be ready to be factored and queried on any thread and at any moment.

The name for the mounting point which will be mounting your settings stream into the settings store.

Requests your settings for loading into the system as default settings.

Lifetime of caller's use of the returned stream. The stream which can be loaded into an . It is the callee's responsibility to dispose of the stream correctly if needed, according to the lifetime provided by the caller. Returning a NULL is a valid case if you SUDDENLY discovered you would not like to provide settings in this environment.

Availability function which tells whether the owner is available in the given . For mass querying a large group of mounts for availability, consider implementing for them.

Gets whether the owner is available in the given .

The data context which defines the availability. Availability. This is the synchronous version, which isn't very good with locks. To handle them gracefully, implement an for these mounts.

Availability function which allows to group a set of items and calculate their availability in one action ().

Creates a new empty optimization group might be optimizing this item. This group MUST accept the item it was created from when it is passed to .

Optimizes querying availability of a group of items with one call.

Gets whether this group is empty of any items. Used for cleaning up old empty groups. Unlike checking for emptiness, should not have the penalty of making a copy of all items.

Evaluates items in the group for availability. Must be thread-safe.

Multiple queries to be executed on exactly the same set of mounts (prevents concurrent modifications on other threads). The queries each specify an to calculate availability against, and the output collection.

Evaluates items in the group for availability. Must be thread-safe.

The asynchronous operation lifetime. Multiple queries to be executed on exactly the same set of mounts (prevents concurrent modifications on other threads). The queries each specify an to calculate availability against, and the output collection. This is the async version of the basic , which allows to await for any locks rather than wait for them.

Gets the list of items currently in the group (such that were submitted to with True result, and whose lifetime has not been terminated). To be thread safe, might need to make a copy of the items, beware perf penalty.

Tells whether the given item belongs to this availability group, and will be returned from when it fits. If yes, adds the item to the group for the duration of the . Must be thread-safe.

If the item fits, it should be managed by the group for the duration of the lifetime. If the item does not fit, this function MUST NOT add actions to the lifetime. The item to try adding to the group. Availability object of the item being added to the group. Validate it for being fit for management by this group. True if item is added and tied to the lifetime, False otherwise.

The live set of mount points to which a binds by either means.

Notifies that the mount points list has changed. NOTE that this might be triggered by a call to if a recalc were pending. Should not fire when there were actually no change. Should fire at least once in a reasonable amount of time after starts to return another value. The recalc should happen in absence of calls to as well, otherwise changes would not be dispatched correctly. This signal might not have acknowledgement.

Gets a freehand string which describes the source of this live mounts list, for diagnostics (e.g. memory leak tracking if the list is formed incorrectly). This is especially important for custom-formed mount lists (no based on a context range).

Gets a snapshot of the current list of mount points. If the mount points list updates itself to some external changes asynchronously with a delay (such as with binding to a context range), causes the update to happen so that an up-to-date list would be returned.

Can fire events on changes in settings. Applies to the Settings Store in the whole, and to its live context bindings.

Listens to changes in the settings store. This signal fires on the settings store change processing thread, which might be either a special thread onwed by the settings store, or a pooled thread. It's OK to occupy it for some time, but all other change processing will be delayed by your activities. If you are using lifetimed entities, make sure to protect their use with a synchronized lifetime.

Listens to changes in the settings store. Your sink is called on the settings store change processing thread, which might be either a special thread onwed by the settings store, or a pooled thread. It's OK to occupy it for some time, but all other change processing will be delayed by your activities. You return a task from the sink. Even though this task does not block the thread and multiple sinks might be running in parallel, the change processing awaits for your task before firing subsequent changes, and the would not be completed until all the sinks are completed. Scenarios when you want to return an incomplete task from the sink: caller changes a value in the settings store; caller checks for the task, which is incomplete because the change is pending for processing; the change gets tossed and your sink gets called; the task from your sink completes asynchronously; only after that might become completed; the client knows when the consequences of the changed value are fully applied.

To make a physical settings storage available for use with the Settings Store access, it must be mounted into the Settings Store using this interface.

Gets the name of the mounting point. Usually, this is the same as the storage name. However, it is possible to mount different subpaths of a storage separately, in which case individual mount names should be provided.

Gets whether the mounting point is available in specific contexts.

Gets the priority of this mounting point.

Basic characteristics of the mounting point.

Custom metadata to provide extensive information on the mounting point.

Gets the underlying storage of the mounting point. All of the storage operations should go under .

The mounting path in the storage under which all of the data accessible through this mounting point resides. This allows to mount several subparts of the same storage individually.

The type of this property is essentially a string, but it is strongly-typed to enable smart-completing typical default values when a new mounting point is created.

The central interface for accessing Settings in terms of Keys & Entries in various contexts.

Gets the helper object which creates the data contexts to define the contexts in which settings are read or written. For example, two project files might have different settings because different mounting points are available in their contexts.

Gets the transaction object which this settings store uses for accessing the underlying mounted storages. This is always non-Null if this settings store is running within a transaction (and is actually). If this settings store is not in a transaction, then this is Null.

Gets the total list of mounting points available for storing the settings. Binding the store to a context filters this list down to those mounting points available in a specific context.

Gets the settings schema which describes possible Keys and Entries which can be read or written on the Settings Store.

Binds Settings Store for reading and writing values in a specific context. The resulting object is live, which means it will see the newly-added mounting points (if they fit the context) and can fire events when settings change in this context.

Lifetime for the live context. Range of the contexts for reading and writing.

A lightweight method which binds Settings Store for reading and writing values in a specific context. Do not store the resulting objects because they will not see any newly-added mounts. Does not require a lifetime.

Range of the contexts for reading and writing.

Binds the context to the explicitly specified mount points. The context would be live and the mounts list might also change with time.

Binds the context to the explicitly specified mount points. This means just creating a new bound store on the mount points.

Creates a nested transaction in the current Settings Store. All of the changes to the transacted Settings Store are not visible outside the transaction until you commit them. You have the same interface to the transacted Settings Store as to the normal one, with addition of a few methods for committing and reverting its transaction.

Lifetime of the transaction. The transaction is automatically reverted when this lifetime ends. If you would like to commit the changes, call before terminating the transaction lifetime.

An interface to the settings store that has been created as a child transaction to some other settings store.

Commits the changes accumulated within this transaction to the parent context (to the real Settings Store if this is not a nested transaction). You can continue using the transaction after it's committed.

The operation is thread-safe in that the Settings Store will be running consistently, but you might encounter side-effects if you are working on another thread with the transaction being committed.

Reverts all of the changes performed within the transaction. You can continue using the transaction after it's reverted. Terminating the transaction lifetime also terminates the transaction, so it's not required to call before dropping the obhect.

The operation is thread-safe in that the Settings Store will be running consistently, but you might encounter side-effects if you are working on another thread with the transaction being reverted.

Creator accessors for .

No origin given here because a ContextRange is supposed to handle dropping obsolete mounts correctly and never cause a leak.

Matches the legacy API before mounts list and last-wide were sync'ed by putting them into together so that they changed in sync. Thus dangerous because any settings activity on background threads might observe your partial change (in either collection or the property). Use only when you never change at least one of them.

and make together. and make together.

A live set which never changes.

Wraps a live property. There is no way to force immediate recalculation here. The value in the property is assumed to be always up to date (as much as needed for bound store access).

For sinking property events within this class. The live mount points list. : you should describe the way of making this property list, plus the owner who keeps this list alive, for tracking of memory leaks.

The original property.

This mounting point is providing default values for settings entries and keys.

This mounting point is user writable by default under normal conditions. Mounting points without this flag shouldn't be written to, unless this is specifically desired by user/algorithm.

Standard priority classes for well-known settings storages. NOTE: you should avoid assigning zero priority to mounting points because relative priorities of injected layers will not work correctly in this case.

Storages providing default settings. For example, built-in live templates, SSR patterns mounted by plugins, etc.

One more global storage for per-user settings, for all products. Settings could be promoted here from per-product global user storage.

The default global storage for per-user settings. Specific to the product.

Base priority for nested storages within the hierarchy (for R#, these are solution/project storages). If you need more than one priority level per hierarchy, use different mantissa with the same exponent (i. e. multiply by a positive number below ten).

When we're rendering the settings layers, mount-originating layers take the priority of the underlying mount. The “Smart” synthetic layer does not have a single mount under it. To be displayed in a sorted list along with other layers, it uses this fake priority level. Do not use for real mounting points.

Describes a group of changes to the logical settings store.

Entry point to the hierarchical representation of the changed entities. These objects follow the hierarchy of the logical schema. Only the part of the schema that has changes described by this object is included. By inspecting these objects, you can determine whether the particular key or entry has changed itself. If a key is included but not , then there're some changes in its child keys or entries. For indexed keys and entries, you can get particular index values. This list is ordered by key local names and then index serialized values, which makes it possible to do binary searches.

A sorted hash set of any storage keys affected by this change. This is a hybrid path: the first path component MUST be empty because it's reserved for the mounting path, and the remaining components represent the physical path within the mounted storage.

Quick access to all of the changed keys listed under . Note that this means that either the key has changed, or rather one of its descendants. To get information on indexed key indices, inspect .

Quick access to all of the changed entries listed under . To get information on indexed entry indices, inspect .

There might be such entities in the lists for which there're no descendants with is-changed-itself status (e.g. only technical changes were registered for those). Remove such entities.

A change to a settings key instance. “Instance” means that for an indexed key this refers to a speficic instance (identified by a particular index value) rather then the schema key in general.

The changed settings key.

Child keys of this key, if there were any changes in them. For indexed keys, only particular instances are listed. If more than one instance of the same key was changed, there will be more than one instance of the same key in the list. This list is sorted by key local name and then index serialized value.

If True, there were changes to this exactly key (only applies to indexed key instances, because they might be created and deleted). If False, the key itself didn't change, but this node has some ancestors which changed themselves.

Changed entries of this key, if any. For indexed entries, only particular instances are listed. If more than one instance of the same entry was changed, there will be more than one instance of the same entry in the list. This list is sorted by key local name and then index serialized value.

If is an indexed key, a non-Null index to the particular instance. Otherwise, Null.

Cached delegate.

Serves as a dictionary key when indexing this stull in a parent.

If this is an indexed key instance, deserializes the index value into a runtime object.

A change to a settings entry instance. “Instance” means that for an indexed entry this refers to a speficic instance (identified by a particular index value) rather then the schema entry in general.

The changed settings entry.

If is an indexed entry, a non-Null index to the particular instance. Otherwise, Null.

If True, there were significant changes to this exactly entry. If False, then the entry is only present because some technical information on it might have changed which does not affect the entry value.

Set to true for removed indexed entries

Cached delegate.

If this is an indexed entry instance, deserializes the index value into a runtime object.

If this is an indexed entry instance, deserializes the index value into a runtime object. Throws otherwise or on failures.

Defines the choice of serializers for storing Settings Store data in the underlying physical storage.

Chooses the best serializer automatically based on the member type of the member annotated with the attribute. For primitive types, it's . In most other cases, .

The value is serialized AS IS, as a primitive type. Is not applicable to non-primitive types (those not directly supported by the settings store types).

The is queried for and it is used to convert between the typed value and an invariant string.

The object is serialized into string and back with .

The object is serialized into string with and back with .

The object is serialized into BLOB and back with .

and items.

Path component.

If non-Null, an additional path component with an index value for this indexed key is required after this component.

Base class for entries of a settings key.

Gets the member of the settings key class which defines this settings entry.

Gets the string that explains the setting for the means of human-readable settings serialization or settings browser.

Gets whether this entry is an indexed entry. When True, this instance is actually of type which has additional information about the index type. Otherwise, the actual type of the instance is .

Local name of the entry. Appended to the full name of the containing settings key to get the actual key in the settings storage key-value store. Complies with the identifier rules (). By default, equal to , but might be overridden with .

The settings key containing this entry.

As this entry has been defined by some member (field/property) in the settings key class, gives the name of that member. Same as the by default, but the latter might be overridden with .

Called in non-production envirnoments to retrieve all of the lazy parameters of this key and let all lazied asserts throw out.

Cached path components for mapping this settings schema entity to physical keys in the settings storage.

Lazy-inits on first use and stores for reuse: bases on the parent key, which lazy-inits also.

Describes an indexed settings entry in the settings schema.

Lazy-inited backend for index and value catalog types and their serialization info. Stored together in a reference type to have atomic operations on it.

The CLR type of the index. This is the first generic actual parameter on the member which defines the entry.

The CLR type of the indexed values. This is the second generic actual parameter on the member which defines the entry.

The way indexed values should be serialized. Equivalent to .

The way indices should be serialized. Note that the final algorithm is a bit different from what's applied to serializing entry values because serialized indices take part in the settings storage keys as local names, which implies strict limitations on their type (always a string) and character set.

The type in settings storage with which indexed values are stored.

The type in settings storage with which indices might be stored as settings storage values. Note that normally indices are used as local names within the settings storage key path, where they must always be strings. However, for human readability, we might be writing a copy of the index into the value, in which case it's serialized against the same rules as normal settings entry values. That's where this datum applies.

Boxes the lazy-inited stuff into the single reference.

Describes an indexed settings key in the settings schema.

Whether and already have values and might be used. This must be raised after those are assigned, and after a fence.

Lazy inited, NULL until that, look at .

The type of the index to this indexed key.

Describes a settings key (indexed or not) in the settings schema. Indexed keys are described by a more specific type .

The mandatory attribute on the settings key class.

Lazy-filled on first use.

Entries are kept in this list, sorted by member-name for quicker lookup (lambda expressions give us the CLR member name), after asked for the first time.

Gets the child settings keys of this key. Their will be pointing to this instance. When defining a settings key as a class with or , the is specified as a parameter to the attribute. CLR inheritance has nothing to do with settings key parenting in the schema.

Gets the string that explains the setting for the means of human-readable settings serialization or settings browser.

Gets the settings entries of this settings key. They are defined as fields or properties in the settings key class marked with or .

Gets whether this key is an indexed key. To get an entry value, you must provide an index to each indexed key in the parent keys chain. When True, this instance is actually of type which has additional information about the index type.

Local name of the key. Appended to the full name of the parent settings key to get the actual key in the settings storage key-value store. Complies with the identifier rules (). By default, equal to ., but might be overridden with .

Gets the parent key of this settings key, or Null if this key is one of the root keys. When defining a settings key as a class with or , the is specified as a parameter to the attribute. CLR inheritance has nothing to do with settings key parenting in the schema.

CLR type of the class which defined this settings key.

Optimizes lookup thru lambda expressions which give us the member name.

Called in non-production envirnoments to retrieve all of the lazy parameters of this key and let all lazied asserts throw out.

Cached path components for mapping this settings schema entity to physical keys in the settings storage.

Optimizes lookup thru lambda expressions which give us the member name.

Lazy calculates for us and all the parents.

Describes a scalar settings entry in the settings schema.

After lazy inited, stores the value together with flag to mark as inited.

Gets the default value to be used for this settings entry in case it's not set for this context. Note that the type of this default value is neither nor the . It's the object value written in the . contains special logic for converting this into the runtime entry value type.

The type of this entry in the setting storage. This only matches for select primitive types. In all other cases, is used for converting values between and back and forth.

Gets the CLR type of the value of this scalar entry. This is the type of the object you'll be getting from the when reading this value. For a scalar entry, matches the type of the member which defines the entry..

Gets how the value of the field/property should be serialized for storage. Used for converting values between and back and forth

Gets the entry default value. Accessible even when the settings store is not available at the point (e.g. in a static context or when running in fallback mode without the Shell).

The settings store, if available. If specified, will be for a quick look up of the entry default value. If Null, the default value will be parsed out of the entry itself, which might be slow. Identifies the entry.

Converts the raw default value to the entry value runtime type. If possible, should not let exceptions out.

This schema is the logical schema on settings keys / settings entries, exposed to the application for getting/setting values of arbitrary user types. It is collected by reading classes with (which produces hierarchy of keys) and inspecting their members for (which produces key entries).

Caches the list of the root keys (keys which do not have a parent, which is denoted by the type as the parent key type). This info is repeatedly requested when tossing settings changes, so it's worth storing after getting for the first time.

Indexes child keys by their parent. We can directly get the parent of a key by reading from its attribute, but there's no way to quickly find all child keys when we need to enumerate the tree, so gotta build this index. Lazy-filled when first needed to traverse the tree top-down (usually, not from direct settings access, but on presentation or changes processing).

Indexes settings key catalog types by their string name. Lazy-filled when first needed.

Caches the settings keys which have already been created. They are lazy-created on first access, which offloads computations from startup. Some of the keys are required sync on startup for reading critical settings, but not many. Lock-free access. Multiple instances of a key might be created while doing concurrent GetOrCreate, but only one of them would be exposed.

Called in non-production environments, makes consistency checks on the full schema and causes all of the lazily-computed values be computed and checked.

Called by a key when it delay-queries the list of its child keys.

Nullable`1 not allowed Cannot be boxed, so many of our methods will fail to roundtrip it when serializing Expected to be called on the assertions branch only.

Lazy-called when smb first needs the entries of a key.

Walk base classes (if any) to collect their members as settings entries into a settings class.

Processes a single member in the settings entry class.

Stores the full name of the type and the short name of the assembly (without the strong name, version, etc). Using this identity for types allows us to avoid problems with binding redirections not quite working in our metadata assembly APIs.

Implement this interface on a -annotated class to migrate settings to a newer semantic layout within the Settings Store. You can import components in your constructor. Your object won't have any thread affinity. Don't forget to write your tests, see SettingsMigrationTestBase Also, consider using upgradable settings instead

Same as , but applies to individual entries when the whole key is not considered for migration to the new format. If you're not migrating the whole key, you don't have to list any entries from it or child keys in this parameter. Might be called on any thread.

Yield the keys which your migration routine would like to migrate to the new format, should there be any values under them. Your migration routine will only be called if these are present in some layer, and this migration routine has not yet been called on that layer. This also includes all the entries in these keys, so you don't have to individually list them within . Child keys are also included. Might be called on any thread.

Called on a specific settings layer when a migration case is detected. (1) The settings covered by or are defined in this layer. (2) This migration routine has not yet been called for this layer.

The settings store bound to the specific layer. The default settings layers are not included in the stack. Optional async implementation.

Helps with migrating the semantical settings format to newer versions within Settings Store. Collects possible , determines their applicability, calls per mount.

Can be set in metadata for a mount point to disable migration

Manages user-injected settings layers based on disk files.

Serializes information on a file-based user-injected layer to enable restoring it after application restarts. The index is just an unique key.

Collection of tuples of Layer's display name and icon and injected file

The current actual absolute path of the layer (either calculated from the relative, or taken as absolute).

When a new hosting layer appears, we're notified of it (layer additions are originated in a guarded context).

Reads the list of injections from the host layer and synchronizes the list on our .

Ensures synchronization on reading injected layer settings from the host layer: that the lifetime does not terminate while we're busy.

Normally, host layers are watched for injections info async with a delay. If you've just added injection info, call into this method to immediately update the set of injected layers.

Base key for all injected layers related data.

Requests for resetting the settings to their defaults should be sent thru this class.

Resets settings to their defaults. Unlike , does not treat user-injected layers in a special way.

Optional. The layer to reset settings in. If omitted, settings will be reset in all the layers. Optional. Keys whose child settings should be reset. Settings outside these keys will not be affected. Resets all applicable settings if omitted.

Resets all settings to their factory defaults. User-injected layers are not wiped, they are just deleted as injected layers. If they are injected from a file, the settings in that file remain intact. See also which wipes specific (or all) layers without telling injected ones apart.

We can be settings on options pages in different contexts, like “Smart”, “Solution Shared Settings Only”. Also we might be mounting new settings files as layers and changing their order. This class describes one of these layers, as visible to the user..

The settings context for reading/writing on this layer. All of these are opened over the same settings store transaction. If you're working with these in an Options dialog, then they're in the Options Dialog transaction.

Whether it's the default “Smart” “settings layer” (a combination of all application-wide mounts) which is edited in the default Options dialog.

Identifies this layer in an instance-invariant and transaction-invariant manner.

Priority of this layer when displaying a sorted layers list. The lower the number, the higher the priority.

Exposes the metadata of the layer (writable). For layers based on a mounting point, this is the metadata of the mounting point. For the default layer, this is just a disconnected local bag.

Display name of the layer. This is composed out of the metadata and the mounting point name () if the former is empty.

Icon of the layer. This is composed out of the metadata

Allows to identify and match settings layers in different transactions.

False means that an extension is managing this. Don't let the user edit/delete/reset. They can always disable

True means: this layer needs special handling for editing (not all settings may be changed there) and for saving (may need a special UI). On practice this means a layer hidden from view unless a client makes additional checks (via or via type checking) that it can handle it. Example: editorconfig layer

Whether it's the default “Smart” “settings layer” (a combination of all application-wide mounts) which is edited in the default Options dialog.

We can be editing settings on options pages in different contexts, like “Smart”, “Solution Shared Settings Only” (displayed as tabs above settings page in the options view). This class describes a set of such contexts.

The default options context for smart editing which always exists.

The list of available options context which could be manually selected for editing by the user.

The list of layers that are visible. This is a superset of and includes any layer that has the metadata set (e.g. extensions)

The list of all layers that may be viewed or edited. This is a superset of . It includes, for example, a special EditorConfig layer.

Set this metadata to True on a mounting point if you want to keep it from appearing in the user-friendly settings layers list (in Options' SaveTo, in SettingsLayers dialog, etc).

True mounting point is generated by R#

If set to True, this settings in the mount point cannot be edited by the user, so this layer should not be presented to the user as a save location

Primarily intended for settings exposed by extensions, where the user shouldn't edit them (they should save changes in e.g. the smart layer), but the layer should still be visible in the manage options dialog Use to completely hide the layer from the user

If True, the mount point won't be cleared during Note: The option is ignored if is used.

Some text which hints on the origin of the layer — e.g. from appdata or solution folder.

Short name for displaying when there is not enough place for a full name

In case this layer originates as a disk file, exposes the full path to that file.

If non-empty, could be used as the display name for the layer in the user interface. Otherwise, the mount point name should be used where applicable.

Layer ID

If non-empty, could be used as the icon for the layer in the user interface. Otherwise, the mount point name should be used where applicable.

By default, layers with metadata are excluded from the user-friendly-layers list. This flag overrides the behavior to include all of the available layers.

Any layer besides the default (smart) one originates from a mounting point, which is made writable and to which all of the mounting points with factory defaults are mixed in. This gives out this originating mount of the layer, or Null for the default (smart) layer.

Whether it's the default "Smart" "settings layer" (a combination of all application-wide mounts) which is edited in the default Options dialog.

Central management authority for user-injected settings layers — those that were added by a user when mounting e.g. a disk file as a new settings layer. “User-Injected Layer” — a settings layer (backed up by a mounting point in the Settings Store) created by the user over some disk file or URI or other media. “Layer Hosting User Injections” — to restore injected layers in subsequent sessions, information on them is stored as settings in one of the regular layers. A layer which can store such information is a hosting layer (regardless of whether it has any such records already or not). Each user-injected layer belongs to exactly one hosting layer, so they have some kind of a parent-child relation. Currently an injected layer cannot host injections, but that might be a subject to change. The overall operation is as follows: when sees a new hosting layer, it publishes it on the collection. Specific user injected layer implementations watch this structure, load their settings from each new hosting layer, and call into for registering the layer. Creation of a brand new injected layer is on the handlers' part. Layer deletion could be initiated from because there should be the single deletion action for the layers.

If the mounting point is holding the list of user-mounted layers which are mounted when the mounting point is loaded and aligned in the same “group” as their parent mount.

If the mounting point was created as a user-mounted layer based on the list in some mounting point.

Metadata on the mounting point of the injected layer with its descriptor object, as provided by the owner.

Lists all of the injection hosting layers which might possibly contain records on injected layers in them. Injection handlers should watch this collection, read their own injection information in their own format from the settings of that layer, and for each of such layers.

Allows to get injection runtime info by injected layer ID. Mounts are created by s, a runtime info lives the whole span the injection is defined, while the mounts get recreated from time to time.

Allows to get hosting layer runtime info by hosting layer ID.

Same as , but contains the full info.

Registers a user-injected layer in the settings system. After calling this method, the layer becomes available with the Settings Store, and this class registers its relation between the injection host and injected layer. This method is to be called by injections functionality implementation (for example, file-based injections). That code should watch for any new , read the feature-specific injection information from it, create the storage and the mounting point WIHTOUT registering them with the settings system, set metadata on the mounting point, and supply the metadata to this function. When the layer is just injected by the user in the UI, the injection settings should be written to the appropriate injections host, the functionality should then get the change notification and process it by creating the storage and supplying it to this function.

Duration of the injection registration.

Gets whether this layer has been user-injected.

Gets if the layer might yield user-injected layers. Note that this does not necessarily mean it will.

If this layer is user-injected, gets the layer which is hosting it. Otherwise, NULL.

If this layer is user-injected, gets the layer which is hosting it. Otherwise, throws an exception.

Expose those mounts that might have user-mounted layers written to them.

Asserts user-mounted-layer-related metadata flags combination is valid on mounting points.

Gets user-injected layers coming from all the hosts.

Gets user-injected layers coming from the specific host.

Deletes the user-injected layer: the record on the injection in the hosting layer is erased, and the layer disappears from the settings system.

An injected layer might be turned off, in which case all of its settings do not take effect, even though information about the layer is not removed from the system. This method allows to toggle the state.

True to turn on, False to turn off, Null to toggle. Actual on/off state after this method runs (especially useful with Toggle).

See . Gets the current state.

Gets whether we can change relative order of the injected layers of the same hosting layer.

The layer whose position is supposed to be changed. How the potision should be changed. See flag values for details.

Changes relative order of the injected layers of the same hosting layer.

The layer whose position is to be changed. How the potision should be changed. See flag values for details. Meaning depends on the value, see flag values for details.

Info provided by layer registrator.

The injections host (which stores the information about the injected layer in its settings). If you're watching for , then it's the layer you got notified of.

The persistent identity of this injected layer. For such features as turning injected layers on/off and editing their priority to work between sessions, this must be persistent between sessions per layer. This should be related to the information stored in the hosting layer by the injection handlers. NOTE: this identity must be unique per hosting layer.

The storage which should be mounted as an injected layer.

Called by when user requests deletion of an injected layer.

Any initial metadata, such as a custom display name, which will be applied to the mounting points created to represent your injected layer in the Settings Store.

Info on the runtime instance of an injected layer, as stored by this class.

Data on the hosting layer (“parent” of this injected layer).

The mounting point currently representing this injected layer. It is registered with the Settings Store. It is recreated per each combination of the flags, e.g. on change of the priority.

When True, the contents of the mount take part in the Settings Store. When False (which corresponds to the unchecked checkbox in the Settings Layers dialog), the contents of the mount are excluded from the Settings Store, even though it's still listed throughout the system. This is manifested thru the parameter. A mount is recreated to update this flag.

The mount priority, as exposed in . A mount is recreated to update this flag.

Exposes ..

Bound to the display name metadata on all of the mounts.

Lists the injected layers of this host. Is a hash set.

Helper dictionary for navigating by identities.

Changes relative order of the injected layers of the same hosting layer.

The layer whose position is to be changed. How the potision should be changed. See flag values for details. Meaning depends on the value, see flag values for details. Invariants: (1) The priorities must be changed so that the desired order applies. (2) We assume that all of the existing priorities are different (otherwise (2) might not be totally fulfilled). // TODO: validate on host load (3) As few positions as possible must be changed, because a position change means recreating mounting points and firing settings changes on each operation. Algorithm: Determine two priorities between which the item should be placed. On edges, higher one is zero and lower one is last plus one. Choose the new priority to be the mean value of those two priorities.

Reads all of the priorities known to customization settings, and makes sure they're consistent in that there're no missing, negative, or duplicate values. Rewrites priorities in the settings store before returning the list as needed.

Makes the layer first in the list (with the highest priority). This flag does not require the “other” parameter.

Makes the layer last in the list (with the highest priority). This flag does not require the “other” parameter.

Places the layer immediately before another layer (with a slightly higher priority). This flag requires the “other” parameter.

Places the layer immediately after another layer (with a slightly lower priority). This flag requires the “other” parameter.

Takes the nearest layer with a higher priority and does for it. This flag does not require the “other” parameter.

Takes the nearest layer with a lower priority and does for it. This flag does not require the “other” parameter.

Root key for Environment settings. Refer to it in your settings classes that should be directly parented under Environment — but preferably choose any of the existing nodes under Environment.

Root key for all housekeeping data (i.e. cached shortcuts data, recently used something global etc). Refer to it in your settings classes that should be directly parented under Housekeeping — but preferably choose any of the existing nodes under Housekeeping.

On product shell start-stop, exposes the product info in the logs.

Add own listener to intercept problems on callstacks where our code (any) is present, and submit to exception reporting.

Applies the command line arguments to the logger.

Asserts that any primary-thread lock is guarded by .

WTF

Checks if the one-time-init is requested. Optionally, marks it as done in the Registry (write-touches Current User hive only).

If the per-machine one-time-init value is not available, this value is used instead.

ToString must provide a human-readable string for the shortcut.

Updates "multi_ide_action_map.json". See: ssh://git@git.jetbrains.team/keymaps/keymaps.git This is a modified code based on MappingUtils originally written by @Vladimir.Krasnotsvetov

Action should be available everywhere: in common scope and in text controls.

Action should be available in text controls only.

Action should be available in global scope, but not in text controls.

Warning! Duplicates on all sides. WinForms enum member values numerically match the VK_* constants, so you can cast the first field.

Can be taken once per process (not per thread as ). Only one acquire per process is possible.

Scheduler interface for

Schedules an action to process items

Lifetime validity Action to perform

Number of continuous interrupts How processing should continue

IsEmpty property which should be used by subscribers which want to be 100% sure that the corresponding advise logic for "IsEmpty=False" event will be executed BEFORE the item will be processed.

Adds an item to the head of the processing queue. If the item is already in the queue, it moves it to the front. Note: This API is not optimized; avoid using it in performance-critical code.

The item to add or move to the front of the queue.

Removes all items from the queue except those that are currently being processed (if any).

A read-only list of the items that were removed from the queue.

A lazily-calculated asynchronous value with ReadLock requirement. Provide safe way to get result value from code with WriteLock.

Proper way to get value sync instead of sync waiting by GetValueAsync().Result, which can lead to deadlock when called from MainThread.

Calculates value with ReadLock in loop to handle interrupts

Implements the housekeeping logic around for the needs of full functionality.

Identifies the primary thread (for the Write Lock affinity). Attaches to the thread it's created on.

True if read access is allowed in the current thread.

Indicates that the current thread owns the read lock.

True if write access is allowed in the current thread.

Indicates that the current thread owns the write lock.

Indicates that any thread (UI thread in non-forked content model) requests for write lock, but not yet granted.

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.

The timestamp is incremented each time write lock is requested and released.

Event which is raised before read lock is acquired. Fires on the same thread.

Use-cases: 1) threading asserts. This event is not fired in content model forks.

Fires after the Read Lock is released in any thread. Fires on that same thread.

Use-cases: 1) ui smoothness asserts. This event is not fired in content model forks.

Event which is raised before write lock is acquired. This event can be used by background operations which need to stop/pause to allow write operation to execute.

This event is not fired in content model forks, instead is fired. AcquireWriteLock

Event which is raised before write lock is acquired in content model fork context.

Fires after the Writer Lock is acquired in any thread. Fires on that same thread.

This event is not fired in content model forks.

Fires after the Writer Lock is released in any thread. Fires on that same thread.

Use-cases: 1) cache notifications for goto navigation feature throttling. This event is not fired in content model forks.

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

Hi-perf tracking of the recent writer lock callers. We get the anyway when taking a lock, here we store it in a cyclic buffer (limiting max count). Not conditioned by any logger/assertion mode, because there should be no penalty. Threading: only records acquired writer locks, so naturally protected by the writer lock. Reading is diagnostic-only, not in prod code, so on your own risk (usually from debugger).

A live property for , but polite interrupts are also counted (see )

Internal api for supporting async write lock. Consider using an extensions method on shellLocks. They are aware of and can provide a sane API

Once the last Read Lock is released and a Write Lock can be taken immediately, the will be called only once on undefined thread. The lifetime of the write lock wait When is true, this method issues and send interruption request to sources which support polite interruption until the provided lifetime is terminated. Non-interrupt mode just waits until all readers are gone. Can be called from any thread

Attempts to acquire (and immediately release) Write Lock (w/o event notifications) to detect if there are any readers active. If there are no readers - executes all subscriptions inline and returns 'true'. Otherwise, returns 'false'.

Polite interrupts are caused not only by direct blocking write lock request on the main thread, but also logical one, by adding activities when polite interrupt is requested. If you decide to respect this kind of interrupts, you should reschedule your background activity only after became true. The reason why this interrupt kind isn't default is historical. A lot of interruptable reschedule themselves instantly after the interrupt. When async write lock is requested, the main thread remains free. That means, that the activity will reschedule itself instantly and interrupt instantly after reaching background thread.

Returns lifetime of content model state when background readers are allowed. This lifetime is terminated when some activity requests (not when acquires but when just asks) a non-gentle write-lock, and is renewed when write-lock request finishes (successfully or not). So new lifetime is created not on release but on acquire, this allows get lifetime for async readers from current writer activity. Could be used for asynchronous operations. MUST BE Taken Under Read Lock. Please don't use it for interrupts. Write lock acquisition terminates this lifetime BEFORE read locks are prohibited! (see ShellLocksTest.InterruptionTest)

Returns lifetime of content model state without new write locks. This lifetime is terminated when some activity acquires a write-lock. Taken under write-lock lifetime will be alive till next success lock acquire. Could be used for asynchronous operations. MUST BE Taken Under Read Lock.

Write Lock event callbacks should not benefit from currently obtained locks. This cookie enforces that.

Represents the interruption source that fires when Write Lock is requested. Represents the interruption source that fires when Write Lock is requested. logical bool Represents the interruption source that fires when Async Write Lock is requested. Represents the interruption source that fires when Async Write Lock is requested. logical bool, 1 means 'Write Lock requested or held by some thread or there is async write lock request aka polite interrupt'

Wraps by executing the same single action. If the execution has been delayed because another execution is in progress ( scenario), does not queue any more executions until the pending one is executed. When the object is disposed of, drops all of the pending executions so that they're never executed after the . Mostly like a , but without any grouping or additional delaying.

Initializes a new instance of the class.

Initializes a new instance of the class. Allows to specify the execute-or-queue action manually.

The useful user action to be executed when the guarded context is entered. The action that causes something to be executed or queued.

Subscribers must be fast. Otherwise, it will cause performance issues in grouping events.

Override this method with activity that should happen in primary thread before background thread

Override this method with activity that happens in background thread.

This method should periodically check return value of interrupt and either return or throw OperationCanceledException NOTE: the method may not be called if lifetime expires.

Override this method with activity that will happen in primary thread after worker thread finishes NOTE: the method may not be called if lifetime expires.

This method is invoked in primary thread if work is interrupted. NOTE: read lock is released between interruption and this method call! If this method is invoked, Finish will NOT be called. NOTE: the method may not be called if lifetime expires.

A non-abstract implementation for the that allows to specify its behavior externally, without creating an inheritor.

Constructs the instance.

The interruption that will be used for cancellation in the function.

Gets or sets the function that is executed in case the action is aborted. NOTE: the method may not be called if lifetime expires in an inappropriate moment.

Gets or sets the function that gets executed on the UI thread in case the action completes successfully.

Gets or sets the function that is executed on the primary/UI thread when the action finishes execution with either result. NOTE: the method may not be called if lifetime expires in an inappropriate moment.

Gets or sets the worker function that executes on the secondary thread. NOTE: the method may not be called if lifetime expires in an inappropriate moment.

Gets or sets the function that is executed on the primary/UI thread when the action starts.

Gets or sets the name for the operation, and for the worker thread of the operation.

Override this method with activity that will happen in primary/UI thread after worker thread finishes

This method is invoked in primary thread if work is interrupted.

If this method is invoked, Finish will NOT be called.

Override this method with activity that should happen in primary thread before background thread

Override this method with activity that happens in background thread.

This method should periodically check return value of d and either return or throw OperationCanceledException

A combined invocator that encapsulates both and . When disposed of, shuts down the and cancels all of its timed actions. It's OK for individual alarm consumers to dispose of them as well.

Gets or sets whether the application is currently active (and background activities are allowed). Used to suspend recurring actions execution when inactive.

Gets the dispatcher of the thread served by this Invocator. On a Shell's invocator, this would be the application's main thread.

Gets or sets whether the application is currently active (and background activities are allowed). Used to suspend recurring actions execution when inactive.

Gets the reentrancy guard that implements the non-timed actions of this Invocator.

Provides access to the underlying , , , and .

Expands basic threading constructs with the Reader-Writer pessimistic locking which protects the content model stuff, such as Documents, Project Model, PSI, and so on.

The Reader-Writer pessimistic locking which protects the content model stuff, such as Documents, Project Model, PSI, and so on.

When executed under a reentrancy guard, lifts the guard and releases all of the locks, ie constructs a clean state. Must be executed on the primary thread.

Name for the lifting. Information about caller The action to be executed in the clean state.

Executes an action on the primary thread in a guarded context. If called on a foreign thread, executes the action asynchronously, like . If called on the guarded thread, checks for reentrancy. If there are no guarded executions on the stack yet, executes the action immediately and synchronously. Otherwise, postpones the action for asynchronous execution, like does. Takes a read lock.

The name for the task. Information about caller The action to execute. Exceptions will be trapped. Priority. True if executed immediately, False if queued (-compatible behavior).

The name for the task. Information about caller The action to execute. Exceptions will be trapped. True if executed immediately, False if queued (-compatible behavior).

The name for the task. Information about caller The action to execute. Exceptions will be trapped. Priority. True if executed immediately, False if queued (-compatible behavior).

The name for the task. Information about caller The action to execute. Exceptions will be trapped. True if executed immediately, False if queued (-compatible behavior).

The name for the task. Information about caller The action to execute. Exceptions will be trapped. Priority. True if executed immediately, False if queued (-compatible behavior).

The name for the task. Information about caller The action to execute. Exceptions will be trapped. True if executed immediately, False if queued (-compatible behavior).

The name for the task. Information about caller The action to execute. Exceptions will be trapped. Priority. True if executed immediately, False if queued (-compatible behavior).

The name for the task. Information about caller The action to execute. Exceptions will be trapped. True if executed immediately, False if queued (-compatible behavior).

Queues the action to execute asynchronously on the primary thread in a guarded context, as soon as possible. Free-threaded. The reentrancy between guarded actions is prevented. Takes a read lock.

The name for the task. Information about caller The action to execute. Exceptions will be trapped.

Queues the action to execute asynchronously on the primary thread in a guarded context, as soon as possible. Free-threaded. The reentrancy between guarded actions is prevented. Takes a read lock.

The name for the task. Information about caller The action to execute. Exceptions will be trapped. Priority.

Queues the action to execute asynchronously on the primary thread in a guarded context, as soon as possible. Free-threaded. The reentrancy between guarded actions is prevented. Takes a read lock.

The name for the task. Information about caller The action to execute. Exceptions will be trapped.

Queues the action to execute asynchronously on the primary thread in a guarded context, as soon as possible. Free-threaded. Takes a read lock. If Async behavior is prohibited, like in test environment, always executes synchronously.

The name for the task. Information about caller The action to execute. Exceptions will be trapped. Priority.

Checks whether read lock is acquired and issues an internal assertion if it's not true. Useful method to be inserted in data access methods to ensure correct use of locks.

Checks whether write lock is acquired and issues an internal assertion if it's not true. Useful method to be inserted in data modification methods to ensure correct use of locks.

Tries to acquire the reader lock, keeps trying for at most . Optimal for use on back threads to avoid blocking. Holds the lifetime while executing.

Whether the action were executed — we could get the reader lock and the lifetime were alive enough. Timeout in milliseconds till read activities are not to be interrupted Timeout in milliseconds till read activities are not to be interrupted Name of the action for logging/ testing purposes

Executes specified function under write lock delayed until write lock is available. The method can be called from any thread.

instance Lifetime for the function. If lifetime is terminated before execution task will be returned in canceled state Information about caller Function to execute Timeout till read activities are not to be interrupted Function return type Task wrapper over the function Timeout in milliseconds till read activities are not to be interrupted Timeout in milliseconds till read activities are not to be interrupted Timeout in milliseconds till read activities are not to be interrupted Timeout in milliseconds till read activities are not to be interrupted Timeout in milliseconds till read activities are not to be interrupted Timeout in milliseconds till read activities are not to be interrupted

Executes specified function under write lock if it can be taken immediately or delayed until it can be acquired. Can be called on UI thread in guarded context only.

instance Lifetime for the function. If lifetime is terminated before execution task will be returned in canceled state Name of the action for logging/ testing purposes Information about caller Function to execute Timeout till read activities are not to be interrupted Function return type Task wrapper over the function

Executes specified function under write lock after all read activities are terminated. The method can be called from any thread. Will terminate only polite read-lock activities (see ) when is set to true. The difference with the WriteLockWhenAvailable family of methods is in the implementation details: WhenAvailable uses polling and tries to get the write lock at a random time. AsyncWriteLock is deeply integrated with ContentWriteLock and queues action as soon as the last readlock is released.

instance Lifetime for the function. If lifetime is terminated before execution task will be returned in canceled state Information about caller Function to execute After reaching this timeout the action will be executed with regular writelock on the main thread whether to interrupt polite read activities or not A task that finished in a writelock context

Executes specified function on the main thread in the guarded context when most of background activities are terminated or timeout expired. The method can be called from any thread. Will terminate only polite read-lock activities (see ) when is set to true

Hides all the read locks taken by the current thread, and returns them back on dispose. Used by wait-for-caches kind functions to allow write locks on the other thread.

Is on main thread with guard and read lock

IShellLocks instance True if on main thread in guarded context

Is on main thread

IShellLocks instance True if on main thread in any (guarded or unguarded) context

The name for the task. Information about caller The action to execute. Exceptions will be trapped. This is temporary version till IShellLocksEx.HideReadLocks removing, with sync

Start action on background thread (JetPool).

Start action on background thread (JetPool) with ReadLock.

retry operation if lifetime is and action finished with Information about caller

Start action on background thread (JetPool) with ReadLock.

retry operation if lifetime is and action finished with Information about caller

Starts action on main thread under read lock.

Starts asynchronous action on main_thread+read_lock context. Action supports await inside. Please note that after await execution will be returned to main_thread+read_lock context .

Exposes threading tasks of the application.

Gets the of the home thread of this instance. If you get the threading object imported into a component, then this is the primary thread of your component container.

A host that creates grouping events to be executed on the home thread of this instance (optionally, under protection of the ). If you get the threading object imported into a component, then this is the primary thread of your component container.

Gets or sets whether the application is currently active (and background activities are allowed). Used to suspend recurring actions execution when inactive.

Gets the of the home thread of this instance. If you get the threading object imported into a component, then this is the primary thread of your component container.

Gets the .NET Async Tasks API for executing tasks asynchronously on either background or main thread, optionally with guarding and content access locks.

Gets the scheduler for running background tasks on other threads.

Schedules one-time and recurring actions to be executed on the home thread of this instance, optionally under protection of the . If you get the threading object imported into a component, then this is the primary thread of your component container.

Checks that the activity is executed on the proper thread and is being guarded from reentrancy. Does not break execution, just logs the failure — the common case of the failure is adding new guard-checks, in which case the features could go on functioning “as before” without breaking execution, but logging the failure.

Executes an action on the primary thread in a guarded context. If called on a foreign thread, executes the action asynchronously, like . If called on the guarded thread, checks for reentrancy. If there are no guarded executions on the stack yet, executes the action immediately and synchronously, like . Otherwise, postpones the action for asynchronous execution, like does.

The name for the task. Information about caller The action to execute. Exceptions will be trapped. Priority. True if executed immediately, False if queued (-compatible behavior).

Executes an action on the primary thread in a guarded context. If called on a foreign thread, executes the action asynchronously, like . If called on the guarded thread, checks for reentrancy. If there are no guarded executions on the stack yet, executes the action immediately and synchronously, like . Otherwise, postpones the action for asynchronous execution, like does.

The name for the task. Information about caller The action to execute. Exceptions will be trapped. True if executed immediately, False if queued (-compatible behavior).

Executes an action on the primary thread in a guarded context. If called on a foreign thread, executes the action asynchronously, like . If called on the guarded thread, checks for reentrancy. If there are no guarded executions on the stack yet, executes the action immediately and synchronously, like . Otherwise, postpones the action for asynchronous execution, like does. If Async behavior is prohibited, like in test environment, always executes synchronously.