### IASortedSet

  A sorted set is an ordered collection of zero or more elements with element equality but no key. Only unique elements are supported. A request to add an element that already exists is ignored. The value of the elements is relevant.

  The elements of a sorted set are ordered such that the value of each element is less than or equal to the value of its successor.

  The element with the smallest value currently in a sorted set is called the first element. The element with the largest value is called the last element. When an element is added, it is placed in the sorted set according to the defined ordering relation.

### IASortedSet - Member Functions and Data by Group

### Constructors & Destructor

Use these members to construct or destruct objects of the class.

~IASortedSet

      public:
      ~IASortedSet()

  Removes all elements from the collection. Destructors are called for all elements contained in the collection and for elements that have been constructed in advance.

  Side Effects

  All cursors of the collection become undefined.

Supported Platforms

  Windows | OS/2 | AIX
  Yes | Yes | Yes

IASortedSet

  Overload 1

      public:
      IASortedSet(INotifier&)

  Use this constructor to create a collection with support for notification.

Supported Platforms

  Windows | OS/2 | AIX
  Yes | Yes | Yes

  Overload 2

      protected:
      IASortedSet(IASortedSet < Element > const&)

  Constructs a collection. The collection is unbounded and is initially empty.
  Note: The collection constructor does not define whether any elements are constructed when the collection is constructed. For some classes, the element's default constructor may be invoked when the collection's constructor is invoked. This happens if a tabular or a diluted sequence implementation variant is used for a collection. The element's default constructor is used to allocate the required storage and initialize the elements. Therefore, a default constructor must be available for elements in such cases.

  Exception

  IOutOfMemory

Supported Platforms

  Windows | OS/2 | AIX
  Yes | Yes | Yes

  Overload 3

      protected:
      IASortedSet()

  This is the default constructor.

Supported Platforms

  Windows | OS/2 | AIX
  Yes | Yes | Yes

### Comparison

Use these members as comparison operators.

compare

      public:
      long
        compare( IASortedSet < Element > const&,
                 long ( * comparisonFunction ) ( Element const & ,
                 Element const & ) ) const

  Compares the collection with the given collection. Comparison yields <0 if the collection is less than the given collection, 0 if the collection is equal to the given collection, and >0 if the collection is greater than the given collection. Comparison is defined by the first pair of corresponding elements, in both collections, that are not equal. If such a pair exists, the collection with the greater element is the greater one. Otherwise, the collection with more elements is the greater one.
  Note:

  1. The given comparison function must return a result according to the following rules:
     >0
       if (element1 > element2)
     0
       if (element1 == element2)
     <0
       if (element1 < element2)
  2. For elements of type char*, compare() is not locale-sensitive by default. Because it uses strcmp() and not strcoll(), it compares the binary values representing the characters, and is not based on the LC_COLLATE category of the current locale. Its results are reliable only for code pages and character sets in which the collating sequence matches the sequence of binary representations. If you need a comparison based on the LC_COLLATE cateogory, then you must implement your own compare() function as described in :Using Separate Functions in the Class Library User's Guide.

  Return Value

  Returns the result of the collection comparison.

Supported Platforms

  Windows | OS/2 | AIX
  Yes | Yes | Yes

### Miscellaneous

Use these members to perform miscellaneous tasks.

addDifference

      public:
      virtual void
        addDifference( IASortedSet < Element > const&,
                       IASortedSet < Element > const& )

  Creates the difference between the two given collections, and adds this difference to the collection. The contents of the added elements, not the pointers to those elements, are copied.

  For a definition of the difference between two collections, see differenceWith.

  Preconditions

  Because the elements are added one by one, the following preconditions are tested for each individual addition.

  - If the collection is bounded and unique, the element or key must exist or (numberOfElements() < maxNumberOfElements()).
  - If the collection is bounded and nonunique, (numberOfElements() < maxNumberOfElements()).
  - If the collection is a map or a sorted map and contains an element with the same key as the given element, this element must be equal to the given element.

  Side Effects

  If any elements were added, all cursors of this collection become undefined.

  Exceptions

  - IOutOfMemory
  - IFullException, if the collection is bounded
  - IKeyAlreadyExistsException, if the collection is a map or a sorted map

Supported Platforms

  Windows | OS/2 | AIX
  Yes | Yes | Yes

