IfdStrKey.cxx

Go to the documentation of this file.

//--------------------------------------------------------------------------
// File and Version Information:
//    $Id: IfdStrKey.cxx,v 1.1.1.1 2005/04/21 01:18:05 zhangy Exp $
//
// Description:
//    Implementation of IfdStrKey.  See .hh for details.
//
// Author List:
//    Ed Frank                        University of Pennsylvania
//
// History:
//    Ed Frank      18 Sep 97         Creation of first version
//
// Copyright Information:
//      Copyright (C) 1997
//
// Bugs:
//
//------------------------------------------------------------------------
 
// #include "BaBar/BaBar.hh"
#include "ProxyDict/IfdStrKey.h"
#if !( defined( __GNUC__ ) && ( __GNUC__ < 3 ) &&                                             \
       ( __GNUC_MINOR__ < 95 ) ) // BABAR_IOSTREAMS_MIGRATION
using std::ostream;
#endif // BABAR_IOSTREAMS_MIGRATION
 
//****************************************************************************
IfdStrKey::IfdStrKey( const char* s )
    //****************************************************************************
 
    : IfdKey( strKey )
 
{
 
  // NB: strncpy would be nice below, but we've already died in strlen
  // if thats an issue.
 
  register size_t strSize = strlen( s ) + 1;
 
  // If the space allocated in this instance of IfdStrKey is big enough
  // to hold the string, then put it there; otherwise do the slower operation
  // of allocating it in the heap.  Either way, make strVal point at it
  // to avoid "if allocated" sort of logic later.
 
  if ( strSize < IFDKEY_BUFSIZE )
  {
    strcpy( _stringBuf, s );
    strVal  = &_stringBuf[0];
    _onHeap = false;
  }
  else
  {
    strVal = new char[strSize];
    strcpy( strVal, s );
    _onHeap = true;
  }
 
  enum {
    MaxChar = 64 // Limit computation.  Don't need strlen()
  };
 
  _hashVal = 0;
 
  size_t n = 0;
  while ( ( s[n] != '\0' ) && ( n < MaxChar ) )
  {
    _hashVal = ( ( _hashVal << 8 ) + s[n] ) % _nHashBuckets;
    n++;
  }
}
 
#ifndef VXWORKS
//****************************************************************************
IfdStrKey::IfdStrKey( const std::string& str )
    //****************************************************************************
 
    : IfdKey( strKey )
 
{
  using std::string;
  const char*     s       = str.c_str();
  register size_t strSize = str.size() + 1;
 
  // register size_t strSize =  strlen(s)+1;
 
  // If the space allocated in this instance of IfdStrKey is big enough
  // to hold the string, then put it there; otherwise do the slower operation
  // of allocating it in the heap.  Either way, make strVal point at it
  // to avoid "if allocated" sort of logic later.
 
  if ( strSize < IFDKEY_BUFSIZE )
  {
    strcpy( _stringBuf, s );
    strVal  = &_stringBuf[0];
    _onHeap = false;
  }
  else
  {
    strVal = new char[strSize];
    strcpy( strVal, s );
    _onHeap = true;
  }
 
  enum {
    MaxChar = 64 // Limit computation.  Don't need strlen()
  };
 
  _hashVal = 0;
 
  size_t n = 0;
  while ( ( s[n] != '\0' ) && ( n < MaxChar ) )
  {
    _hashVal = ( ( _hashVal << 8 ) + s[n] ) % _nHashBuckets;
    n++;
  }
}
#endif
 
//****************************************************************************
IfdStrKey::IfdStrKey( const char* s, unsigned int hashVal )
    //****************************************************************************
    // Used for the clone function.  We keep this private because we don't trust
    // anyone else to set the hash value correctly/consistently.  The aim here
    // is to save the cost of calling the hash function during a clone.
 
    : IfdKey( strKey ) {
 
  // This code is cut/paste from the other constructor.  This is harder
  // to maintain but in this case we very much need the speed gained by
  // saving a call.
 
  register size_t strSize = strlen( s ) + 1;
 
  if ( strSize < IFDKEY_BUFSIZE )
  {
    strcpy( _stringBuf, s );
    strVal  = &_stringBuf[0];
    _onHeap = false;
  }
  else
  {
    strVal = new char[strlen( s ) + 1];
    strcpy( strVal, s );
    _onHeap = true;
  }
 
  _hashVal = hashVal; // Override the IfdKey base class init of this.
}
 
//****************************************************************************
IfdStrKey::~IfdStrKey() {
  //****************************************************************************
  if ( _onHeap ) delete[] strVal;
  strVal = 0;
}
 
//****************************************************************************
IfdKey* IfdStrKey::clone( void ) const {
  //****************************************************************************
  return new IfdStrKey( strVal, _hashVal );
}
 
//****************************************************************************
int IfdStrKey::operator==( const IfdKey& k ) const {
  //****************************************************************************
 
  if ( ( strKey == k.getKeyKind() ) && ( _hashVal == k._hashVal ) )
  {
 
    // Then they might actually match!  Check the strings.
    // We used to use strcmp, but this is faster by x2.2.
    char* s1 = strVal;
    char* s2 = k.strVal;
    while ( *s1 == *s2++ )
    {
      if ( *s1++ == '\0' ) return 1; // NB: == in while => *s2 == \0 too.
    }
  }
 
  return 0;
}
 
//****************************************************************************
int IfdStrKey::operator<( const IfdKey& k ) const {
  //****************************************************************************
  return ( strKey == k.getKeyKind() ) && ( strcmp( strVal, k.strVal ) < 0 );
}
 
//****************************************************************************
void IfdStrKey::print( ostream& o ) const {
  //****************************************************************************
  o << "IfdStrKey(" << strVal << ")";
}