// Copyright (c) 2005 DMTF.  All rights reserved.
// <change cr="ArchCR00066.004" type="add">Add UmlPackagePath
// qualifier values to CIM Schema.</change>
// ==================================================================
//  CIM_PolicyRule 
// ==================================================================
   [Version ( "2.7.0" ), 
    UMLPackagePath ( "CIM::Policy" ), 
    Description ( 
       "The central class used for representing the \'If Condition "
       "then Action\' semantics of a policy rule. A PolicyRule "
       "condition, in the most general sense, is represented as either "
       "an ORed set of ANDed conditions (Disjunctive Normal Form, or "
       "DNF) or an ANDed set of ORed conditions (Conjunctive Normal "
       "Form, or CNF). Individual conditions may either be negated "
       "(NOT C) or unnegated (C). The actions specified by a "
       "PolicyRule are to be performed if and only if the PolicyRule "
       "condition (whether it is represented in DNF or CNF) evaluates "
       "to TRUE. \n"
       "\n"
       "The conditions and actions associated with a PolicyRule are "
       "modeled, respectively, with subclasses of PolicyCondition and "
       "PolicyAction. These condition and action objects are tied to "
       "instances of PolicyRule by the PolicyConditionInPolicyRule and "
       "PolicyActionInPolicyRule aggregations. \n"
       "\n"
       "A PolicyRule may also be associated with one or more policy "
       "time periods, indicating the schedule according to which the "
       "policy rule is active and inactive. In this case it is the "
       "PolicySetValidityPeriod aggregation that provides this "
       "linkage. \n"
       "\n"
       "The PolicyRule class uses the property ConditionListType, to "
       "indicate whether the conditions for the rule are in DNF "
       "(disjunctive normal form), CNF (conjunctive normal form) or, "
       "in the case of a rule with no conditions, as an "
       "UnconditionalRule. The PolicyConditionInPolicyRule aggregation "
       "contains two additional properties to complete the "
       "representation of the Rule\'s conditional expression. The "
       "first of these properties is an integer to partition the "
       "referenced PolicyConditions into one or more groups, and the "
       "second is a Boolean to indicate whether a referenced Condition "
       "is negated. An example shows how ConditionListType and these "
       "two additional properties provide a unique representation of a "
       "set of PolicyConditions in either DNF or CNF. \n"
       "\n"
       "Suppose we have a PolicyRule that aggregates five "
       "PolicyConditions C1 through C5, with the following values in "
       "the properties of the five PolicyConditionInPolicyRule "
       "associations: \n"
       "C1: GroupNumber = 1, ConditionNegated = FALSE \n"
       "C2: GroupNumber = 1, ConditionNegated = TRUE \n"
       "C3: GroupNumber = 1, ConditionNegated = FALSE \n"
       "C4: GroupNumber = 2, ConditionNegated = FALSE \n"
       "C5: GroupNumber = 2, ConditionNegated = FALSE \n"
       "\n"
       "If ConditionListType = DNF, then the overall condition for the "
       "PolicyRule is: \n"
       "(C1 AND (NOT C2) AND C3) OR (C4 AND C5) \n"
       "\n"
       "On the other hand, if ConditionListType = CNF, then the "
       "overall condition for the PolicyRule is: \n"
       "(C1 OR (NOT C2) OR C3) AND (C4 OR C5) \n"
       "\n"
       "In both cases, there is an unambiguous specification of the "
       "overall condition that is tested to determine whether to "
       "perform the PolicyActions associated with the PolicyRule. \n"
       "\n"
       "PolicyRule instances may also be used to aggregate other "
       "PolicyRules and/or PolicyGroups. When used in this way to "
       "implement nested rules, the conditions of the aggregating rule "
       "apply to the subordinate rules as well. However, any side "
       "effects of condition evaluation or the execution of actions "
       "MUST NOT affect the result of the evaluation of other "
       "conditions evaluated by the rule engine in the same evaluation "
       "pass. That is, an implementation of a rule engine MAY evaluate "
       "all conditions in any order before applying the priority and "
       "determining which actions are to be executed." )]
