BeatyBit.Armature.Core

Indicates that the marked symbol is used implicitly (e.g. via reflection, in external library), so this symbol will be ignored by usage-checking inspections.
You can use and to configure how this attribute is applied.


             [UsedImplicitly]
             public class TypeConverter {}
            
             public class SummaryData
             {
             [UsedImplicitly(ImplicitUseKindFlags.InstantiatedWithFixedConstructorSignature)]
             public SummaryData() {}
             }
            
             [UsedImplicitly(ImplicitUseTargetFlags.WithInheritors | ImplicitUseTargetFlags.Default)]
             public interface IService {}

Can be applied to attributes, type parameters, and parameters of a type assignable from . When applied to an attribute, the decorated attribute behaves the same as . When applied to a type parameter or to a parameter of type , indicates that the corresponding type is used implicitly.

Specifies the details of implicitly used symbol when it is marked with or .

Only entity marked with attribute considered used.

Indicates implicit assignment to a member.

Indicates implicit instantiation of a type with fixed constructor signature. That means any unused constructor parameters won't be reported as such.

Indicates implicit instantiation of a type.

Specifies what is considered to be used implicitly when marked with or .

Members of the type marked with the attribute are considered used.

Inherited entities are considered used.

Entity marked with the attribute and all its members considered used.

This attribute is intended to mark publicly available API, which should not be removed and so is treated as used.

Tells the code analysis engine if the parameter is completely handled when the invoked method is on stack. If the parameter is a delegate, indicates that delegate is executed while the method is executed. If the parameter is an enumerable, indicates that it is enumerated while the method is executed.

Indicates that the marked method builds string by the format pattern and (optional) arguments. The parameter, which contains the format string, should be given in the constructor. The format string should be in -like form.


             [StringFormatMethod("message")]
             void ShowError(string message, params object[] args) { /* do something */ }
            
             void Foo() {
             ShowError("Failed: {0}"); // Warning: Non-existing argument in format string
             }

Specifies which parameter of an annotated method should be treated as the format string

Indicates that the marked parameter is a message template where placeholders are to be replaced by the following arguments in the order in which they appear


             void LogInfo([StructuredMessageTemplate]string message, params object[] args) { /* do something */ }
            
             void Foo() {
             LogInfo("User created: {username}"); // Warning: Non-existing argument in format string
             }

Collection of build actions grouped by a build stage.

These methods are implemented as extensions instead of class members in order to be able to operation with 'null' BuildActionBag.

Merges two collections into one

Returns the build action with biggest matching weight for the build stage.

Throws if there are more than one action with equal matching weight.

Build action. One or more build actions should be performed to build a unit.

Building is two-pass process, each build action called twice. is called in reverse order of

This method is called first for all matched actions in direct order. Once is set by any action, no other matched actions are called.

This method is called when all actions for which was called are rewind back after the unit is just built.

Collection of build actions with weight grouped by a build stage.

The builder of units. It is the convenient way to couple a build stack pattern tree, (), build stages, and parent builders together to pass into a .

Used in logs an for debugging The ordered collection of build stages all of which are performed to build a unit. Used in logs an for debugging The ordered collection of build stages all of which are performed to build a unit. See for details. If unit is not built and are provided, tries to build a unit using parent builders one by one in the order they passed into the constructor.

Used in logs and for debugging.

A result of building a Unit, null is a valid value of the .

Represents whole build session of one Unit, all dependency of the being built Unit are built in the context of one build session.

It could be for example IA -> A -> IB -> B -> int. This stack means that for now Unit of type int is the target unit, but it is built in the "context" of the whole build stack. The sequence of build stages. See for details. Build stack patterns tree used to find build actions to build a unit. Additional build stack patterns tree, in opposite to these patterns are passed to if unit is being tried to build via parent builders. If unit is not built and are provided, tries to build a unit using parent builders one by one in the order they passed into the constructor.

Common logic to build one or all units

Represents the "building stack". It could be for example IA -> A -> IB -> B -> int. This stack means that for now Unit of type 'int' is the target unit but it is built in the "context" of the whole build stack.

The unit to be built

Gets the tails of the stack. remains the same, in opposite to items accessed by

The index of the item which should became the very first item of the tail.

Builds a unit identified by the .

The id of the unit to be built. Optional tree of build stack patterns which will be used along with the permanent one to build a unit or it's dependencies.

Builds all units represented by by all build actions in spite of matching weight. This can be useful to build all implementers of an interface.

The id of the unit to build. Additional build stack pattern tree containing build actions to build a unit or its dependencies. Returns if no units were built.

This is a limited interface of the passed to and .

The result of building. Build actions can check if the unit is already built, or set the result.

The stack of units representing a build session. See for details.

Builds a unit represented by in the context of the current build session.

"Id" of the unit to build. See for details Determines whether to build a unit via parent builders in case it's not built in the scope of the current build session. Default: true.

Builds all units represented by with all build actions in spite of the weight. This can be useful to build all implementers of an interface.

"Id" of the unit to build. See for details If true is called for whole parent builders graph, if false build unit only in the scope of the current build sesstion. Default: true. Returns an empty list if no units were built.

Base class implementing

The collection of all children nodes used to find existing one, add new, or replace one with another. All nodes with their children are a build stack pattern tree.

Adds a as a child node if the node is not already added. Returns the new node, or the existing node if the node already added.

Call it first and then fill returned with build actions or perform other needed actions due to it can return other instance of then passed .

Gathers and merges build actions from all children nodes.

The build stack to pass to children nodes if any. The weight of matching which passed to children to calculate a final weight of matching.

Base class for build stack patterns using to match the passed .

