/*
 * STRUCT: SE_Requirement
 *
 *   Describes a relationship between two classes.  One class, the "from"
 *   class or "current" class, is taken from a context outside of this
 *   structure, while the "to" class is identified in this structure. The
 *   relationship from the "from" class to the "to" class is defined by this
 *   structure.
 *
 *   The relationship being described may be an association, aggregation,
 *   or component relationship.  Each class has a list of its association
 *   requirements, a list of its aggregation requirements, and a list of
 *   its component requirements. These lists are accessed via
 *   SE_AssociationsList(), SE_AggregatesList(), and SE_ComponentsList()
 *   (see). The SE_Requirement struct defined here is used as an
 *   entry in those lists.
 *
 *  Another way to describe lower_limit and upper_limit:
 *
 *     For fixed size arrays,
 *           multiplicity == SE_MLTPCTY_EXACTLY_N
 *           lower_limit  == upper_limit == (value of N)
 *
 *     For bounded arrays (at least N, at most M),
 *           multiplicity == SE_MLTPCTY_BOUNDED_ARRAY
 *           lower_limit  == (N, the lower bound value)
 *           upper_limit  == (M, the upper bound value)
 *
 *     For unbounded arrays (at least N, no upper bound),
 *           multiplicity == SE_MLTPCTY_UNBOUNDED_ARRAY
 *           lower_limit  == (N, lower bound value)
 *           upper_limit  == SE_MLTPCTY_NO_UPPER_BOUND (-1)
 */

Field Notes

drm_class

 The ID of the 'to' class, always meaningful.

multiplicity

 The multiplicity of the "to" side of the relationship,
 always meaningful.  It answers the question "How many
 of the 'to' class objects are required to be related
 to a 'from' class object?"

ordered

 When more than one object of the "to" class is allowed,
 this ordered flag indicates whether or not the ordering of
 those "to" objects is important.  This ordered flag is
 meaningful only when the multiplicity allows more than
 one "to" class object (i.e. - this ordered flag should be
 SE_FALSE, but should also be ignored and is not meaningful
 when the multiplicity is SE_MLTPCTY_EXACTLY_ONE or
 SE_MLTPCTY_ZERO_OR_ONE).

lower_limit

 The lower limit for the number of "to" class objects.
 Only meaningful for multiplicity values of SE_MLTPCTY_EXACTLY_N,
 SE_MLTPCTY_BOUNDED_ARRAY, and SE_MLTPCTY_UNBOUNDED_ARRAY. The
 meaning of lower_limit is:
           for SE_MLTPCTY_EXACTLY_N, the lower_limit equals N,
                             requiring exactly N "to" objects
           for SE_MLTPCTY_BOUNDED_ARRAY, the lower_limit is the minimum
                                 number of "to" objects required
           for SE_MLTPCTY_UNBOUNDED_ARRAY, the lower_limit is the minimum
                                  number of "to" objects required

upper_limit

 The upper limit for the number of "to" class objects.
 Only meaningful for multiplicity values of SE_MLTPCTY_EXACTLY_N,
 SE_MLTPCTY_BOUNDED_ARRAY, and SE_MLTPCTY_UNBOUNDED_ARRAY.  The meaning
 of upper_limit is:
     for SE_MLTPCTY_EXACTLY_N, the upper_limit equals N,
                       requiring exactly N "to" objects
                       (the value N is stored in both the
                        lower_limit and upper_limit for
                        multiplicity SE_MLTPCTY_EXACTLY_N)
     for SE_MLTPCTY_BOUNDED_ARRAY, the upper_limit is the maximum
                           number of "to" objects required
     for SE_MLTPCTY_UNBOUNDED_ARRAY, there is no upper limit for the
                             number of "to" objects required,
                             so upper_limit is set to the
                             sentinel value SE_MLTPCTY_NO_UPPER_BOUND

drm_link_class

 Set to the link class, if the relationship has one;
    otherwise, set to SE_DRM_CLS_NULL.

next_ptr

 A pointer to the next SE_Requirement struct in this
    singly-linked list of requirements; NULL if end-of-list.