addIntersection

      public:
      virtual void
        addIntersection( IASortedSet < Element > const&,
                         IASortedSet < Element > const& )

  Creates the intersection of the two given collections, and adds this intersection to the collection. The contents of the added elements, not the pointers to those elements, are copied.

  For a definition of the intersection of two collections, see intersectionWith.

  Preconditions

  Because the elements are added one by one, the following preconditions are tested for each individual addition.

  - If the collection is bounded and unique, the element or key must exist or (numberOfElements() < maxNumberOfElements()).
  - If the collection is bounded and nonunique, (numberOfElements() < maxNumberOfElements()).
  - If the collection is a map or a sorted map and contains an element with the same key as the given element, this element must be equal to the given element.

  Side Effects

  If any elements were added, all cursors of this collection become undefined.

  Exceptions

  - IOutOfMemory
  - IFullException, if the collection is bounded
  - IKeyAlreadyExistsException, if the collection is a map or a sorted map

Supported Platforms

  Windows | OS/2 | AIX
  Yes | Yes | Yes

addUnion

      public:
      virtual void
        addUnion( IASortedSet < Element > const&,
                  IASortedSet < Element > const& )

  Creates the union of the two given collections, and adds this union to the collection. The contents of the added elements, not the pointers to those elements, are copied.

  For a definition of the union of two collections, see unionWith.

  Preconditions

  Because the elements are added one by one, the following preconditions are tested for each individual addition.

  - If the collection is bounded and unique, the element or key must exist or (numberOfElements() < maxNumberOfElements()).
  - If the collection is bounded and nonunique, (numberOfElements() < maxNumberOfElements()).
  - If the collection is a map or a sorted map and contains an element with the same key as the given element, this element must be equal to the given element.

  Side Effects

  If any elements were added, all cursors of this collection become undefined.

  Exceptions

  - IOutOfMemory
  - IFullException, if the collection is bounded
  - IKeyAlreadyExistsException, if the collection is a map or a sorted map

Supported Platforms

  Windows | OS/2 | AIX
  Yes | Yes | Yes

differenceWith

      public:
      virtual void differenceWith(IASortedSet < Element > const&)

  Makes the collection the difference between the collection and the given collection. The difference of A and B (A minus B) is the set of elements that are contained in A but not in B.

  The following rule applies for bags with duplicate elements: If bag P contains the element X m times and bag Q contains the element X n times, the difference of P and Q contains the element X m-n times if m> n, and zero times if m<=n.

  Side Effects

  If any elements were removed, all cursors of this collection become undefined.

Supported Platforms

  Windows | OS/2 | AIX
  Yes | Yes | Yes

intersectionWith

      public:
      virtual void
        intersectionWith( IASortedSet < Element > const& )

  Makes the collection the intersection of the collection and the given collection. The intersection of A and B is the set of elements that is contained in both A and B.

  The following rule applies for bags with duplicate elements: If bag P contains the element X m times and bag Q contains the element X n times, the intersection of P and Q contains the element X MIN(m,n)times.

  Side Effects

  If any elements were removed, all cursors of this collection become undefined.

Supported Platforms

  Windows | OS/2 | AIX
  Yes | Yes | Yes

operator !=

      public:
      IBoolean operator !=(IASortedSet < Element > const&) const

  Returns true if the cursor does not point to the same element (of the same collection) as the given cursor.

Supported Platforms

  Windows | OS/2 | AIX
  Yes | Yes | Yes

operator ==

      public:
      IBoolean operator ==(IASortedSet < Element > const&) const

  Returns true if the cursor points to the same element (of the same collection) as the given cursor.

Supported Platforms

  Windows | OS/2 | AIX
  Yes | Yes | Yes

unionWith

      public:
      virtual void unionWith(IASortedSet < Element > const&)

  Makes the collection the union of the collection and the given collection. The union of A and B is the set of elements that are members of A or B or both.

  The following rule applies for bags with duplicate elements: If bag P contains the element X m times and bag Q contains the element X n times, the union of P and Q contains the element X m+n times.

  Preconditions

  Because the elements from the given collection are added to the collection one by one, the following preconditions are tested for each individual add operation :

  - If the collection is bounded and unique, the element or key must exist or (numberOfElements() < maxNumberOfElements()).
  - If the collection is bounded and nonunique, (numberOfElements() < maxNumberOfElements()).
  - If the collection is a map or a sorted map and contains an element with the same key as the given element, this element must be equal to the given element.

  Side Effects

  If any elements were added to the collection, all cursors of this collection become undefined.

  Exceptions

  - IOutOfMemory
  - IFullException, if the collection is bounded
  - IKeyAlreadyExistsException, if the collection is a map or a sorted map

Supported Platforms

  Windows | OS/2 | AIX
  Yes | Yes | Yes

