able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/inetsrv/query/h/key.hxx

1168 lines
30 KiB
C++
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
//+---------------------------------------------------------------------------
//
// Microsoft Windows
// Copyright (C) Microsoft Corporation, 1991 - 2000.
//
// File: Key.hxx
//
// Contents: Normalized key class
//
// Classes: CKey, CKeyBuf
//
// History: 29-Mar-91 BartoszM Created
//
// Notes: Key comparison is tricky. The global Compare function
// is the basis for key sorting. Searching may involve
// wildcard pidAll.
//
//----------------------------------------------------------------------------
#pragma once
#include <sstream.hxx>
#include <streams.hxx>
#include <bitoff.hxx>
// size of key prefix in bytes (STRING_KEY and VALUE_KEY)
const unsigned cbKeyPrefix = 1;
// maximum size of key (in bytes)
const unsigned MAXKEYSIZE = 128 + cbKeyPrefix;
const BYTE MAX_BYTE = 0xff;
// maximum size of key (in WCHARs)
const unsigned cwcMaxKey = (MAXKEYSIZE - cbKeyPrefix)/sizeof(WCHAR);
const BYTE STRING_KEY = 0;
const BYTE VALUE_KEY = 1;
//+---------------------------------------------------------------------------
//
// Class: CKey
//
// Purpose: Content index key. Used in data structures holding
// potentially large numbers of keys.
//
// History: 29-Mar-91 BartoszM Created
// 27-Oct-27 DwightKr Added Type() method
//
//----------------------------------------------------------------------------
class CKey
{
friend class CKeyBuf;
public:
CKey () : cb(0), buf(0) {}
inline CKey ( const CKeyBuf& keyBuf );
inline CKey ( const CKey& key );
CKey ( CStream & stream ) { Init( stream ); }
inline ~CKey();
void Init() {
cb = 0;
buf = 0;
}
inline void Init( CStream & stream );
void Free()
{
delete buf;
buf = 0;
}
inline void operator= ( const CKey& key );
inline void operator= ( const CKeyBuf& keybuf );
BOOL IsMinKey() const { return 0 == cb && pidAll == pid; }
inline int Compare ( const CKey& key ) const;
inline int Compare ( const CKeyBuf& key ) const;
inline int CompareStr ( const CKeyBuf & key) const;
inline int CompareStr ( const CKey & key) const;
inline BOOL IsExactMatch ( const CKey& key ) const;
BYTE const* GetBuf() const { return buf; }
unsigned Count() const { return cb; }
PROPID Pid() const { return pid; }
void SetPid( PROPID newpid ) { pid = newpid; }
BOOL MatchPid ( const CKeyBuf& key ) const;
inline void FillMax ();
inline void FillMax ( const CKey& key );
inline void FillMin ();
inline void Serialize( CStream & stream ) const;
inline BOOL IsValue() const { return ( *buf != STRING_KEY ); }
inline BYTE Type() const { return *buf; }
inline void Acquire(CKey & key) {
Win4Assert(0 == buf);
cb = key.cb;
buf = key.buf;
pid = key.pid;
key.buf = 0;
key.cb = 0;
key.pid = 0;
}
//
// Serialization
//
inline void Marshall( PSerStream & stm ) const;
inline CKey( PDeSerStream & stm );
WCHAR* GetStr() const;
unsigned StrLen() const;
#ifdef CIEXTMODE
void CiExtDump(void *ciExtSelf);
#endif
private:
unsigned cb;
BYTE* buf;
PROPID pid;
};
//+---------------------------------------------------------------------------
//
// Class: CKeyBuf
//
// Purpose: Content index key buffer. Used for holding key data.
// It has a large fixed size buffer. Use sparingly.
//
// History: 29-Mar-91 BartoszM Created
// 27-Oct-27 DwightKr Added Type() method
//
//----------------------------------------------------------------------------
class CKeyBuf
{
public:
inline CKeyBuf( PROPID pid, BYTE const * pb, unsigned cb );
inline CKeyBuf() : cb(0)
#if CIDBG == 1
, pid(0)
#endif // CIDBG == 1
{}
#if 0 // STACKSTACK
inline CKeyBuf(const CKey& key);
#endif
inline void operator=(const CKeyBuf & key);
inline void operator=(const CKey & key);
inline void FillMax();
inline void FillMin();
inline BOOL IsMaxKey() const;
inline BOOL IsMinKey() const;
inline int CompareStr ( const CKeyBuf & key) const;
inline int CompareStr ( const CKey & key) const;
inline int Compare ( const CKeyBuf& key ) const;
inline int Compare ( const CKey& key ) const;
inline BOOL IsPossibleRW();
BYTE const* GetBuf() const { return (BYTE *)buf; }
BYTE * GetWritableBuf() { return (BYTE *)buf; }
unsigned Count() const { return cb; }
unsigned * GetWritableCount() { return &cb; }
PROPID Pid() const { return pid; }
void SetCount(unsigned i) {cb = i;}
void SetPid ( PROPID pidNew ) {pid = pidNew;}
unsigned* GetCountAddress() {return(&cb);}
BOOL IsValue() const { return ( *buf != STRING_KEY ); }
BYTE Type() const { return *buf; }
WCHAR* GetStr() const;
unsigned StrLen() const;
#ifdef CIEXTMODE
void CiExtDump(void *ciExtSelf);
#endif
private:
unsigned cb;
BYTE buf[MAXKEYSIZE];
PROPID pid;
};
class SKeyBuf
{
public :
SKeyBuf(CKeyBuf * pKeyBuf) { _pKeyBuf = pKeyBuf;
}
~SKeyBuf() { delete _pKeyBuf; }
CKeyBuf * operator -> () { return _pKeyBuf; }
CKeyBuf & operator * () { return *_pKeyBuf; }
CKeyBuf * Acquire()
{ CKeyBuf * pTemp = _pKeyBuf; _pKeyBuf = 0; return pTemp; }
private:
CKeyBuf * _pKeyBuf;
};
//+---------------------------------------------------------------------------
//
// Function: Compare
//
// Synopsis: Compare two unsigned longs
//
// Arguments: [ul1] -- first ulong
// [ul2] -- second ulong
//
// Returns: "difference" ul1 - ul2
//
// History: 07-May-91 BartoszM Created
//
//----------------------------------------------------------------------------
inline int Compare ( ULONG u1, ULONG u2 )
{
return ( u1 > u2 )? 1 : (( u1 < u2 )? -1: 0);
}
//+---------------------------------------------------------------------------
//
// Class: CDirectoryKey
//
// Purpose: Key class for use in the (downlevel) directory
//
// History: 3-May-95 dlee created
//
// Notes: Directory keys look like this:
//
// cb of the key (2 bytes)
// BitOffset (8 bytes)
// PROPID (4 bytes)
// the key (cb bytes)
//
// There are no alignment constraints on any of the fields.
//
//----------------------------------------------------------------------------
#include <pshpack1.h>
const BYTE pidIdMaxSmallPid = 0x40; // 1-byte pids > this are 4096-based
const ULONG pidNewPidBase = INIT_DOWNLEVEL_PID; // base of CI's new pids
class CDirectoryKey
{
public:
void * operator new( size_t size, void *pv ) { return pv; }
void operator delete( void * p ) {}
unsigned Count()
{
return (unsigned) _cbKey;
}
BYTE * Key()
{
Win4Assert( 0 != this );
return (BYTE *) ( this + 1 ) + ExtraPropIdSize();
}
PROPID PropId()
{
Win4Assert( 0 != this );
if ( 0 == _bPropId )
return * (UNALIGNED PROPID *) ( this + 1 );
if ( _bPropId > pidIdMaxSmallPid )
return (PROPID) _bPropId - pidIdMaxSmallPid + pidNewPidBase - 1;
return (PROPID) _bPropId;
}
void PropId( PROPID & pid )
{
pid = PropId();
}
void Offset( BitOffset & offset )
{
Win4Assert( 0 != this );
offset.SetPage( * (UNALIGNED ULONG *) &_oPage );
offset.SetOff( * (UNALIGNED USHORT *) &_oBit );
}
void Write( BYTE cbKey,
BitOffset bitOffset,
PROPID pid,
const BYTE * buf )
{
* (UNALIGNED ULONG *) &_oPage = bitOffset.Page();
Win4Assert( bitOffset.Offset() <= 0xffff );
* (UNALIGNED USHORT *) &_oBit = (USHORT) bitOffset.Offset();
BYTE * pbKey = (BYTE *) (this + 1);
if ( pid <= pidIdMaxSmallPid )
{
_bPropId = (BYTE) pid;
}
else if ( ( pid >= pidNewPidBase ) &&
( pid < ( pidNewPidBase + 0xfd - pidIdMaxSmallPid ) ) )
{
_bPropId = (BYTE) ( pid - pidNewPidBase + pidIdMaxSmallPid + 1 );
}
else
{
_bPropId = 0;
RtlCopyMemory( pbKey, &pid, sizeof ULONG );
pbKey += sizeof ULONG;
}
_cbKey = cbKey;
RtlCopyMemory( pbKey, buf, cbKey );
}
unsigned Size()
{
return sizeof CDirectoryKey + ExtraPropIdSize() + Count();
}
static unsigned ComputeSize( BYTE cbKey, PROPID pid )
{
unsigned cbPid = 0;
if ( ! ( ( pid <= pidIdMaxSmallPid ) ||
( ( pid >= pidNewPidBase ) &&
( pid < ( pidNewPidBase + 0xfd - pidIdMaxSmallPid ) ) ) ) )
cbPid = sizeof ULONG;
return sizeof CDirectoryKey + cbPid + cbKey;
}
CDirectoryKey * NextKey()
{
Win4Assert( 0 != this );
return (CDirectoryKey *) ( (BYTE *) this + Size() );
}
BOOL IsGreaterThanKeyBuf( const CKeyBuf & key )
{
// return TRUE if "this" is greater than key
Win4Assert( 0 != this );
Win4Assert( 0 != &key );
Win4Assert( pidAll != PropId() );
unsigned count = Count();
unsigned long mincb = __min( count, key.Count() );
int diff = memcmp( Key(), key.GetBuf(), mincb );
if ( 0 == diff )
{
diff = count - key.Count();
if ( 0 == diff )
{
diff = ::Compare( PropId(), key.Pid() );
}
}
return diff > 0;
}
void MakeKeyBuf( CKeyBuf & keyBuf )
{
// copy the count and key
unsigned cbKey = Count();
keyBuf.SetCount( cbKey );
RtlCopyMemory( keyBuf.GetWritableBuf(),
Key(),
cbKey );
// copy the pid
keyBuf.SetPid( PropId() );
}
private:
unsigned ExtraPropIdSize()
{
return ( 0 == _bPropId ) ? sizeof ULONG : 0;
}
ULONG _oPage; // page number
USHORT _oBit; // bit offset in the page
BYTE _bPropId; // Byte form of propid, or 0 if it won't fit
BYTE _cbKey; // Byte count of the key following
};
#include <poppack.h>
//+---------------------------------------------------------------------------
//
// Member: CKey::~Ckey
//
// Synopsis: Free memory
//
// History: 07-May-91 BartoszM Created
//
//----------------------------------------------------------------------------
inline CKey::~CKey()
{
delete buf;
}
inline void CKey::Marshall( PSerStream & stm ) const
{
stm.PutULong( pid );
stm.PutULong( cb );
stm.PutBlob( buf, cb );
}
inline CKey::CKey( PDeSerStream & stm )
: buf(0)
{
pid = stm.GetULong();
cb = stm.GetULong();
// Guard against attack
if ( cb >= 65536 )
THROW( CException( E_INVALIDARG ) );
buf = new BYTE[cb];
stm.GetBlob( buf, cb );
}
inline void CKey::Init( CStream & stream )
{
stream.Read( &cb, sizeof( cb ) );
buf = new BYTE[cb];
stream.Read( buf, sizeof( buf[0] ) * cb );
stream.Read( &pid, sizeof( pid ) );
}
inline void CKey::Serialize( CStream & stream ) const
{
stream.Write( &cb, sizeof( cb ) );
stream.Write( buf, sizeof( buf[0] ) * cb );
stream.Write( &pid, sizeof( pid ) );
}
//+---------------------------------------------------------------------------
//
// Member: CKey::FillMax
//
// Synopsis: Makes a max key, greater or equal to any key.
//
// History: 07-May-91 BartoszM Created
//
//----------------------------------------------------------------------------
inline void CKey::FillMax ()
{
Win4Assert ( pidInvalid == 0xffffffff );
pid = pidInvalid;
cb = MAXKEYSIZE;
Win4Assert ( buf == 0 );
buf = new BYTE[MAXKEYSIZE];
memset( buf, MAX_BYTE, MAXKEYSIZE);
}
//+---------------------------------------------------------------------------
//
// Member: CKey::FillMax
//
// Synopsis: Treats [key] as a prefix. Creates a key that is greater
// than any other key with the same prefix.
// Used for end of range
//
// Arguments: [key] -- prefix
//
// History: 07-May-91 BartoszM Created
//
//----------------------------------------------------------------------------
inline void CKey::FillMax ( const CKey& key )
{
Win4Assert ( &key != 0 );
Win4Assert ( this != 0 );
buf = new BYTE[MAXKEYSIZE];
cb = MAXKEYSIZE;
pid = key.Pid();
memcpy ( buf, key.GetBuf(), key.Count());
memset ( buf + key.Count(), MAX_BYTE, MAXKEYSIZE - key.Count() );
}
//+---------------------------------------------------------------------------
//
// Member: CKey::FillMin
//
// Synopsis: Creates a minimum key
//
// History: 07-May-91 BartoszM Created
//
//----------------------------------------------------------------------------
inline void CKey::FillMin()
{
cb = 0;
pid = 0;
}
//+---------------------------------------------------------------------------
//
// Member: CKey::CKey
//
// Synopsis: Creates CKey based on CKeyBuf
//
// Arguments: [keybuf] -- original
//
// History: 07-May-91 BartoszM Created
//
//----------------------------------------------------------------------------
inline CKey::CKey ( const CKeyBuf& keybuf )
: buf(0)
{
Win4Assert ( &keybuf != 0 );
Win4Assert ( this != 0 );
cb = keybuf.Count();
pid = keybuf.Pid();
buf = new BYTE [cb];
memcpy ( buf, keybuf.GetBuf(), cb );
}
//+---------------------------------------------------------------------------
//
// Member: CKey::CKey
//
// Synopsis: Copy constructor
//
// Arguments: [keySrc] -- original
//
// History: 07-May-91 BartoszM Created
//
//----------------------------------------------------------------------------
inline CKey::CKey ( const CKey& keySrc )
: buf(0)
{
Win4Assert ( &keySrc != 0 );
Win4Assert ( this != 0 );
cb = keySrc.cb;
pid = keySrc.pid;
buf = new BYTE [cb];
memcpy ( buf, keySrc.buf, cb );
}
//+---------------------------------------------------------------------------
//
// Member: CKey::operator=
//
// Synopsis: Creates CKey based on CKeyBuf
//
// Arguments: [keybuf] -- original
//
// History: 07-May-91 BartoszM Created
//
//----------------------------------------------------------------------------
inline void CKey::operator= ( const CKeyBuf& keybuf )
{
Win4Assert ( &keybuf != 0 );
Win4Assert ( this != 0 );
cb = keybuf.Count();
pid = keybuf.Pid();
Win4Assert ( buf == 0 );
buf = new BYTE [cb];
memcpy ( buf, keybuf.GetBuf(), cb );
}
//+---------------------------------------------------------------------------
//
// Member: CKey::operator=
//
// Synopsis: Creates CKey based on another CKey
//
// Arguments: [key] -- original
//
// History: 07-May-91 BartoszM Created
//
//----------------------------------------------------------------------------
inline void CKey::operator= ( const CKey& key )
{
Win4Assert ( &key != 0 );
Win4Assert ( this != 0 );
cb = key.cb;
pid = key.pid;
Win4Assert ( buf == 0 );
buf = new BYTE [cb];
memcpy ( buf, key.buf, cb );
}
//+---------------------------------------------------------------------------
//
// Member: CKey::MatchPid
//
// Synopsis: Compares pids, "this" may have wildcard pidAll
//
// Arguments: [key] -- the other key (not pidAll)
//
// History: 29-Nov-94 BartoszM Created
//
//----------------------------------------------------------------------------
inline BOOL CKey::MatchPid ( const CKeyBuf& key ) const
{
Win4Assert (key.Pid() != pidAll);
return ( Pid() == pidAll && key.Pid() != pidRevName ) || Pid() == key.Pid();
}
//+---------------------------------------------------------------------------
//
// Function: Compare
//
// Synopsis: Compare two keys
//
// Arguments: [key1] -- first key
// [key2] -- second key
//
// Returns: "difference" key1 - key2
//
// Requires: key1 != NULL && key2 != NULL
//
// History: 06-May-91 BartoszM Created
//
// Notice: No wildcard pidAll allowed
//
//----------------------------------------------------------------------------
inline int Compare ( const CKeyBuf* key1, const CKeyBuf* key2 )
{
Win4Assert ( key1 != 0 );
Win4Assert ( key2 != 0 );
Win4Assert ( key1->Pid() != pidAll );
Win4Assert ( key2->Pid() != pidAll );
int result;
unsigned long mincb = __min(key1->Count(), key2->Count());
result = memcmp(key1->GetBuf(), key2->GetBuf(), mincb);
if (result == 0)
{
result = key1->Count() - key2->Count();
if ( result == 0 )
result = Compare ( key1->Pid(), key2->Pid() );
}
return result;
}
//+---------------------------------------------------------------------------
//
// Function: AreEqual
//
// Synopsis: Compare two keys for equality. Early exit when lengths differ
//
// Arguments: [key1] -- first key
// [key2] -- second key
//
// Returns: TRUE when equal
//
// Requires: key1 != NULL && key2 != NULL
//
// History: 06-May-91 BartoszM Created
//
// Notice: No wildcard pidAll allowed
//
//----------------------------------------------------------------------------
inline BOOL AreEqual ( const CKeyBuf* key1, const CKeyBuf* key2 )
{
Win4Assert ( key1 != 0 );
Win4Assert ( key2 != 0 );
Win4Assert ( key1->Pid() != pidAll );
Win4Assert ( key2->Pid() != pidAll );
unsigned len = key1->Count();
if (key2->Count() != len)
return(FALSE);
if ( memcmp(key1->GetBuf(), key2->GetBuf(), len) != 0 )
return(FALSE);
return ( key1->Pid() == key2->Pid() );
}
//+---------------------------------------------------------------------------
//
// Function: AreEqualStr
//
// Synopsis: Compare two keys for equality of buffers (disregard PID).
// Early exit when lengths differ
//
// Arguments: [key1] -- first key
// [key2] -- second key
//
// Returns: TRUE when equal
//
// Requires: key1 != NULL && key2 != NULL
//
// History: 06-May-91 BartoszM Created
//
// Notice: No wildcard pidAll allowed
//
//----------------------------------------------------------------------------
inline BOOL AreEqualStr ( const CKeyBuf* key1, const CKeyBuf* key2 )
{
Win4Assert ( key1 != 0 );
Win4Assert ( key2 != 0 );
Win4Assert ( key1->Pid() != pidAll );
Win4Assert ( key2->Pid() != pidAll );
unsigned len = key1->Count();
if (key2->Count() != len)
return(FALSE);
return memcmp(key1->GetBuf(), key2->GetBuf(), len) == 0;
}
//+---------------------------------------------------------------------------
//
// Member: CKey::Compare
//
// Synopsis: Compare this with another key
//
// Arguments: [key] -- key to compare with
//
// Returns: "difference" this - key
// this key can have wildcard pidAll
// but it will be treated like any other pid
//
// Requires: [key]'s pid cannot be pidAll
//
// History: 14-Sep-92 BartoszM Created
//
//----------------------------------------------------------------------------
inline int CKey::Compare( const CKey & key) const
{
Win4Assert ( this != 0 );
Win4Assert ( &key != 0 );
Win4Assert ( key.Pid() != pidAll );
unsigned long mincb = __min(cb, key.Count());
int diff = memcmp(buf, key.GetBuf(), mincb);
if (diff == 0)
{ // this->buf == key.buf
diff = cb - key.Count();
if (diff == 0)
{
diff = ::Compare ( pid, key.Pid());
}
}
return(diff);
}
//+---------------------------------------------------------------------------
//
// Member: CKey::Compare
//
// Synopsis: Compare this with another key
//
// Arguments: [key] -- key to compare with
//
// Returns: "difference" this - key
// this key can have wildcard pidAll
// but it will be treated like any other pid
//
// Requires: [key]'s pid cannot be pidAll
//
// History: 14-Sep-92 BartoszM Created
//
//----------------------------------------------------------------------------
inline int CKey::Compare( const CKeyBuf & key) const
{
Win4Assert ( this != 0 );
Win4Assert ( &key != 0 );
Win4Assert ( key.Pid() != pidAll );
unsigned long mincb = __min(cb, key.Count());
int diff = memcmp(buf, key.GetBuf(), mincb);
if (diff == 0)
{ // this->buf == key.buf
diff = cb - key.Count();
if (diff == 0)
{
diff = ::Compare ( pid, key.Pid());
}
}
return(diff);
}
//+---------------------------------------------------------------------------
//
// Member: CKey::CompareStr
//
// Synopsis: Compare this with another key ignoring pid
//
// Arguments: [key] -- key to compare with
//
// Returns: "difference" this - key
//
// History: 14-Sep-92 BartoszM Created
//
//----------------------------------------------------------------------------
inline int CKey::CompareStr( const CKeyBuf & key) const
{
Win4Assert ( this != 0 );
Win4Assert ( &key != 0 );
unsigned long mincb = __min(cb, key.Count());
int diff = memcmp(buf, key.GetBuf(), mincb);
if (diff == 0)
{ // this->buf == key.buf
diff = cb - key.Count();
}
return(diff);
}
//+---------------------------------------------------------------------------
//
// Member: CKey::CompareStr
//
// Synopsis: Compare this with another key ignoring pid
//
// Arguments: [key] -- key to compare with
//
// Returns: "difference" this - key
//
// History: 14-Sep-92 BartoszM Created
//
//----------------------------------------------------------------------------
inline int CKeyBuf::CompareStr( const CKey & key) const
{
Win4Assert ( this != 0 );
Win4Assert ( &key != 0 );
unsigned long mincb = __min(cb, key.Count());
int diff = memcmp(buf, key.GetBuf(), mincb);
if (diff == 0)
{ // this->buf == key.buf
diff = cb - key.Count();
}
return(diff);
}
//+---------------------------------------------------------------------------
//
// Member: CKey::CompareStr
//
// Synopsis: Compare this with another key ignoring pid
//
// Arguments: [key] -- key to compare with
//
// Returns: "difference" this - key
//
// History: 14-Sep-92 BartoszM Created
//
//----------------------------------------------------------------------------
inline int CKey::CompareStr( const CKey & key) const
{
Win4Assert ( this != 0 );
Win4Assert ( &key != 0 );
unsigned long mincb = __min(cb, key.Count());
int diff = memcmp(buf, key.GetBuf(), mincb);
if (diff == 0)
{ // this->buf == key.buf
diff = cb - key.Count();
}
return(diff);
}
//+---------------------------------------------------------------------------
//
// Method: IsExactMatch
//
// Synopsis: Compare for exact equality. Early exit when lengths differ
//
// Arguments: [key] -- key to compare with
//
// Returns: TRUE when equal
//
// Requires: key1 != NULL && key2 != NULL
//
// History: 06-Oct-94 BartoszM Created
//
// Notice: pidAll allowed in both. Use to compare keys in query
//
//----------------------------------------------------------------------------
inline BOOL CKey::IsExactMatch ( const CKey& key ) const
{
Win4Assert (this != 0);
Win4Assert (&key != 0);
return cb == key.Count()
&& pid == key.Pid()
&& memcmp(buf, key.GetBuf(), cb) == 0;
}
//+---------------------------------------------------------------------------
//
// Member: CKeyBuf::IsPossibleRW, public
//
// Synopsis: Determine whether a word can be a relevant word or not.
//
// Returns: TRUE if no digits and > 2 characters long
//
// Notes: All of these characters are deemed 'digits' by Win32
//
// History: 6-May-94 v-dlee Created
//
//----------------------------------------------------------------------------
#define _IsADigit(x) (((x) >= 0x30 && (x) <= 0x39) || \
((x) >= 0xb2 && (x) <= 0xb3) || \
((x) == 0xb9) || \
((x) >= 0x660 && (x) <= 0x669) || \
((x) >= 0x6f0 && (x) <= 0x6f9) || \
((x) >= 0x966 && (x) <= 0x96f) || \
((x) >= 0x9e6 && (x) <= 0x9ef) || \
((x) >= 0xa66 && (x) <= 0xa6f) || \
((x) >= 0xae6 && (x) <= 0xaef) || \
((x) >= 0xb66 && (x) <= 0xb6f) || \
((x) >= 0xbe7 && (x) <= 0xbef) || \
((x) >= 0xbf0 && (x) <= 0xbf2) || \
((x) >= 0xc66 && (x) <= 0xc6f) || \
((x) >= 0xce6 && (x) <= 0xcef) || \
((x) >= 0xd66 && (x) <= 0xd6f) || \
((x) >= 0xe50 && (x) <= 0xe59) || \
((x) >= 0xed0 && (x) <= 0xed9) || \
((x) >= 0x1040 && (x) <= 0x1049) || \
((x) == 0x2070) || \
((x) >= 0x2074 && (x) <= 0x2079) || \
((x) >= 0x2080 && (x) <= 0x2089) || \
((x) >= 0xff10 && (x) <= 0xff19))
inline BOOL CKeyBuf::IsPossibleRW()
{
unsigned uCount = Count();
if (uCount > (1 + 2 * sizeof(WCHAR)))
{
const BYTE * p = (BYTE *) &buf;
p++;
for (unsigned c = 0; c < uCount; c += 2, p += 2)
{
WCHAR wc = MAKEWORD(*(p + 1),*p);
if (_IsADigit(wc))
{
return FALSE;
}
}
}
else return FALSE;
return TRUE;
} //IsPossibleRW
inline CKeyBuf::CKeyBuf( PROPID p, BYTE const * pb, unsigned count )
: pid( p ),
cb( count )
{
memcpy( buf, pb, count );
}
//+---------------------------------------------------------------------------
//
// Member: CKeyBuf::operator=, public
//
// Synopsis: Assignment operator
//
// Arguments: [key] -- CKeyBuf to assign to this.
//
// History: 26-Jun-91 KyleP Created.
//
//----------------------------------------------------------------------------
inline void CKeyBuf::operator=(const CKeyBuf & key)
{
cb = key.Count();
pid = key.Pid();
memcpy(buf, key.GetBuf(), cb);
}
//+---------------------------------------------------------------------------
//
// Member: CKeyBuf::CKeyBuf, public
//
// Synopsis: Assignment operator
//
// Arguments: [key] -- CKeyBuf to assign to this.
//
// History: 26-Jun-91 KyleP Created.
//
//----------------------------------------------------------------------------
#if 0 //STACKSTACK
inline CKeyBuf::CKeyBuf(const CKey& key)
{
*this = key;
}
#endif
inline void CKeyBuf::operator=( const CKey& key)
{
Win4Assert( key.Count() <= MAXKEYSIZE );
cb = key.Count();
pid = key.Pid();
memcpy(buf, key.GetBuf(), cb);
}
//+---------------------------------------------------------------------------
//
// Member: CKeyBuf::FillMax
//
// Synopsis: Makes a max key, greater or equal to any key.
//
// History: 07-May-91 BartoszM Created
//
//----------------------------------------------------------------------------
inline void CKeyBuf::FillMax ()
{
Win4Assert ( pidInvalid == 0xffffffff );
pid = pidInvalid;
cb = MAXKEYSIZE;
memset( buf, MAX_BYTE, MAXKEYSIZE);
}
inline void CKeyBuf::FillMin()
{
cb = 0;
pid = 0;
}
//+---------------------------------------------------------------------------
//
// Member: CKeyBuf::IsMaxKey
//
// Synopsis: Returns TRUE if this is the maximum possible key
//
// History: 07-May-91 BartoszM Created
//
//----------------------------------------------------------------------------
inline BOOL CKeyBuf::IsMaxKey() const
{
if (cb == MAXKEYSIZE)
{
for(unsigned n = 0; n < MAXKEYSIZE; n++)
{
if (buf[n] != MAX_BYTE)
{
return(FALSE);
}
}
return(TRUE);
}
else
return(FALSE);
}
inline BOOL CKeyBuf::IsMinKey() const
{
return ( 0 == cb ) && ( 0 == pid );
}
//+---------------------------------------------------------------------------
//
// Member: CKeyBuf::CompareStr
//
// Synopsis: Compare this with another key ignoring pid
//
// Arguments: [key] -- key to compare with
//
// Returns: "difference" this - key
//
// History: 14-Sep-92 BartoszM Created
// 15-Dec-93 w-PatG Stolen from CKey
//
//----------------------------------------------------------------------------
inline int CKeyBuf::CompareStr( const CKeyBuf & key) const
{
Win4Assert ( this != 0 );
Win4Assert ( &key != 0 );
unsigned long mincb = __min(cb, key.Count());
int diff = memcmp(buf, key.GetBuf(), mincb);
if (diff == 0)
{ // this->buf == key.buf
diff = cb - key.Count();
}
return(diff);
}
inline int CKeyBuf::Compare( const CKeyBuf & key) const
{
Win4Assert ( this != 0 );
Win4Assert ( &key != 0 );
Win4Assert ( key.Pid() != pidAll );
unsigned long mincb = __min(cb, key.Count());
int diff = memcmp(buf, key.GetBuf(), mincb);
if (diff == 0)
{ // this->buf == key.buf
diff = cb - key.Count();
if (diff == 0)
{
diff = ::Compare ( pid, key.Pid());
}
}
return(diff);
}
inline int CKeyBuf::Compare( const CKey & key) const
{
Win4Assert ( this != 0 );
Win4Assert ( &key != 0 );
Win4Assert ( key.Pid() != pidAll );
unsigned long mincb = __min(cb, key.Count());
int diff = memcmp(buf, key.GetBuf(), mincb);
if (diff == 0)
{ // this->buf == key.buf
diff = cb - key.Count();
if (diff == 0)
{
diff = ::Compare ( pid, key.Pid());
}
}
return(diff);
}
Reference in a new issue Copy permalink