Returns 'this' in order to use fluent syntax

The root node of the tree of nodes.

This class implements and has method in order to make possible compact and readable initialization like new BuildStackPatternTree(...) { new IfFirstUnit(new IsConstructor()) .UseBuildAction(new GetConstructorWithMaxParametersCount(), BuildStage.Create), new IfFirstUnit(new IsParameterInfoList()) .UseBuildAction(new BuildMethodArgumentsInDirectOrder(), BuildStage.Create), new IfFirstUnit(new IsParameterInfo()) .UseBuildAction(new BuildArgumentByParameterType(), BuildStage.Create) };

Reuse implementation of to implement public interface.

A pattern used to match a unit or their combination in the build stack. See for details.

Adds a as a child node if the node is not already added. Returns the new node, or the existing node if the node already added.

Call it first and then fill returned with build actions or perform other needed actions due to it can return other instance of then passed .

Adds the as a child node.

A node is already in the tree.

Adds a which will be called to build a Target Unit matched by the branch of the build stack pattern tree represented by this node with its parents.

A build action. A build stage in which the build action is executed. Returns true if build action was added, false if the equal build action is already in the collection.

Returns build actions which should be performed to build a .

The stack of units representing a build session. Each unit is the dependency of the "deeper" in the stack one. The weight of matching which used by children matchers to calculate a final weight of matching IA -> A -> IB -> B. This stack means that for now Unit of type 'B' is the target unit but it is built in the "context" of the whole build stack. Returns all matched build actions for the . All actions are grouped by a building stage and coupled with a "weight of matching". See for details.

Checks if the first unit in the build stack matches the specified pattern.

Checks if the first unit in the build stack matches the specified patter. If it is the target unit, returns build actions for it, if no, pass the rest of the build stack to each child and returns all actions from children merged

Moves along the build stack skipping units until it encounters a matching unit. Behaves like string search with wildcard.

Moves along the build stack skipping units until it finds the matching unit. If it is the target unit, returns build actions for it, if no, pass the rest of the stack to each child and returns merged actions.

Skips units from the build stack while unit matches specified pattern till the target unit. The target unit is never skipped.

Inherit this class to extend enum pattern with custom weights or want to re-balance the weighting system.

Note that and are multipliers, see the implementation of method . in classes and , whereas is an absolute value. Make sure that and will never "win" when change their values.

Weights of is about two orders of magnitude higher than weights of in order to registrations like builder.GetOrAddNode(new IfFirstUnit(Unit.Of(typeof(string)), WeightOf.InjectionPoint.ByType)) .GetOrAddNode(new SkipTillUnit(new Unit.Of(typeof(ChildType)), WeightOf.UnitPattern.ExactTypePattern)) never "wins" builder.GetOrAddNode(new IfFirstUnit(Unit.Of(typeof(string)), WeightOf.InjectionPoint.ByName)) .GetOrAddNode(new IfFirstUnit(new IsInheritorOf(typeof(BaseType)), WeightOf.UnitPattern.SubtypePattern)) because the first one is registration for building "in context" of ChildType whereas the second one is "personal" registration of all inheritors of BaseType

Exception is used to distinguish internal unexpected situations and error produced by user code

A list which doesn't allocate inner array if contains less than five items

Represents an object as a text ready to be logged.

An object is able to print its content to the log not as a part of runtime logging but as an entity with content.

Class is used to log Armature activities in human friendly form in HOCON format. Writes data into , so add a listener to see the log.

Set should full type name be logged or only short name w/o namespace to simplify reading.

The count of spaces used for indentation

Can be used instead of passing lambda into if logging is placed on a critical path and even creating of a lambda and even more so a closure is not an option.

See usages in Armature itself for details.

Enables logging, disposing returned object revert Log to the previous state

Disables logging, disposing returned object revert Log to the previous state

This method calls only if Logging is enabled for , use if calculating arguments for logging takes a time.

Makes indented "block" of log data.

Makes named and indented "block" of log data

Makes a named and indented "block" of log data

Executes action if satisfies current Log level. See for details. Use it if there are complex computations to prepare log data to avoid performing them if the is less than needed.

If the current is less then passed Log doesn't enter into the conditional mode, because all records with bigger then currently active will be ignored. If the current is bigger then passed Log doesn't enter into the conditional mode, because all records with less then currently active will be written anyway. If the current is equal to passed all records to the log will be preserved till returned object is disposed, then records with equal to the current will be written only if . set to true.

Returns the name of respecting property

Returns log representation of object, some objects logs in more friendly form then common returns

This interface provides access to the internal fields in the generic form for the sake of possible extensibility by the end user. See implementation for details.

Generic approach of creating singleton instances of a type when needed.

Couples an entity with a weight.

Represents a pattern used to match with the unit id in order to gather a set of needed to build a unit.

Unlike which works on a build stack at whole, this pattern is used to match a single Unit.

Checks if passed matches the pattern.

No equality member are needed for this class, is used only for debug purpose, these tags should be equal by the reference.

Means "any tag", it is used in patterns to match a unit regardless a tag.

Is used to propagate a tag during building dependencies.

An Id of the Unit to be built.

The part of an . It could be any object e.g. a , or a string constant. Whatever you find suitable to identify a Unit during tuning up the build process. See and its implementations for details.

The part of an . Two Units of the same but with different are different Units and could be built in different ways. It allows distinguishing e.g. two implementations of the same interface, etc.

Syntax sugar for increasing code readability. 'Unit.Of(' looks cleaner than 'new UnitId('

Checks if a unit matches with the specified kind and a tag.

Checks if a tag matches , returns true if they are equal or the is .