Configuring Object Dependencies

After you've created object dependencies for classification, you can customize them so that they work exactly the way you wanted, by:

• Creating reference characteristics
• Defining a processing sequence
• Linking variant tables
• Defining variant functions

Before we dive into these tasks, here's a quick refresher of information to keep in mind.

The following image shows the types of object dependencies that you can create.

Object dependencies work:

• During classification, for characteristics (values) and classes
• Not during selection
• In Variant Configuration, for characteristics (values)

In Variant Configuration, another type of object dependency is available: Constraints.

Object dependencies can be global or local:

• Global object dependencies are created and maintained centrally using a separate function in the Variant Configuration menu. They're created using a name and can be used multiple times.
• Local object dependencies are created specifically for a class, characteristic, or characteristic value. They receive a number internally and can't be used more than once.

To properly set up multiple object dependencies in a classification system, you need to be aware of the sequence in which SAP will process them. The following video introduces this sequence.

Because sequences of dependencies that include multiple procedures involve steps-within-steps, they can become complex. The following example may help to clarify these sequences.

In the image before this, the sequence begins with the deletion of any previous valuations by procedures, Next, we create four new procedures.

• $self.COLOR = 'red' is assigned to the class "gearboxes"
• $self.COLOR = 'blue'is assigned to the characteristic "Number of Gears."
• $self.COLOR = 'green' is assigned to the characteristic value "5" for the "Number of Gears" characteristic.
• $self.COLOR = 'yellow' is also assigned to the characteristic value "5" for the "Number of Gears" characteristic.

Now, we have four procedures, each of which specifies a different value for COLOR. What do you think happens to that characteristic when we classify a new object? Here's the sequence:

1. The value of the "COLOR" characteristic is set to "red" initially, because the procedure =red assigned to the class is processed first.
2. Next, the sequence moves to the characteristic "Number of Gears."
   • If the number of gears is unassigned, then the sequence ends, and the value of "COLOR" remains "red."
   • If a value is assigned to the number of gears, then the =blue procedure is processed. As a result, the "red" characteristic value for "COLOR" is overwritten and changed to "blue."
3. Next, the sequence examines characteristic values for "Number of Gears."
   • If the number of gears is anything other than 5, the remaining two processes remain idle, and "COLOR" remains "blue."
   • If the number of gears is 5, then the =green procedure is executed, changing "COLOR" from "blue" to "green."
4. Finally, the = yellow procedure is executed. Because the "Number of Gears" is still 5, that process changes "COLOR" from "green" to "yellow." Both the = green and = yellow procedures are executed. But because the= yellow procedure is processed last, it "gets the last word" and "wins."

The following demonstration will show the preceding sequence as it appears in SAP.

In Variant Configuration and in classification, you can build your own programs to augment the functions of standard object dependencies. Written in the SAP programming language Advanced Business Application Programming Version 4 (ABAP/4), these programs result in dependencies that can't be mapped well with the standard object dependencies.

The following video illustrates the idea.

Variant functions allow you to enhance an object dependency with specialized logic for calculations or consistency checks. In a variant function, you reference an ABAP function module and pass import and export parameters to it. Within the function module, you can then access and process all relevant data further.

The syntax looks like this:

Key word:

FUNCTION

Declaration of function name:

Z_LABEL_ID

Declaration of characteristics:

1234
(Chassis  = $SELF.CHASSIS,
ENGINE	  = $SELF.ENGINE,
COLOR 	  = $SELF.COLOR,
LABEL_ID  = $ROOT.LABEL_ID) 

When you call a user-defined function module, the system no longer controls any potential error situations. The programmer who writes the function module can use all ABAP language elements but bears full responsibility for the code.

The process for defining a variant function for object dependencies is:

1. Define the ABAP/4 Program - Here define Parameters for Import, Export, Changing, Tables and Exceptions.: Here define Parameters for Import, Export, Changing, Tables and Exceptions required for the function. The following screenshot shows the Function Builder interface that you'll use to do this. Other function modules are similar; only the attributes and the source code are different.

   • Tab: Import

     Parameter Name = GLOBALS

     Associated Type = CUOV_00

   • Tab: Export

     empty

   • Tab: Changing

     empty

   • Tab: Tables

     Parameter Name = QUERY

     Associated Type = CUOV_01

     Parameter Name = MATCH

     Associated Type = CUOV_01

   • Tab: Exceptions

     Exception = FAIL

     Exception = INTERNAL_ERROR

2. Define the ABAP/4 Program: - Source code Write the ABAP/4 program that includes the logic needed for your function.
3. Create the Variant Function to Call the ABAP/4 Program: Here define Input and Output Characteristics Develop the variant function that will call and execute the ABAP/4 program. Specify the input and output characteristics required for the function.
4. Include the Variant Function in an Object Dependency: Integrate the variant function into an object dependency, such as a procedure, using the keyword FUNCTION. Assign these object dependencies to the class, characteristic or characteristic value as needed.

   The syntax looks like this:

   Code Snippet

   Copy codeSwitch to dark mode

   123
   function z_t991 (characteristic1_f  = charl1_o,
     	                      characteristic2_f  = char2_o,
   	                      characteristic3_f  = $self.char3_o)

The demonstration that follows shows two examples of variant functions.