cs_list.h

c-smile 一个语法类似与JS 又有点像C++的 编译器

  }


  /****************************************************************************/
  template <class element>
  inline bool
    const_iterator<element>::at_end () const
  {
    return ( my_current && !my_current->_next );
  }


  /****************************************************************************/
  template <class element>
  inline int
    const_iterator<element>::size () const
  {
    return my_list->size ();
  }


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


  /****************************************************************************/
  template <class element>
  inline const list<element> &
    const_iterator<element>::the_list () const
  {
    assert ( my_list );
    //error - not_initialized;

    return *my_list;
  }


  /****************************************************************************/
  template <class element>
  inline
    iterator<element>::iterator ()
  {
    my_list = NULL;
    my_current = NULL;
  }


  /****************************************************************************/
  template <class element>
  inline
    iterator<element>::iterator ( list<element> &the_list )
  {
    my_list = &the_list;
    the_list.my_iterator_count++;
    my_current = the_list.my_head;
  }


  /****************************************************************************/
  template <class element>
  inline
    iterator<element>::iterator ( const iterator<element> &the_iterator )
  : my_list ( the_iterator.my_list )
  {
    if ( my_list )
      my_list->my_iterator_count++;
    my_current = the_iterator.my_current;
  }


  /****************************************************************************/
  template <class element>
  inline
    iterator<element>::~iterator ()
  {
    if ( my_list )
      my_list->my_iterator_count--;
  }


  /****************************************************************************/
  template <class element>
  inline iterator<element> &
    iterator<element>::iterate_over ( list<element> &the_list )
  {
    if ( my_list )
      my_list->my_iterator_count--;
    my_list = &the_list;
    my_list->my_iterator_count++;
    my_current = my_list->my_head;

    return *this;
  }


  /****************************************************************************/
  template <class element>
  inline iterator<element> &
    iterator<element>::iterate_over ()
  {
    if ( my_list )
    {
      my_list->my_iterator_count--;
      my_list = NULL;
      my_current = NULL;
    }

    return *this;
  }


  /****************************************************************************/
  template <class element>
  inline iterator<element> &
    iterator<element>::operator= ( const iterator<element> &the_iterator )
  {
    if ( my_list )
      my_list->my_iterator_count--;
    my_list = the_iterator.my_list;
    if ( my_list )
      my_list->my_iterator_count++;
    my_current = the_iterator.my_current;

    return *this;
  }


  /****************************************************************************/
  template <class element>
  iterator<element> &
    iterator<element>::insert_before_current ( const element &the_element )
  {
    assert ( my_current );

    list<element>::node *newnode = new list<element>::node;
    check_mem ( newnode );
    newnode->_element = the_element;

    if ( my_current->_previous )
    {

      if (my_current == &my_deleted)
      {
        newnode->_previous = my_current->_previous;
        newnode->_next = my_current->_next;
        my_current->_previous->_next = newnode;
        if ( my_current->_next )
          my_current->_next->_previous = newnode;
        else
          my_list->my_tail = newnode;
        my_current->_previous = newnode;
      }
      else
      {
        newnode->_previous = my_current->_previous;
        newnode->_next = my_current;
        my_current->_previous->_next = newnode;
        my_current->_previous = newnode;
      }
    }
    else
    {
      my_list->my_head->_previous = newnode;
      my_current->_previous = newnode; // in case my_current == my_deleted
      newnode->_next = my_list->my_head;
      newnode->_previous = NULL;
      my_list->my_head = newnode;
    }

    my_list->my_size++;
    return *this;
  }


  /****************************************************************************/
  template <class element>
  iterator<element> &
    iterator<element>::insert_after_current ( const element &the_element )
  {
    assert ( my_current );

    list<element>::node *newnode = new list<element>::node;
    check_mem ( newnode );
    newnode->_element = the_element;

    if ( my_current->_next )
    {
      if ( my_current == &my_deleted )
      {
        newnode->_next = my_current->_next;
        newnode->_previous = my_current->_previous;
        my_current->_next->_previous = newnode;
        if ( my_current->_previous )
          my_current->_previous->_next = newnode;
        else
          my_list->my_head = newnode;
        my_current->_next = newnode;
      }
      else
      {
        newnode->_next = my_current->_next;
        newnode->_previous = my_current;
        my_current->_next->_previous = newnode;
        my_current->_next = newnode;
      }
    }
    else
    {
      my_list->my_tail->_next = newnode;
      my_current->_next = newnode;  // in case my_current == my_deleted
      newnode->_previous = my_list->my_tail;
      newnode->_next = NULL;
      my_list->my_tail = newnode;
    }

    my_list->my_size++;
    return *this;
  }


  /****************************************************************************/
  template <class element>
  iterator<element> &
    iterator<element>::replace_current_with ( const element &the_element )
  {
    assert ( my_current );
    assert ( my_current != &my_deleted );
    my_current->_element = the_element;

    return *this;
  }


  /****************************************************************************/
  template <class element>
  inline element &
    iterator<element>::current ()
  {
    assert ( my_current );
    //current() - no current element
    return my_current->_element;
  }


  /****************************************************************************/
  template <class element>
  inline element *
    iterator<element>::ptr ()
  {
    if ( my_current )
      return &my_current->_element;
    else
      return NULL;
  }


  /****************************************************************************/
  template <class element>
  void
    iterator<element>::remove_current ()
  {
    assert ( my_current );
    //remove_current() - no current element

    assert ( my_current != &my_deleted );
    //remove_current() - current element has already been removed

    assert ( my_list->my_iterator_count == 1 );

    my_deleted._previous = my_current->_previous;
    my_deleted._next = my_current->_next;
    delete my_current;
    my_current = &my_deleted;

    if ( my_deleted._previous )
      my_deleted._previous->_next = my_deleted._next;
    else
      my_list->my_head = my_deleted._next;

    if ( my_deleted._next )
      my_deleted._next->_previous = my_deleted._previous;
    else
      my_list->my_tail = my_deleted._previous;

    my_list->my_size--;
  }


  /****************************************************************************/
  template <class element>
  inline iterator<element> &
    iterator<element>::beginning ()
  {
    if ( my_list )
      my_current = my_list->my_head;
    return *this;
  }


  /****************************************************************************/
  template <class element>
  inline iterator<element> &
    iterator<element>::end ()
  {
    if ( my_list )
      my_current = my_list->my_tail;
    return *this;
  }


  /****************************************************************************/
  template <class element>
  inline iterator<element> &
    iterator<element>::operator++ ()  // prefix
  {
    assert ( my_current );

    my_current = my_current->_next;
    return *this;
  }


  /****************************************************************************/
  template <class element>
  inline iterator<element> &
    iterator<element>::operator-- ()  // prefix
  {
    assert ( my_current );

    my_current = my_current->_previous;
    return *this;
  }


  /****************************************************************************/
  template <class element>
  inline void
    iterator<element>::operator++ ( int )  // postfix
  {
    assert ( my_current );
    //operator++() - no next element

    my_current = my_current->_next;
  }


  /****************************************************************************/
  template <class element>
  inline void
    iterator<element>::operator-- ( int )  // postfix
  {
    assert ( my_current );
    //operator--() - no next element

    my_current = my_current->_previous;
  }


  /****************************************************************************/
  template <class element>
  inline element &
    iterator<element>::operator* ()
  {
    assert ( my_current );
    return my_current->_element;
  }


  /****************************************************************************/
  template <class element>
  inline element *
    iterator<element>::operator-> ()
  {
    assert ( my_current );
    return &my_current->_element;
  }


  /****************************************************************************/
  template <class element>
  inline bool
    iterator<element>::at_beginning () const
  {
    return ( my_current && !my_current->_previous );
  }


  /****************************************************************************/
  template <class element>
  inline bool
    iterator<element>::at_end () const
  {
    return ( my_current && !my_current->_next );
  }


  /****************************************************************************/
  template <class element>
  inline int
    iterator<element>::size () const
  {
    return my_list->size ();
  }


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


  /****************************************************************************/
  template <class element>
  inline list<element> &
    iterator<element>::the_list ()
  {
    assert ( my_list );

    return *my_list;
  }
  /****************************************************************************/
};

#endif