(file) Return to List.cpp CVS log (file) (dir) Up to [Pegasus] / pegasus / src / Pegasus / Common

Diff for /pegasus/src/Pegasus/Common/List.cpp between version 1.1.2.1 and 1.1.2.6

version 1.1.2.1, 2006/06/29 17:31:36 version 1.1.2.6, 2006/06/30 20:07:50
Line 1 
Line 1 
 #include <cassert>  //%2006////////////////////////////////////////////////////////////////////////
   //
   // Copyright (c) 2000, 2001, 2002 BMC Software; Hewlett-Packard Development
   // Company, L.P.; IBM Corp.; The Open Group; Tivoli Systems.
   // Copyright (c) 2003 BMC Software; Hewlett-Packard Development Company, L.P.;
   // IBM Corp.; EMC Corporation, The Open Group.
   // Copyright (c) 2004 BMC Software; Hewlett-Packard Development Company, L.P.;
   // IBM Corp.; EMC Corporation; VERITAS Software Corporation; The Open Group.
   // Copyright (c) 2005 Hewlett-Packard Development Company, L.P.; IBM Corp.;
   // EMC Corporation; VERITAS Software Corporation; The Open Group.
   // Copyright (c) 2006 Hewlett-Packard Development Company, L.P.; IBM Corp.;
   // EMC Corporation; Symantec Corporation; The Open Group.
   //
   // Permission is hereby granted, free of charge, to any person obtaining a copy
   // of this software and associated documentation files (the "Software"), to
   // deal in the Software without restriction, including without limitation the
   // rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
   // sell copies of the Software, and to permit persons to whom the Software is
   // furnished to do so, subject to the following conditions:
   //
   // THE ABOVE COPYRIGHT NOTICE AND THIS PERMISSION NOTICE SHALL BE INCLUDED IN
   // ALL COPIES OR SUBSTANTIAL PORTIONS OF THE SOFTWARE. THE SOFTWARE IS PROVIDED
   // "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT
   // LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
   // PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
   // HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
   // ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
   // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
   //
   //==============================================================================
   //
   // Author: Mike Brasher (m.brasher@inovadevelopment.com)
   //
   //%/////////////////////////////////////////////////////////////////////////////
   
 #include "List.h" #include "List.h"
   #include "PegasusAssert.h"
  
 #ifdef PEGASUS_LINKABLE_SANITY #ifdef PEGASUS_LINKABLE_SANITY
 # define LIST_ASSERT(COND) assert(COND)  # define PEGASUS_LIST_ASSERT(COND) PEGASUS_ASSERT(COND)
 #else #else
 # define LIST_ASSERT(COND) /* empty */  # define PEGASUS_LIST_ASSERT(COND) /* empty */
 #endif #endif
  
 #define PEGASUS_LIST_MAGIC 0x1234ABCD  #define PEGASUS_LIST_MAGIC 0x6456FD0A
  
 PEGASUS_NAMESPACE_BEGIN PEGASUS_NAMESPACE_BEGIN
  
