TokenEnforcementStrategy

enum class MayaFlux::Buffers::TokenEnforcementStrategy

strong

Defines how strictly processing token requirements are enforced in buffer processing chains.

TokenEnforcementStrategy provides different levels of flexibility for handling processor-buffer compatibility based on processing tokens. This allows the system to balance performance optimization with operational flexibility depending on the application's requirements.

The enforcement strategy affects how BufferProcessingChain handles processors with incompatible tokens, ranging from strict validation to complete flexibility. This enables different operational modes for development, production, and specialized processing scenarios.

Enumerator
STRICT	Strictly enforces token assignment with no cross-token sharing. Processors must exactly match the buffer's processing token requirements. Any incompatibility results in immediate rejection. This provides maximum performance optimization by ensuring all processors in a chain can execute with the same backend configuration, but offers the least flexibility.
FILTERED	Filters processors through token enumeration, allowing compatible combinations. Uses the are_tokens_compatible() function to determine if processors can work together despite different token assignments. This allows some flexibility while maintaining performance optimization for compatible processor combinations. Incompatible processors are filtered out rather than rejected outright.
OVERRIDE_SKIP	Allows token overrides but skips processing for incompatible operations. Permits processors with different tokens to be added to processing chains, but skips their execution when the tokens are incompatible. This maintains chain integrity while allowing dynamic processor management. Useful for conditional processing scenarios where not all processors need to execute.
OVERRIDE_REJECT	Allows token overrides but rejects incompatible processors from chains. Similar to OVERRIDE_SKIP but removes incompatible processors from the chain entirely rather than skipping them. This provides a middle ground between flexibility and performance by cleaning up incompatible processors while allowing initial token mismatches during chain construction.
IGNORE	Ignores token assignments completely, allowing any processing combination. Disables all token validation and compatibility checking. Any processor can be added to any buffer's processing chain regardless of token compatibility. This provides maximum flexibility but may result in suboptimal performance or execution errors. Primarily useful for debugging or specialized scenarios.

Definition at line 19 of file BufferUtils.hpp.

                                    {
    /**
     * @brief Strictly enforces token assignment with no cross-token sharing
     *
     * Processors must exactly match the buffer's processing token requirements.
     * Any incompatibility results in immediate rejection. This provides maximum
     * performance optimization by ensuring all processors in a chain can execute
     * with the same backend configuration, but offers the least flexibility.
     */
    STRICT,
 
    /**
     * @brief Filters processors through token enumeration, allowing compatible combinations
     *
     * Uses the are_tokens_compatible() function to determine if processors can work
     * together despite different token assignments. This allows some flexibility while
     * maintaining performance optimization for compatible processor combinations.
     * Incompatible processors are filtered out rather than rejected outright.
     */
    FILTERED,
 
    /**
     * @brief Allows token overrides but skips processing for incompatible operations
     *
     * Permits processors with different tokens to be added to processing chains,
     * but skips their execution when the tokens are incompatible. This maintains
     * chain integrity while allowing dynamic processor management. Useful for
     * conditional processing scenarios where not all processors need to execute.
     */
    OVERRIDE_SKIP,
 
    /**
     * @brief Allows token overrides but rejects incompatible processors from chains
     *
     * Similar to OVERRIDE_SKIP but removes incompatible processors from the chain
     * entirely rather than skipping them. This provides a middle ground between
     * flexibility and performance by cleaning up incompatible processors while
     * allowing initial token mismatches during chain construction.
     */
    OVERRIDE_REJECT,
 
    /**
     * @brief Ignores token assignments completely, allowing any processing combination
     *
     * Disables all token validation and compatibility checking. Any processor can
     * be added to any buffer's processing chain regardless of token compatibility.
     * This provides maximum flexibility but may result in suboptimal performance
     * or execution errors. Primarily useful for debugging or specialized scenarios.
     */
    IGNORE
};