class CIM_PolicyRule : CIM_PolicySet {

      [Key, Description ( "The scoping System\'s CreationClassName." ), 
       MaxLen ( 256 ), 
       Propagated ( "CIM_System.CreationClassName" )]
   string SystemCreationClassName;

      [Key, Description ( "The scoping System\'s Name." ), 
       MaxLen ( 256 ), 
       Propagated ( "CIM_System.Name" )]
   string SystemName;

      [Key, Description ( 
          "CreationClassName indicates the name of the class or the "
          "subclass used in the creation of an instance. When used "
          "with the other key properties of this class, this "
          "property allows all instances of this class and its "
          "subclasses to be uniquely identified." ), 
       MaxLen ( 256 )]
   string CreationClassName;

      [Key, Description ( "A user-friendly name of this PolicyRule." ), 
       MaxLen ( 256 )]
   string PolicyRuleName;

      [Description ( 
          "Indicates whether the list of PolicyConditions "
          "associated with this PolicyRule is in disjunctive normal "
          "form (DNF), conjunctive normal form (CNF), or has no "
          "conditions (i.e., is an UnconditionalRule) and is "
          "automatically evaluated to \"True.\" The default value "
          "is 1 (\"DNF\")." ), 
       ValueMap { "0", "1", "2" }, 
       Values { "Unconditional Rule", "DNF", "CNF" }]
   uint16 ConditionListType = 1;

      [Description ( 
          "A free-form string that can be used to provide "
          "guidelines on how this PolicyRule should be used." )]
   string RuleUsage;

      [Deprecated { "CIM_PolicySetComponent.Priority" }, 
       Description ( 
          "PolicyRule.Priority is deprecated and replaced by "
          "providing the priority for a rule (and a group) in the "
          "context of the aggregating PolicySet instead of the "
          "priority being used for all aggregating PolicySet "
          "instances. Thus, the assignment of priority values is "
          "much simpler. \n"
          "\n"
          "A non-negative integer for prioritizing this Policy Rule "
          "relative to other Rules. A larger value indicates a "
          "higher priority. The default value is 0." )]
   uint16 Priority = 0;

      [Deprecated { "No Value" }, 
       Description ( 
          "A flag indicating that the evaluation of the Policy "
          "Conditions and execution of PolicyActions (if the "
          "Conditions evaluate to TRUE) is required. The evaluation "
          "of a PolicyRule MUST be attempted if the Mandatory "
          "property value is TRUE. If the Mandatory property is "
          "FALSE, then the evaluation of the Rule is \'best effort\' "
          "and MAY be ignored." )]
   boolean Mandatory;

      [Description ( 
          "This property gives a policy administrator a way of "
          "specifying how the ordering of the PolicyActions "
          "associated with this PolicyRule is to be interpreted. "
          "Three values are supported: \n"
          "o mandatory(1): Do the actions in the indicated order, "
          "or don\'t do them at all. \n"
          "o recommended(2): Do the actions in the indicated order "
          "if you can, but if you can\'t do them in this order, do "
          "them in another order if you can. \n"
          "o dontCare(3): Do them -- I don\'t care about the order. \n"
          "The default value is 3 (\"DontCare\")." ), 
       ValueMap { "1", "2", "3" }, 
       Values { "Mandatory", "Recommended", "Dont Care" }]
   uint16 SequencedActions = 3;

      [Description ( 
          "ExecutionStrategy defines the strategy to be used in "
          "executing the sequenced actions aggregated by this "
          "PolicyRule. There are three execution strategies: \n"
          "\n"
          "Do Until Success - execute actions according to "
          "predefined order, until successful execution of a single "
          "action. \n"
          "Do All - execute ALL actions which are part of the "
          "modeled set, according to their predefined order. "
          "Continue doing this, even if one or more of the actions "
          "fails. \n"
          "Do Until Failure - execute actions according to "
          "predefined order, until the first failure in execution "
          "of an action instance." ), 
       ValueMap { "1", "2", "3" }, 
       Values { "Do Until Success", "Do All", "Do Until Failure" }]
   uint16 ExecutionStrategy;


};