numberOfOccurrences

      protected:
      INumber numberOfOccurrences(Element const&) const

  Returns the number of occurrences of the given element in the collection.

Supported Platforms

  Windows | OS/2 | AIX
  Yes | Yes | Yes

removeAllOccurrences

      protected:
      INumber removeAllOccurrences(Element const&)

  Removes all elements from the collection that are equal to the given element, and returns the number of elements removed. Element destructors are called as described in removeAt.

  Side Effects

  If any elements were removed, all cursors of this collection become undefined.

Supported Platforms

  Windows | OS/2 | AIX
  Yes | Yes | Yes

### IASortedSet - Inherited Member Functions and Data

#### Inherited Public Functions

  IACollection

  -     virtual ~IACollection()

  -     virtual bool add(Element const&)

  -     virtual bool add(Element const&, ICursor&)

  -     virtual void addAllFrom(IACollection < Element > const&)

  -     void adoptStreamer(IACollectionStreamer*)

  -     bool allElementsDo(IConstantApplicator < Element >&) const

  -     bool
          allElementsDo( bool ( * applicatorFunction ) ( Element&,
                         void * ) , void* additionalArgument = 0 )

  -     bool allElementsDo(IApplicator < Element >&)

  -     bool
          allElementsDo( bool ( * applicatorFunction ) ( Element const&,
                         void * ) , void* additionalArgument = 0 ) const

  -     Element const& any() const

  -     Element const& anyElement() const

  -     virtual void copy(IACollection < Element > const&)

  -     INotifier& disableNotification()

  -     Element& elementAt(ICursor const&)

  -     Element const& elementAt(ICursor const&) const

  -     INotifier& enableNotification(bool = true)

  -     IACollection(INotifier&)

  -     bool isBounded() const

  -     bool isConsistent() const

  -     bool isEmpty() const

  -     bool isEnabledForNotification() const

  -     bool isFull() const

  -     INumber maxNumberOfElements() const

  -     virtual ICursor* newCursor() const

  -     ICursor* newMngCursor() const

  -     INotifier& notifier()

  -     INotifier const& notifier() const

  -     INotifier& notifyObservers(INotificationEvent const&)

  -     INumber numberOfElements() const

  -     virtual void operator <<=(IDataStream&)

  -     virtual void operator >>=(IDataStream&)

  -     operator INotifier &() const

  -     virtual INumber
          removeAll( bool ( * predicateFunction ) ( Element const&,
                     void * ) , void* additionalArgument = 0 )

  -     virtual INumber removeAll()

  -     virtual void removeAt(ICursor&)

  -     virtual void replaceAt(ICursor const&, Element const&)

  -     bool setToFirst(ICursor&) const

  -     bool setToNext(ICursor&) const

  IAOrderedCollection

  -     ~IAOrderedCollection()

  -     Element const& elementAtPosition(IPosition) const

  -     Element const& first() const

  -     Element const& firstElement() const

  -     IAOrderedCollection(INotifier&)

  -     bool isFirst(ICursor const&) const

  -     bool isFirstAt(ICursor const&) const

  -     bool isLast(ICursor const&) const

  -     bool isLastAt(ICursor const&) const

  -     Element const& last() const

  -     Element const& lastElement() const

  -     IPosition position(ICursor const&) const

  -     IPosition positionAt(ICursor const&) const

  -     virtual void removeAtPosition(IPosition)

  -     virtual void removeFirst()

  -     virtual void removeLast()

  -     bool setToLast(ICursor&) const

  -     void setToPosition(IPosition, ICursor&) const

  -     bool setToPrevious(ICursor&) const

  IASortedCollection

  -     ~IASortedCollection()

  -     IASortedCollection(INotifier&)

#### Inherited Public Data

  - None

#### Inherited Protected Functions

  IACollectionBase

  -     ~IACollectionBase()

  -     static ICursorImpl const& CrsrImplOf(ICursor const& cursor)

  -     static ICursorImpl& CrsrImplOf(ICursor& cursor)

  -     IACollectionBase()

  -     IACollectionBase(IACollectionBase const&)

  -     static ICursor* InterfaceFor(ICursorImpl* cursor)

  IACollection

  -     IACollection()

  -     IACollection(IACollection < Element > const&)

  -     static Implementation&
          ImplOf( IACollection < Element > const& )

  IAOrderedCollection

  -     IAOrderedCollection(IAOrderedCollection < Element > const&)

  -     IAOrderedCollection()

  IASortedCollection

  -     IASortedCollection(IASortedCollection < Element > const&)

  -     IASortedCollection()

#### Inherited Protected Data

  - None