vtkStringStringMap.h

Go to the documentation of this file.

/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*-
 *
 * $Id: vtkStringStringMap.h,v 1.5 2004/08/10 07:37:21 xpxqx Exp $
 *
 * Copyright (c) 2004 Sean McInerney
 * All rights reserved.
 *
 * See Copyright.txt or http://vtkextensions.sourceforge.net/Copyright.html
 * for details.
 *
 *    This software is distributed WITHOUT ANY WARRANTY; without even 
 *    the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR 
 *    PURPOSE.  See the above copyright notice for more information.
 *
 */
#ifndef VTK_STRING_STRING_MAP_H_
#  define VTK_STRING_STRING_MAP_H_
#  include "vtkExtensionsObject.h"
#  include "vtkStringOps.h" // inline string operations

VTK_EXTENSIONS_NAMESPACE_BEGIN

class vtkStringStringPair;

class VTK_EXTENSIONS_COMMON_EXPORT vtkStringStringMap
  : public vtkExtensionsObject
{
public:
  static vtkStringStringMap* New (void);
  vtkTypeRevisionMacro (vtkStringStringMap, vtkExtensionsObject);
  void PrintSelf (ostream&, vtkIndent);

  vtkGetMacro (CheckUnique, int);
  vtkSetMacro (CheckUnique, int);
  vtkBooleanMacro (CheckUnique, int);
  vtkGetMacro (CheckCase, int);
  vtkSetMacro (CheckCase, int);
  vtkBooleanMacro (CheckCase, int);
  vtkIdType     GetSize (void) const /*THROW_SPEC()*/;

  int           IsEmpty (void) const /*THROW_SPEC()*/;

  void          Clear (void) /*THROW_SPEC1(vtkBadAlloc)*/;

  vtkIdType     GetCapacity (void) const /*THROW_SPEC()*/;

  const vtkUTF16ChType* Find (const vtkUTF16ChType*     key) const
    /*THROW_SPEC()*/;
  const vtkUTF16ChType* Find (const vtkUTF8ChType*      key) const
    /*THROW_SPEC1(vtkBadAlloc)*/;
  const vtkUTF16ChType* Find (const char*               key) const
    /*THROW_SPEC1(vtkBadAlloc)*/;
  int           Insert (const vtkUTF16ChType*   key,
                        const vtkUTF16ChType*   value)
    /*THROW_SPEC2(vtkBadAlloc, vtkOverflowError)*/;
  int           Insert (const vtkUTF8ChType*    key,
                        const vtkUTF8ChType*    value)
    /*THROW_SPEC2(vtkBadAlloc, vtkOverflowError)*/;
  int           Insert (const char*             key,
                        const char*             value)
    /*THROW_SPEC2(vtkBadAlloc, vtkOverflowError)*/;
  int           Erase (const vtkUTF16ChType*    key)
    /*THROW_SPEC()*/;
  int           Erase (const vtkUTF8ChType*     key)
    /*THROW_SPEC1(vtkBadAlloc)*/;
  int           Erase (const char*              key)
    /*THROW_SPEC1(vtkBadAlloc)*/;
  virtual void  Swap (vtkStringStringMap* object);

  virtual const vtkUTF16ChType* FindKey (const vtkUTF16ChType* other);

  const vtkUTF16ChType*         FindNextKey (void);

protected:
  vtkStringStringMap (void);
  ~vtkStringStringMap();

private:
  int                           CheckUnique;
  int                           CheckCase;

  vtkIdType                     CapacityIndex;

  vtkIdType                     Capacity;

  vtkIdType                     EnteredSize;

  vtkIdType                     ErasedSize;

  vtkIdType                     MaxSize;

  vtkIdType                     MinSize;

  vtkStringStringPair**         Table;

  vtkIdType                     SearchIndex;

  vtkIdType                     TraversalIndex;

  //BTX
  void          EraseAll (void);

  void          GrowTable (void) THROW_SPEC2(vtkBadAlloc, vtkOverflowError);

  void          ShrinkTable (void) THROW_SPEC1(vtkBadAlloc);

  vtkUint32Type Hash (const vtkUTF16ChType* const& key) const THROW_SPEC();
  void          Rehash (vtkUint32Type const& initial,
                        vtkUint32Type &      current) const THROW_SPEC();
  int           IsOccupied (const vtkIdType index) const THROW_SPEC();

  int           Equals (const vtkUTF16ChType* const& str1,
                        const vtkUTF16ChType* const& str2) const THROW_SPEC();

  int           Find (vtkIdType            const& index,
                      vtkStringStringPair* &      slot) const THROW_SPEC();

  void          Insert (vtkStringStringPair* const& pair) THROW_SPEC();

  int           Erase (vtkIdType            const& index,
                       vtkStringStringPair* &      slot) THROW_SPEC();
  //ETX

private:
  vtkStringStringMap (const vtkStringStringMap&);
  void operator= (const vtkStringStringMap&);
};

