cs_bag.h

C-smile OOL is a scripting language with C++-like grammar. It has compiler, VM running bytecodes and

    return remove ( bag );
  }


  /****************************************************************************/
  template <class element>
  inline bag<element> &
    bag<element>::operator-= ( const element &element )
  {
    return remove ( element, 1 );
  }


  /****************************************************************************/
  template <class element>
  bag<element> &
    bag<element>::remove ( const bag &the_bag )
  {
    if ( this == &the_bag )
      my_list.clear();
    else
    {
      iterator<bag<element>::slot> a ( my_list );
      read_only_iterator<bag<element>::slot> b ( bag.my_list );

      foreach ( b )
      {
        while ( a.ptr() && a->my_element < b->my_element )
          a++;
        if ( !a.ptr() || b->my_element < a->my_element ||
              b->my_count > a->my_count )
        {
          cerr << "bag - error subtracting more than exists\n";
          assert ( 0 );
        }
        else if ( b->my_count < a->my_count )
          a->my_count -= b->my_count;
        else
          a.remove_current ();
        a++;
      }
    }
    return *this;
  }


  /****************************************************************************/
  template <class element>
  bag<element> &
    bag<element>::remove ( const element &element, int num )
  {
    iterator<bag<element>::slot> iter ( my_list );

    while ( iter.ptr() && iter->my_element < element )
      iter++;

    if ( !iter.ptr() || element < iter->my_element || num > iter->my_count)
    {
      cerr << "bag - error subtracting more than exists\n";
      assert ( 0 );
    }
    else if ( num < iter->my_count )
      iter->my_count -= num;
    else
      iter.remove_current();

    return *this;
  }


  /****************************************************************************/
  template <class element>
  bag<element> &
    bag<element>::remove_all ( const element &element )
  {
    iterator<bag<element>::slot> iter ( my_list );

    while ( iter.ptr() && iter->my_element < element )
      iter++;
    if ( iter.ptr() && iter->my_element == element )
      iter.remove_current();

    return *this;
  }


  /****************************************************************************/
  template <class element>
  bool
    bag<element>::operator== ( const bag<element> &the_bag ) const
  {
    if ( this == &the_bag )
      return true;

    if ( my_list.size() != bag.my_list.size() )
      return false;

    read_only_iterator<bag<element>::slot> a ( my_list ), b ( bag.my_list );
    while ( a.ptr() )
    {
      if ( !( a->my_count == b->my_count && a->my_element == b->my_element ) )
        return false;
      a++, b++;
    }
    return true;
  }


  /****************************************************************************/
  template <class element>
  inline bool
    bag<element>::operator!= ( const bag<element> &the_bag ) const
  {
    return !operator== ( bag );
  }


  /****************************************************************************/
  template <class element>
  bool
    bag<element>::operator< ( const bag<element> &the_bag ) const
  {
    if ( bag.my_list.size() < my_list.size() )
      return false;
    else if ( my_list.size() < bag.my_list.size() )
      return true;
    else
    {
      read_only_iterator<bag<element>::slot> a ( my_list ), b ( bag.my_list );
      while ( a.ptr() )
      {
        if ( b->my_count < a->my_count )
          return false;
        else if ( a->my_count < b->my_count )
          return true;
        else if ( b->my_element < a->my_element )
          return false;
        else if ( a->my_element < b->my_element )
          return true;
        a++, b++;
      }
    }
    return false;
  }


  /****************************************************************************/
  template <class element>
  inline bag<element> &
    bag<element>::operator= ( const bag<element> &the_bag )
  {
    my_list = bag.my_list;
    return *this;
  }


  /****************************************************************************/
  template <class element>
  inline bag<element> &
    bag<element>::operator= ( const element &element )
  {
    bag<element>::slot slot ( element, 1 );
    my_list += slot;
    return *this;
  }


  /****************************************************************************/
  template <class element>
  bag<element> &
    bag<element>::operator= ( const list<element> &the_list )
  {
    clear();
    read_only_iterator<element> iter ( the_list );
    foreach ( iter )
      add ( *iter );

    return *this;
  }


  /****************************************************************************/
  template <class element>
  list<element>
    bag<element>::the_list () const
  {
    list<element> _list;
    read_only_iterator<bag<element>::slot> iter ( my_list );

    foreach ( iter )
      for ( register int i = 0; i < iter->my_count; i++ )
        _list.add_to_tail ( iter->my_element );

    return _list;
  }


  /****************************************************************************/
  template <class element>
  list<element>
    bag<element>::the_unique_list () const
  {
    list<element> _list;
    read_only_iterator<bag<element>::slot> iter ( my_list );

    foreach ( iter )
      _list.add_to_tail ( iter->my_element );

    return _list;
  }


  /****************************************************************************/
  template <class element>
  int
    bag<element>::size () const
  {
    int total_count = 0;
    read_only_iterator<bag<element>::slot> iter ( my_list );

    foreach ( iter )
      total_count += iter->my_count;

    return total_count;
  }


  /****************************************************************************/
  template <class element>
  inline int
    bag<element>::unique_size() const
  {
    return my_list.size();
  }


  /****************************************************************************/
  template <class element>
  inline bool
    bag<element>::is_empty () const
  {
    return my_list.is_empty ();
  }


  /****************************************************************************/
  template <class element>
  bool
    bag<element>::contains ( const bag<element> &the_bag ) const
  {
    if ( this == &the_bag )
      return true;

    read_only_iterator<bag<element>::slot> a ( my_list ), b ( bag.my_list );

    while ( b.ptr() )
    {
      while ( a.ptr() && a->my_element < b->my_element )
        a++;
      if ( !( a.ptr() && a->my_element == b->my_element &&
            a->my_count >= b->my_count ) )
        return false;
      a++;
      b++;
    }
    return true;
  }


  /****************************************************************************/
  template <class element>
  bool
    bag<element>::contains ( const element &element, int num ) const
  {
    read_only_iterator<bag<element>::slot> iter ( my_list );

    while ( iter.ptr() && iter->my_element < element )
      iter++;

    return ( iter.ptr() && iter->my_element == element &&
             iter->my_count >= num );
  }


  /****************************************************************************/
  template <class element>
  int
    bag<element>::occurrences_of ( const element &element ) const
  {
    read_only_iterator<bag<element>::slot> iter ( my_list );

    while ( iter.ptr() && iter->my_element < element )
      iter++;
    if ( iter.ptr() && iter->my_element == element )
      return iter->my_count;
    else
      return 0;
  }


  /****************************************************************************/
  template <class element>
  element
    bag<element>::retrieve ()
  {
    if ( my_list.is_empty() )
    {
      cerr << "bag: retreive() - bag empty\n";
      assert ( 0 );
    }

    element element = my_list.head ().my_element;

    if ( --my_list.head().my_count == 0 )
      my_list.remove_head ();

    return element;
  }


  /****************************************************************************/
  template <class element>
  inline bag<element> &
    bag<element>::clear ()
  {
    my_list.clear ();

    return *this;
  }


/****************************************************************************/
};

#endif /* bag_defined */