UtlLink.h

Go to the documentation of this file.

//
// Copyright (C) 2005 SIPfoundry Inc.
// License by SIPfoundry under the LGPL license.
// 
// Copyright (C) 2005 Pingtel Corp.
// Licensed to SIPfoundry under a Contributor Agreement.
//

#ifndef _UTLLINK_H_
#define _UTLLINK_H_

#include "assert.h"

// SYSTEM INCLUDES
#include "os/OsDefs.h"
#include "os/OsBSem.h"

// APPLICATION INCLUDES
#include "utl/UtlContainable.h"

// DEFINES
#ifndef UTLLINK_BLOCK_SIZE
#define UTLLINK_BLOCK_SIZE 1000
#endif

// MACROS
// EXTERNAL FUNCTIONS
// EXTERNAL VARIABLES
// CONSTANTS
// STRUCTS
// TYPEDEFS
// FORWARD DECLARATIONS
class UtlLink;
class UtlChainPool;

class UtlChain
{
/* //////////////////////////// PUBLIC //////////////////////////////////// */
  public:
   UtlChain() :
      prev(NULL),
      next(NULL)
      {
      }

   ~UtlChain()
      {
      }

/* //////////////////////////// PROTECTED //////////////////////////////////// */
  protected:
   friend class UtlChainPool;
   friend class UtlLink;
   friend class UtlPair;
   friend class UtlContainer;
   friend class UtlList;
   friend class UtlHashMap;
   friend class UtlHashMapIterator;
   friend class UtlHashBag;
   friend class UtlHashBagIterator;
   friend class UtlChainTest;
   friend class UtlLinkTest;
   
   UtlChain* prev; 
   UtlChain* next; 

   // ================================================================

   bool isUnLinked() const
      {
         return (!(prev||next));
      }

   void unchain()
      {
         if (prev)
         {
            prev->next = next;
         }
         if (next)
         {
            next->prev = prev;
         }
         prev=NULL;
         next=NULL;
      }


   void chainBefore(UtlChain* existing)
      {
         assert(isUnLinked()); // not valid on a link that's in a chain
         
         next = existing;
         if (existing->prev)
         {
            prev = existing->prev;
         }
         if (prev)
         {
            prev->next = this;
         }
         existing->prev = this;
      }
   


   void chainAfter(UtlChain* existing)
      {
         assert(isUnLinked()); // not valid on a link that's in a chain

         prev = existing;
         next = existing->next;
         if (next)
         {
            next->prev = this;
         }
         existing->next = this;
      }


   // ================================================================

   UtlChain* listHead() const
      {
         return next;
      }

   UtlChain* listTail() const
      {
         return prev;
      }

   UtlLink* head() const
      {
         return (UtlLink*)next;
      }

   UtlLink* tail() const
      {
         return (UtlLink*)prev;
      }

   void listBefore(UtlChain* list,    
                   UtlChain* existing 
                   );
   void listAfter(UtlChain* list,     
                  UtlChain* existing  
                  );
   UtlChain* detachFromList(UtlChain* listHead);
   
/* //////////////////////////// PRIVATE /////////////////////////////////// */
  private:
};


class UtlLink : public UtlChain
{
/* //////////////////////////// PUBLIC //////////////////////////////////// */
  public:

   // ================================================================

   UtlLink* next() const
      {
         return static_cast<UtlLink*>(UtlChain::next);
      }
   
   UtlLink* prev() const
      {
         return static_cast<UtlLink*>(UtlChain::prev);
      }

   UtlLink* findDataRef(UtlContainable* target) const
      {
         UtlLink* theLink;
         for (theLink=const_cast<UtlLink*>(this);
              theLink && theLink->data != target;
              theLink=theLink->next())
         {
         }
         return theLink;
      }

   UtlLink* findNextHash(unsigned targetHash) const
      {
         UtlLink* theLink;
         for (theLink=const_cast<UtlLink*>(this);
              theLink && theLink->hash != targetHash;
              theLink=theLink->next())
         {
         }
         return theLink;
      }
   
   UtlContainable*    data;
   unsigned           hash;


   // ================================================================


   static size_t totalAllocated();

   
/* //////////////////////////// PROTECTED ///////////////////////////////// */
  protected:
   friend class UtlChainPool;
   friend class UtlContainer;
   friend class UtlList;
   friend class UtlListIterator;
   friend class UtlSList;
   friend class UtlSListIterator;
   friend class UtlSortedList;
   friend class UtlHashBag;
   friend class UtlHashBagIterator;
   friend class UtlLinkTest;
   friend class UtlInit;

   // ================================================================
   
   UtlContainable* unlink();
   static UtlLink* before(UtlChain* existing, UtlContainable* newData);

   static UtlLink* after(UtlChain* existing, UtlContainable* newData);


   // ================================================================


   static UtlLink* listBefore(UtlChain* list,    
                              UtlChain* existing,
                              UtlContainable* newData 
                              );
   static UtlLink* listAfter(UtlChain* list,     
                             UtlChain* existing, 
                             UtlContainable* newData 
                             );
   UtlContainable* detachFrom(UtlChain* listHead);
   static UtlLink* findData(UtlChain* list, UtlContainable* target) 
      {
         return list->next ? static_cast<UtlLink*>(list->next)->findDataRef(target) : NULL;
      }
   

   // ================================================================


   UtlLink() :
      data(NULL),
      hash(0)
      {
      };


   ~UtlLink()
      {
      };

   static UtlLink* get();

   void release();

   void rehash();

/* //////////////////////////// PRIVATE /////////////////////////////////// */
  private:

   static void allocate(size_t    blocksize, 
                        UtlChain* blockList, 
                        UtlChain* pool       
                        );
   

   static UtlChainPool* spLinkPool;  
};

class UtlPair : public UtlLink
{
  protected:
   friend class UtlHashMap;
   friend class UtlHashMapIterator;
   friend class UtlHashBagIterator;
   friend class UtlInit;

   UtlContainable* value;

   UtlPair() :
      value(NULL)
      {
      };

   ~UtlPair()
      {
      }
   
   static UtlChainPool* spPairPool;

   static UtlPair* get();

   void release();

  private:
   static void allocate(size_t    blocksize, 
                        UtlChain* blockList, 
                        UtlChain* pool       
                        );

};

#endif    // _UTLLINK_H_