// ----------------------------------------------------------------------------
inline vtkUint32Type
vtkStringStringMap::Hash (const vtkUTF16ChType* const& aKey) const THROW_SPEC()
{
  // (0 < initial hash value < table size).
  return vtkUint32Type(1 + vtkStringOps::Hash(aKey, this->Capacity - 1));
}

inline void
vtkStringStringMap::Rehash (vtkUint32Type const& aInitial,
                            vtkUint32Type &      aCurrent) const THROW_SPEC()
{
  if ((aCurrent += aInitial) >= this->Capacity)
    {
    aCurrent %= this->Capacity;
    }
}

// ----------------------------------------------------------------------------
inline int
vtkStringStringMap::Equals (const vtkUTF16ChType* const& aStr1,
                            const vtkUTF16ChType* const& aStr2) const
  THROW_SPEC()
{
  return ( this->CheckCase ?
           vtkStringOps::Equals(aStr1, aStr2) :
           vtkStringOps::EqualsI(aStr1, aStr2) );
}

// ----------------------------------------------------------------------------
inline int
vtkStringStringMap::IsOccupied (const vtkIdType aIndex) const THROW_SPEC()
{
  if ( aIndex >= this->Capacity ||
       (this->Table[aIndex] == (vtkStringStringPair *)  0) ||
       (this->Table[aIndex] == (vtkStringStringPair *) -1) )
    {
    return VTK_FALSE;
    }

  return VTK_TRUE;
}

// ----------------------------------------------------------------------------
inline const vtkUTF16ChType*
vtkStringStringMap::Find (const vtkUTF8ChType*    aKey) const
/*THROW_SPEC1(vtkBadAlloc)*/
{
  return this->Find(UTF8_TO_UTF16(aKey));
}

inline const vtkUTF16ChType*
vtkStringStringMap::Find (const char*             aKey) const
/*THROW_SPEC1(vtkBadAlloc)*/
{
  return this->Find(LATIN1_TO_UTF16(aKey));
}

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
inline int
vtkStringStringMap::Insert (const vtkUTF8ChType* aKey,
                            const vtkUTF8ChType* aValue)
/*THROW_SPEC2(vtkBadAlloc, vtkOverflowError)*/
{
  return this->Insert(UTF8_TO_UTF16(aKey), UTF8_TO_UTF16(aValue));
}

inline int
vtkStringStringMap::Insert (const char* aKey,
                            const char* aValue)
/*THROW_SPEC2(vtkBadAlloc, vtkOverflowError)*/
{
  return this->Insert(LATIN1_TO_UTF16(aKey), LATIN1_TO_UTF16(aValue));
}

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
inline int
vtkStringStringMap::Erase (const vtkUTF8ChType* aKey)
/*THROW_SPEC1(vtkBadAlloc)*/
{
  return this->Erase(UTF8_TO_UTF16(aKey));
}

inline int
vtkStringStringMap::Erase (const char* aKey)
/*THROW_SPEC1(vtkBadAlloc)*/
{
  return this->Erase(LATIN1_TO_UTF16(aKey));
}

VTK_EXTENSIONS_NAMESPACE_END

#endif /* VTK_STRING_STRING_MAP_H_ */
/*
 * End of: $Id: vtkStringStringMap.h,v 1.5 2004/08/10 07:37:21 xpxqx Exp $.
 *
 */

---