Line 22 
Line 57 
  
 ListRep::~ListRep() ListRep::~ListRep()
 { {
     LIST_ASSERT(_magic == PEGASUS_LIST_MAGIC);      PEGASUS_LIST_ASSERT(_magic == PEGASUS_LIST_MAGIC);
  
     clear();     clear();
 #ifdef PEGASUS_LINKABLE_SANITY #ifdef PEGASUS_LINKABLE_SANITY
Line 32 
Line 67 
  
 void ListRep::clear() void ListRep::clear()
 { {
     LIST_ASSERT(_magic == PEGASUS_LIST_MAGIC);      PEGASUS_LIST_ASSERT(_magic == PEGASUS_LIST_MAGIC);
  
     if (_destructor)     if (_destructor)
     {     {
         for (Linkable* p = _front; p; )          // Reset _front, _back, and _size in case the destructor calls
           // a method of List.
   
           Linkable* front = _front;
           Linkable* back = _back;
           size_t size= _size;
   
           _front = 0;
           _back = 0;
           _size = 0;
   
           for (Linkable* p = front; p; )
         {         {
             LIST_ASSERT(p->magic == PEGASUS_LINKABLE_MAGIC);              PEGASUS_LIST_ASSERT(p->magic == PEGASUS_LINKABLE_MAGIC);
             Linkable* next = p->next;             Linkable* next = p->next;
               p->list = 0;
             _destructor(p);             _destructor(p);
             p = next;             p = next;
         }         }
   
         _front = 0;  
         _back = 0;  
         _size = 0;  
     }     }
 } }
  
 void ListRep::insert_front(Linkable* elem) void ListRep::insert_front(Linkable* elem)
 { {
     LIST_ASSERT(_magic == PEGASUS_LIST_MAGIC);      PEGASUS_LIST_ASSERT(_magic == PEGASUS_LIST_MAGIC);
     LIST_ASSERT(elem != 0);      PEGASUS_LIST_ASSERT(elem != 0);
     LIST_ASSERT(elem->magic == PEGASUS_LINKABLE_MAGIC);      PEGASUS_LIST_ASSERT(elem->magic == PEGASUS_LINKABLE_MAGIC);
     LIST_ASSERT(elem->list == 0);      PEGASUS_LIST_ASSERT(elem->list == 0);
  
     elem->list = this;     elem->list = this;
     elem->next = _front;     elem->next = _front;
Line 72 
Line 115 
  
 void ListRep::insert_back(Linkable* elem) void ListRep::insert_back(Linkable* elem)
 { {
     LIST_ASSERT(_magic == PEGASUS_LIST_MAGIC);      PEGASUS_LIST_ASSERT(_magic == PEGASUS_LIST_MAGIC);
     LIST_ASSERT(elem != 0);      PEGASUS_LIST_ASSERT(elem != 0);
     LIST_ASSERT(elem->magic == PEGASUS_LINKABLE_MAGIC);      PEGASUS_LIST_ASSERT(elem->magic == PEGASUS_LINKABLE_MAGIC);
     LIST_ASSERT(elem->list == 0);      PEGASUS_LIST_ASSERT(elem->list == 0);
  
     elem->list = this;     elem->list = this;
     elem->prev = _back;     elem->prev = _back;
Line 94 
Line 137 
     Linkable* pos,     Linkable* pos,
     Linkable* elem)     Linkable* elem)
 { {
     LIST_ASSERT(_magic == PEGASUS_LIST_MAGIC);      PEGASUS_LIST_ASSERT(_magic == PEGASUS_LIST_MAGIC);
     LIST_ASSERT(pos != 0);      PEGASUS_LIST_ASSERT(pos != 0);
     LIST_ASSERT(elem != 0);      PEGASUS_LIST_ASSERT(elem != 0);
     LIST_ASSERT(elem->magic == PEGASUS_LINKABLE_MAGIC);      PEGASUS_LIST_ASSERT(elem->magic == PEGASUS_LINKABLE_MAGIC);
     LIST_ASSERT(pos->magic == PEGASUS_LINKABLE_MAGIC);      PEGASUS_LIST_ASSERT(pos->magic == PEGASUS_LINKABLE_MAGIC);
     LIST_ASSERT(elem->list == 0);      PEGASUS_LIST_ASSERT(elem->list == 0);
  
     elem->list = this;     elem->list = this;
     elem->prev = pos;     elem->prev = pos;
Line 120 
Line 163 
     Linkable* pos,     Linkable* pos,
     Linkable* elem)     Linkable* elem)
 { {
     LIST_ASSERT(_magic == PEGASUS_LIST_MAGIC);      PEGASUS_LIST_ASSERT(_magic == PEGASUS_LIST_MAGIC);
     LIST_ASSERT(pos != 0);      PEGASUS_LIST_ASSERT(pos != 0);
     LIST_ASSERT(elem != 0);      PEGASUS_LIST_ASSERT(elem != 0);
     LIST_ASSERT(pos->magic == PEGASUS_LINKABLE_MAGIC);      PEGASUS_LIST_ASSERT(pos->magic == PEGASUS_LINKABLE_MAGIC);
     LIST_ASSERT(elem->magic == PEGASUS_LINKABLE_MAGIC);      PEGASUS_LIST_ASSERT(elem->magic == PEGASUS_LINKABLE_MAGIC);
     LIST_ASSERT(elem->list == 0);      PEGASUS_LIST_ASSERT(elem->list == 0);
  
     elem->list = this;     elem->list = this;
     elem->next = pos;     elem->next = pos;
Line 144 
Line 187 
  
 void ListRep::remove(Linkable* pos) void ListRep::remove(Linkable* pos)
 { {
     LIST_ASSERT(_magic == PEGASUS_LIST_MAGIC);      PEGASUS_LIST_ASSERT(_magic == PEGASUS_LIST_MAGIC);
     LIST_ASSERT(pos != 0);      PEGASUS_LIST_ASSERT(pos != 0);
     LIST_ASSERT(pos->magic == PEGASUS_LINKABLE_MAGIC);      PEGASUS_LIST_ASSERT(pos->magic == PEGASUS_LINKABLE_MAGIC);
     LIST_ASSERT(pos->list == this);      PEGASUS_LIST_ASSERT(pos->list == this);
     LIST_ASSERT(_size != 0);      PEGASUS_LIST_ASSERT(_size != 0);
  
     if (_size == 0)     if (_size == 0)
         return;         return;
Line 172 
Line 215 
  
 bool ListRep::contains(const Linkable* elem) bool ListRep::contains(const Linkable* elem)
 { {
     LIST_ASSERT(_magic == PEGASUS_LIST_MAGIC);      PEGASUS_LIST_ASSERT(_magic == PEGASUS_LIST_MAGIC);
     LIST_ASSERT(elem != 0);      PEGASUS_LIST_ASSERT(elem != 0);
     LIST_ASSERT(elem->magic == PEGASUS_LINKABLE_MAGIC);      PEGASUS_LIST_ASSERT(elem->magic == PEGASUS_LINKABLE_MAGIC);
   
     return elem && elem->list == this;  
  
 #if 0  
     for (const Linkable* p = _front; p; p = p->next)     for (const Linkable* p = _front; p; p = p->next)
     {     {
         if (p == elem)         if (p == elem)
Line 187 
Line 227 
  
     // Not found!     // Not found!
     return false;     return false;
 #endif  
 } }
  
 Linkable* ListRep::remove_front() Linkable* ListRep::remove_front()
 { {
     LIST_ASSERT(_magic == PEGASUS_LIST_MAGIC);      PEGASUS_LIST_ASSERT(_magic == PEGASUS_LIST_MAGIC);
  
     if (_size == 0)     if (_size == 0)
         return 0;         return 0;
Line 205 
Line 244 
  
 Linkable* ListRep::remove_back() Linkable* ListRep::remove_back()
 { {
     LIST_ASSERT(_magic == PEGASUS_LIST_MAGIC);      PEGASUS_LIST_ASSERT(_magic == PEGASUS_LIST_MAGIC);
     LIST_ASSERT(_size > 0);      PEGASUS_LIST_ASSERT(_size > 0);
  
     Linkable* elem = _back;     Linkable* elem = _back;
     remove(elem);     remove(elem);
Line 216 
Line 255 
  
 Linkable* ListRep::find(ListRep::Equal equal, const void* client_data) Linkable* ListRep::find(ListRep::Equal equal, const void* client_data)
 { {
     LIST_ASSERT(_magic == PEGASUS_LIST_MAGIC);      PEGASUS_LIST_ASSERT(_magic == PEGASUS_LIST_MAGIC);
     LIST_ASSERT(equal != 0);      PEGASUS_LIST_ASSERT(equal != 0);
  
     for (Linkable* p = _front; p; p = p->next)     for (Linkable* p = _front; p; p = p->next)
     {     {
         if ((*equal)(p, client_data))         if ((*equal)(p, client_data))
         {         {
             LIST_ASSERT(p->magic == PEGASUS_LINKABLE_MAGIC);              PEGASUS_LIST_ASSERT(p->magic == PEGASUS_LINKABLE_MAGIC);
             return p;             return p;
         }         }
     }     }
Line 234 
Line 273 
  
 Linkable* ListRep::remove(ListRep::Equal equal, const void* client_data) Linkable* ListRep::remove(ListRep::Equal equal, const void* client_data)
 { {
     LIST_ASSERT(_magic == PEGASUS_LIST_MAGIC);      PEGASUS_LIST_ASSERT(_magic == PEGASUS_LIST_MAGIC);
     LIST_ASSERT(equal != 0);      PEGASUS_LIST_ASSERT(equal != 0);
  
     Linkable* p = find(equal, client_data);     Linkable* p = find(equal, client_data);
  
     if (p)     if (p)
     {     {
         LIST_ASSERT(p->magic == PEGASUS_LINKABLE_MAGIC);          PEGASUS_LIST_ASSERT(p->magic == PEGASUS_LINKABLE_MAGIC);
         remove(p);         remove(p);
     }     }
  
Line 250 
Line 289 
  
 void ListRep::apply(ListRep::Apply apply, const void* client_data) void ListRep::apply(ListRep::Apply apply, const void* client_data)
 { {
     LIST_ASSERT(_magic == PEGASUS_LIST_MAGIC);      PEGASUS_LIST_ASSERT(_magic == PEGASUS_LIST_MAGIC);
     LIST_ASSERT(apply != 0);      PEGASUS_LIST_ASSERT(apply != 0);
  
     for (Linkable* p = _front; p; p = p->next)     for (Linkable* p = _front; p; p = p->next)
         (*apply)(p, client_data);         (*apply)(p, client_data);

Legend:
Removed from v.1.1.2.1  
changed lines
  Added in v.1.1.2.6
No CVS admin address has been configured
 Powered by
ViewCVS 0.9.2