1290 lines
45 KiB
C++
1290 lines
45 KiB
C++
/*
|
|
* Copyright © {1996-1999}, International Business Machines Corporation and others. All Rights Reserved.
|
|
*****************************************************************************************
|
|
*/
|
|
//===============================================================================
|
|
//
|
|
// File tables.h
|
|
//
|
|
//
|
|
//
|
|
// Created by: Helena Shih
|
|
//
|
|
// Modification History:
|
|
//
|
|
// Date Name Description
|
|
// 2/5/97 aliu Added streamIn and streamOut methods to EntryPair,
|
|
// VectorOfInt, VectorOfPToExpandTable, VectorOfPToContractElement,
|
|
// VectorOfPToContractTable. These are used by TableCollation
|
|
// streamIn and streamOut methods.
|
|
// 3/5/97 aliu Made VectorOfPointersToPatternEntry::at() inline.
|
|
// 5/07/97 helena Added isBogus().
|
|
// 6/18/97 helena Added VectorOfPointer for queue-up extension list in
|
|
// MergeCollation.
|
|
// 8/18/97 helena Added internal API documentation. Note. All the VectorOfXXX
|
|
// interface is about the same. The internal API docs will be
|
|
// added to only the first version and additional description
|
|
// will be added where necessary.
|
|
// 8/04/98 erm Added fwd member to EntryPair.
|
|
//===============================================================================
|
|
|
|
#ifndef TABLES_H
|
|
#define TABLES_H
|
|
|
|
|
|
#include "filestrm.h"
|
|
#include "unicode/unistr.h"
|
|
|
|
|
|
/**
|
|
* EntryPair is used for contracting characters. Each entry pair contains the contracting
|
|
* character string and its collation order.
|
|
*/
|
|
class EntryPair
|
|
{
|
|
public:
|
|
/**
|
|
* Constructor
|
|
*/
|
|
EntryPair();
|
|
EntryPair(const UnicodeString &name, int32_t aValue, bool_t aFwd = TRUE);
|
|
|
|
UnicodeString entryName; // Contracting characters
|
|
int32_t value; // Collation order
|
|
bool_t fwd; // true if this pair is for the forward direction
|
|
|
|
/**
|
|
* The streamIn and streamOut methods read and write objects of this
|
|
* class as binary, platform-dependent data in the iostream. The stream
|
|
* must be in ios::binary mode for this to work. These methods are not
|
|
* intended for general public use; they are used by the framework to improve
|
|
* performance by storing certain objects in binary files.
|
|
*/
|
|
void streamOut(FileStream* os) const;
|
|
void streamIn(FileStream* is);
|
|
};
|
|
|
|
|
|
/**
|
|
* VectorOfInt is a dynamic array of 32-bit integers.
|
|
* Ideally we would use templates for this, but they're not supported
|
|
* on all of the platforms we need to support.
|
|
*/
|
|
class VectorOfInt {
|
|
|
|
public:
|
|
/**
|
|
* The chunk size by which the array is grown.
|
|
* This probably shouldn't be in the API
|
|
*/
|
|
enum EGrowthRate { GROWTH_RATE = 4 };
|
|
/**
|
|
* Creates a vector that contains elements of integers.
|
|
* @param initialSize the initial size of the vector object.
|
|
*/
|
|
VectorOfInt(int32_t initialSize = 0);
|
|
/**
|
|
* Copy constructor.
|
|
*/
|
|
VectorOfInt(const VectorOfInt& that);
|
|
/**
|
|
* Destructor.
|
|
*/
|
|
~VectorOfInt();
|
|
|
|
/**
|
|
* Assignment operator.
|
|
*/
|
|
const VectorOfInt& operator=(const VectorOfInt& that);
|
|
|
|
|
|
/**
|
|
* Equality operators.
|
|
*/
|
|
bool_t operator==(const VectorOfInt& that);
|
|
bool_t operator!=(const VectorOfInt& that);
|
|
|
|
/**
|
|
* Gets a read-only reference to the element at the specified index.
|
|
* This does not do range-checking; an invalid index may cause a crash.
|
|
* @return the accessed element.
|
|
*/
|
|
int32_t operator[](int32_t index) const;
|
|
int32_t at(int32_t index) const;
|
|
|
|
/**
|
|
* Gets a non-const reference to the element at the specified index.
|
|
* This does range-checking; access to elements beyond the end of the
|
|
* array will cause the array to grow.
|
|
*/
|
|
int32_t& operator[](int32_t index);
|
|
int32_t& at(int32_t index);
|
|
|
|
/**
|
|
* Sets the element at the specified index to a different value.
|
|
* @param index the specified index.
|
|
* @param value the new value.
|
|
*/
|
|
void atPut( int32_t index,
|
|
const int32_t& value);
|
|
/**
|
|
* Inserts a value at the specified index, sliding the rest of
|
|
* the elements in the array over to make room.
|
|
* @param index the specified index.
|
|
* @param value the value.
|
|
*/
|
|
void atInsert( int32_t index,
|
|
const int32_t& value);
|
|
|
|
/**
|
|
* Returns the number of elements in the vector.
|
|
* @return the size of vector.
|
|
*/
|
|
int32_t size(void) const;
|
|
|
|
/**
|
|
* Sets the size of this vector. If the new size is greater than the
|
|
* current size, new <code>0</code> items are added to the end of
|
|
* the vector. If the new size is less than the current size, all
|
|
* components at index <code>newSize</code> and greater are discarded.
|
|
* If <code>newSize</code> is negative it is treated as if it were zero.
|
|
*
|
|
* @param newSize the new size of this vector.
|
|
*/
|
|
void setSize(int32_t newSize);
|
|
|
|
/**
|
|
* Checks if this vector object is valid.
|
|
* @return TRUE if the vector object is valid, FALSE otherwise.
|
|
*/
|
|
bool_t isBogus(void) const;
|
|
|
|
/**
|
|
* The streamIn and streamOut methods read and write objects of this
|
|
* class as binary, platform-dependent data in the iostream. The stream
|
|
* must be in ios::binary mode for this to work. These methods are not
|
|
* intended for general public use; they are used by the framework to improve
|
|
* performance by storing certain objects in binary files.
|
|
*/
|
|
void streamOut(FileStream* os) const;
|
|
void streamIn(FileStream* is);
|
|
|
|
private:
|
|
/**
|
|
* Resizes the vector if necessary when compared to a new size.
|
|
* @param newSize the new size.
|
|
*/
|
|
void resize(int32_t newSize);
|
|
|
|
int32_t fSize;
|
|
int32_t fCapacity;
|
|
int32_t* fElements;
|
|
bool_t fBogus;
|
|
};
|
|
|
|
/**
|
|
* VectorOfPointer is a dynamic array of void* pointers.
|
|
* <P>
|
|
* This is a vector class that is designed to be used with pointer types and which implements
|
|
* owning semantics. That is, once a value is placed an element of the vector, the vector is
|
|
* considered to own it and is responsible for disposing it. This will happen both when the
|
|
* element is changed using atPut() or through an PointerTo****, and when the vector itself is
|
|
* disposed.
|
|
* <P>
|
|
* WARNING: The caller must be careful to avoid holding onto any dangling references
|
|
* after the vector is disposed, and the caller must also be careful not to put the same
|
|
* value into more than one element in the vector (unless the value is NULL).
|
|
* <P>
|
|
* As with VectorOf***>, the vector grows as necessary to accommodate all elements, the
|
|
* size is one plus the index of the highest element that's been set, and any elements below
|
|
* the highest element that aren't explicitly initialized are initialized to NULL.
|
|
*/
|
|
class VectorOfPointer {
|
|
public:
|
|
/**
|
|
* The chunk size by which the array is grown.
|
|
* This probably shouldn't be in the API
|
|
*/
|
|
enum EGrowthRate { GROWTH_RATE = 4 };
|
|
/**
|
|
* Creates a vector that contains elements of pointers to objects.
|
|
* @param initialSize the initial size of the vector object.
|
|
*/
|
|
VectorOfPointer(int32_t initialSize = 0);
|
|
/**
|
|
* Copy constructor.
|
|
*/
|
|
VectorOfPointer(const VectorOfPointer& that);
|
|
/**
|
|
* Destructor.
|
|
*/
|
|
~VectorOfPointer();
|
|
/**
|
|
* Assignment operator.
|
|
*/
|
|
const VectorOfPointer& operator=(const VectorOfPointer& that);
|
|
|
|
/**
|
|
* Equality operators.
|
|
*/
|
|
bool_t operator==(const VectorOfPointer& that);
|
|
bool_t operator!=(const VectorOfPointer& that);
|
|
|
|
/**
|
|
* Gets a read-only reference to the element at the specified index.
|
|
* This does not do range-checking; an invalid index may cause a crash.
|
|
* @return the accessed element.
|
|
*/
|
|
void* operator[](int32_t index) const;
|
|
void* at(int32_t index) const;
|
|
|
|
/**
|
|
* Gets a non-const reference to the element at the specified index.
|
|
* This does range-checking; access to elements beyond the end of the
|
|
* array will cause the array to grow.
|
|
*/
|
|
void*& operator[](int32_t index);
|
|
void*& at(int32_t index);
|
|
|
|
/**
|
|
* Sets the element at the specified index to a different value.
|
|
* @param index the specified index.
|
|
* @param value the new value.
|
|
*/
|
|
void atPut( int32_t index,
|
|
const void*& value);
|
|
|
|
/**
|
|
* Inserts a value at the specified index, sliding the rest of
|
|
* the elements in the array over to make room.
|
|
* @param index the specified index.
|
|
* @param value the value.
|
|
*/
|
|
void atInsert( int32_t index,
|
|
const void*& value);
|
|
/**
|
|
* Returns the number of elements in the vector.
|
|
* @return the size of vector.
|
|
*/
|
|
int32_t size(void) const;
|
|
|
|
/**
|
|
* Checks if this vector object is valid.
|
|
* @return TRUE if the vector object is valid, FALSE otherwise.
|
|
*/
|
|
bool_t isBogus(void) const;
|
|
|
|
private:
|
|
/**
|
|
* Resizes the vector if necessary when compared to a new size.
|
|
* @param newSize the new size.
|
|
*/
|
|
void resize(int32_t newSize);
|
|
|
|
int32_t fSize;
|
|
int32_t fCapacity;
|
|
void** fElements;
|
|
bool_t fBogus;
|
|
};
|
|
|
|
//=================================================================================================
|
|
// The following diagram shows the data structure of the RuleBasedCollator object.
|
|
// Suppose we have the rule, where 'o-umlaut' is the unicode char 0x00F6.
|
|
// "a, A < b, B < c, C, ch, cH, Ch, CH < d, D ... < o, O; 'o-umlaut'/E, 'O-umlaut'/E ...".
|
|
// What the rule says is, sorts 'ch'ligatures and 'c' only with tertiary difference and
|
|
// sorts 'o-umlaut' as if it's always expanded with 'e'.
|
|
//
|
|
// (VectorOfPToContractTable) (VectorOfPToExpandTable)
|
|
// mapping table contracting list expanding list
|
|
// (contains all unicode char
|
|
// entries)
|
|
// (VectorOfPToContractElement) *(PToContractElement) (PToExpandTable)
|
|
// ___ _____________ _________________________
|
|
// ________ |=====>|_*_|----->|'c' |v('c') | |==>|v('o')|v('umlaut')|v('e')|
|
|
// |_\u0001_|--> v('\u0001') | |_:_| |-------------| | |-------------------------|
|
|
// |_\u0002_|--> v('\u0002') | |_:_| |'ch' |v('ch')| | | : |
|
|
// |____:___| | |_:_| |-------------| | |-------------------------|
|
|
// |____:___| | |'cH' |v('cH')| | | : |
|
|
// |__'a'___|--> v('a') | |-------------| | |-------------------------|
|
|
// |__'b'___|--> v('b') | |'Ch' |v('Ch')| | | : |
|
|
// |____:___| | |-------------| | |-------------------------|
|
|
// |____:___| | |'CH' |v('CH')| | | : |
|
|
// |__'ch'__|------------------- ------------- | |-------------------------|
|
|
// |____:___| | | : |
|
|
// |o-umlaut|------------------------------------------------------ |_________________________|
|
|
// |____:___|
|
|
//
|
|
//
|
|
// Noted by Helena Shih on 6/23/97 with pending design changes (slimming collation).
|
|
//=================================================================================================
|
|
|
|
class VectorOfPToExpandTable;
|
|
|
|
/**
|
|
* PToExpandTable is a smart-pointer to a VectorOfInt that is used to store
|
|
* the collation orders that are the result of an expansion.
|
|
* <P>
|
|
* You can use this object as if it were a pointer to a VectorOfInt, e.g.
|
|
* <pre>
|
|
* PToExpandTable foo = ....;
|
|
* foo->atInsert(....);
|
|
* </pre>
|
|
*/
|
|
class PToExpandTable {
|
|
public:
|
|
|
|
/**
|
|
* Destructor.
|
|
*/
|
|
~PToExpandTable();
|
|
|
|
/**
|
|
* Assignment operators
|
|
* The expand table that this object already points to (if any) is deleted.
|
|
*/
|
|
const PToExpandTable& operator=(VectorOfInt* newValue);
|
|
const PToExpandTable& operator=(const PToExpandTable& pointerToNewValue);
|
|
|
|
/**
|
|
* Pointer operator override
|
|
*/
|
|
operator VectorOfInt*() const;
|
|
|
|
private:
|
|
/**
|
|
* Constructor
|
|
*/
|
|
PToExpandTable(VectorOfInt*& value);
|
|
/**
|
|
* Copy constructor.
|
|
*/
|
|
PToExpandTable(const PToExpandTable& that);
|
|
|
|
VectorOfInt*& fValue;
|
|
|
|
friend class VectorOfPToExpandTable;
|
|
};
|
|
|
|
/**
|
|
* VectorOfPointer is a dynamic array of PToExpandTable objects
|
|
* which in turn point to the array of collation orders for each expanding character.
|
|
* <P>
|
|
* This is a vector class that is designed to be used with pointer types and which implements
|
|
* owning semantics. That is, once a value is placed an element of the vector, the vector is
|
|
* considered to own it and is responsible for disposing it. This will happen both when the
|
|
* element is changed using atPut() or through an PointerTo****, and when the vector itself is
|
|
* disposed.
|
|
* <P>
|
|
* WARNING: The caller must be careful to avoid holding onto any dangling references
|
|
* after the vector is disposed, and the caller must also be careful not to put the same
|
|
* value into more than one element in the vector (unless the value is NULL).
|
|
* <P>
|
|
* As with VectorOf***>, the vector grows as necessary to accommodate all elements, the
|
|
* size is one plus the index of the highest element that's been set, and any elements below
|
|
* the highest element that aren't explicitly initialized are initialized to NULL.
|
|
*/
|
|
class VectorOfPToExpandTable {
|
|
public:
|
|
|
|
/**
|
|
* The chunk size by which the array is grown.
|
|
* This probably shouldn't be in the API
|
|
*/
|
|
enum EGrowthRate { GROWTH_RATE = 4 };
|
|
/**
|
|
* Creates a vector that contains elements of PToExpandTable.
|
|
* @param initialSize the initial size of the vector object.
|
|
*/
|
|
VectorOfPToExpandTable(int32_t initialSize = 0);
|
|
/**
|
|
* Copy constructor.
|
|
*/
|
|
VectorOfPToExpandTable(const VectorOfPToExpandTable& that);
|
|
|
|
/**
|
|
* Destructor.
|
|
*/
|
|
~VectorOfPToExpandTable();
|
|
|
|
/**
|
|
* Assignment operator.
|
|
*/
|
|
const VectorOfPToExpandTable&
|
|
operator=(const VectorOfPToExpandTable& that);
|
|
|
|
/**
|
|
* Return a modifiable smart-pointer to the expansion table
|
|
* at the given index. Assigning to this smart pointer will work, e.g.
|
|
* VectorOfPToExpandTable foo = ....;
|
|
* foo[5] = new VectorOfInt ...;
|
|
* This does range-checking; access to elements beyond the end of the
|
|
* array will cause the array to grow.
|
|
*/
|
|
PToExpandTable at(int32_t index);
|
|
PToExpandTable operator[](int32_t index);
|
|
|
|
/**
|
|
* Return a pointer to the table at the given index.
|
|
* The pointer itself cannot be modified, but the elements it points to may:
|
|
* <pre>
|
|
* const VectorOfPToExpandTable foo = ....;
|
|
* foo[5] = ....; // NOT ALLOWED
|
|
* foo[5][0] = 12345; // ok
|
|
* </pre>
|
|
* This does not do range-checking; an invalid index may cause a crash.
|
|
* @return the accessed element.
|
|
*/
|
|
VectorOfInt* at(int32_t index) const;
|
|
VectorOfInt* operator[](int32_t index) const;
|
|
|
|
/**
|
|
* Sets the element at the specified index to a different value.
|
|
* If there was aready an object stored at this index, it is deleted.
|
|
* @param index the specified index.
|
|
* @param value the new value.
|
|
*/
|
|
void atPut( int32_t index,
|
|
VectorOfInt* value);
|
|
|
|
/**
|
|
* "Orphan" the pointer at the specified index. The array will no
|
|
* longer contain a reference to the object, and the caller is
|
|
* now responsible for deleting its storage.
|
|
*/
|
|
VectorOfInt* orphanAt(int32_t index);
|
|
|
|
/**
|
|
* Returns the number of elements in the vector.
|
|
* @return the size of vector.
|
|
*/
|
|
int32_t size(void) const;
|
|
|
|
/**
|
|
* Checks if this vector object is valid.
|
|
* @return TRUE if the vector object is valid, FALSE otherwise.
|
|
*/
|
|
bool_t isBogus(void) const;
|
|
|
|
/**
|
|
* The streamIn and streamOut methods read and write objects of this
|
|
* class as binary, platform-dependent data in the iostream. The stream
|
|
* must be in ios::binary mode for this to work. These methods are not
|
|
* intended for general public use; they are used by the framework to improve
|
|
* performance by storing certain objects in binary files.
|
|
*/
|
|
void streamOut(FileStream* os) const;
|
|
void streamIn(FileStream* is);
|
|
|
|
private:
|
|
/**
|
|
* Resizes the vector if necessary when compared to a new size.
|
|
* @param newSize the new size.
|
|
*/
|
|
void resize(int32_t newSize);
|
|
|
|
int32_t fSize;
|
|
int32_t fCapacity;
|
|
VectorOfInt** fElements;
|
|
bool_t fBogus;
|
|
};
|
|
|
|
class VectorOfPToContractElement;
|
|
|
|
/**
|
|
* PToContractElement is a smart-pointer to an array that is used to store
|
|
* the contracting-character strings that are associated with a given Unicode character.
|
|
* <P>
|
|
* You can use this object as if it were a pointer to an EntryPair array, e.g.
|
|
* <pre>
|
|
* PToContractElement foo = ....;
|
|
* foo->entryName = ....;
|
|
* </pre>
|
|
*/
|
|
class PToContractElement {
|
|
public:
|
|
/**
|
|
* Destructor.
|
|
*/
|
|
~PToContractElement();
|
|
|
|
/**
|
|
* Assignment operators
|
|
* The EntryPair that this object already points to (if any) is deleted.
|
|
*/
|
|
const PToContractElement& operator=(EntryPair* newValue);
|
|
const PToContractElement& operator=(const PToContractElement& pointerToNewValue);
|
|
|
|
/**
|
|
* Pointer operator override
|
|
*/
|
|
operator EntryPair*() const;
|
|
|
|
private:
|
|
/**
|
|
* Constructor
|
|
*/
|
|
PToContractElement(EntryPair*& value);
|
|
/**
|
|
* Copy constructor.
|
|
*/
|
|
PToContractElement(const PToContractElement& that);
|
|
|
|
EntryPair*& fValue;
|
|
|
|
friend class VectorOfPToContractElement;
|
|
};
|
|
|
|
/**
|
|
* The table that contains the list of contracting character entries.
|
|
* <P>
|
|
* This is a vector class that is designed to be used with pointer types and which implements
|
|
* owning semantics. That is, once a value is placed an element of the vector, the vector is
|
|
* considered to own it and is responsible for disposing it. This will happen both when the
|
|
* element is changed using atPut() or through an PointerTo****, and when the vector itself is
|
|
* disposed.
|
|
* <P>
|
|
* WARNING: The caller must be careful to avoid holding onto any dangling references
|
|
* after the vector is disposed, and the caller must also be careful not to put the same
|
|
* value into more than one element in the vector (unless the value is NULL).
|
|
* <P>
|
|
* As with VectorOf***>, the vector grows as necessary to accommodate all elements, the
|
|
* size is one plus the index of the highest element that's been set, and any elements below
|
|
* the highest element that aren't explicitly initialized are initialized to NULL.
|
|
*/
|
|
class VectorOfPToContractElement {
|
|
public:
|
|
/**
|
|
* The chunk size by which the array is grown.
|
|
* This probably shouldn't be in the API
|
|
*/
|
|
enum EGrowthRate { GROWTH_RATE = 4 };
|
|
/**
|
|
* Creates a vector that contains elements of PToContractElement.
|
|
* @param initialSize the initial size of the vector object.
|
|
*/
|
|
VectorOfPToContractElement(int32_t initialSize = 0);
|
|
/**
|
|
* Copy constructor.
|
|
*/
|
|
VectorOfPToContractElement(const VectorOfPToContractElement& that);
|
|
|
|
/**
|
|
* Destructor.
|
|
*/
|
|
~VectorOfPToContractElement();
|
|
|
|
/**
|
|
* Assignment operator.
|
|
*/
|
|
const VectorOfPToContractElement&
|
|
operator=(const VectorOfPToContractElement& that);
|
|
|
|
/**
|
|
* Return a modifiable smart-pointer to the EntryPair
|
|
* at the given index. Assigning to this smart pointer will work, e.g.
|
|
* <pre>
|
|
* PToContractElement foo = ....;
|
|
* foo[5] = ...;
|
|
* </pre>
|
|
* This does range-checking; access to elements beyond the end of the
|
|
* array will cause the array to grow.
|
|
*/
|
|
PToContractElement operator[](int32_t index);
|
|
PToContractElement at(int32_t index);
|
|
|
|
/**
|
|
* Return a pointer to the EntryPair at the given index.
|
|
* The pointer itself cannot be modified, but the elements it points to may:
|
|
* <pre>
|
|
* const VectorOfPToExpandTable foo = ....;
|
|
* foo[5] = ....; // NOT ALLOWED
|
|
* foo[5]->entryName = ....; // ok
|
|
* </pre>
|
|
* This does not do range-checking; an invalid index may cause a crash.
|
|
* @return the accessed element.
|
|
*/
|
|
EntryPair* operator[](int32_t index) const;
|
|
EntryPair* at(int32_t index) const;
|
|
|
|
/**
|
|
* Sets the element at the specified index to a different value.
|
|
* If there was aready an object stored at this index, it is deleted.
|
|
* @param index the specified index.
|
|
* @param value the new value.
|
|
*/
|
|
void atPut( int32_t index,
|
|
EntryPair* value);
|
|
/**
|
|
* Inserts a value at the specified index, sliding the rest of
|
|
* the elements in the array over to make room.
|
|
* @param index the specified index.
|
|
* @param value the value.
|
|
*/
|
|
void atInsert( int32_t index,
|
|
EntryPair* value);
|
|
/**
|
|
* "Orphan" the pointer at the specified index. The array will no
|
|
* longer contain a reference to the object, and the caller is
|
|
* now responsible for deleting its storage.
|
|
*/
|
|
EntryPair* orphanAt(int32_t index);
|
|
|
|
/**
|
|
* Returns the number of elements in the vector.
|
|
* @return the size of vector.
|
|
*/
|
|
int32_t size(void) const;
|
|
|
|
/**
|
|
* Checks if this vector object is valid.
|
|
* @return TRUE if the vector object is valid, FALSE otherwise.
|
|
*/
|
|
bool_t isBogus(void) const;
|
|
|
|
/**
|
|
* The streamIn and streamOut methods read and write objects of this
|
|
* class as binary, platform-dependent data in the iostream. The stream
|
|
* must be in ios::binary mode for this to work. These methods are not
|
|
* intended for general public use; they are used by the framework to improve
|
|
* performance by storing certain objects in binary files.
|
|
*/
|
|
void streamOut(FileStream* os) const;
|
|
void streamIn(FileStream* is);
|
|
|
|
private:
|
|
/**
|
|
* Resizes the vector if necessary when compared to a new size.
|
|
* @param newSize the new size.
|
|
*/
|
|
void resize(int32_t newSize);
|
|
|
|
int32_t fSize;
|
|
int32_t fCapacity;
|
|
EntryPair** fElements;
|
|
bool_t fBogus;
|
|
};
|
|
|
|
class VectorOfPToContractTable;
|
|
|
|
/**
|
|
* Pointer to each contracing element list.
|
|
*/
|
|
class PToContractTable {
|
|
public:
|
|
/**
|
|
* Destructor.
|
|
*/
|
|
~PToContractTable();
|
|
|
|
/**
|
|
* Assignment operators.
|
|
* <P>
|
|
* The contracting element list (if any) that this object already points to
|
|
* is deleted.
|
|
*/
|
|
const PToContractTable& operator=(VectorOfPToContractElement* newValue);
|
|
const PToContractTable& operator=(const PToContractTable& pointerToNewValue);
|
|
|
|
/**
|
|
* Pointer operator override
|
|
*/
|
|
operator VectorOfPToContractElement*() const;
|
|
|
|
private:
|
|
/**
|
|
* Constructor
|
|
*/
|
|
PToContractTable(VectorOfPToContractElement*& value);
|
|
/**
|
|
* Copy constructor.
|
|
*/
|
|
PToContractTable(const PToContractTable& that);
|
|
|
|
VectorOfPToContractElement*& fValue;
|
|
|
|
friend class VectorOfPToContractTable;
|
|
};
|
|
|
|
/**
|
|
* The vector that contains all contracting list tables.
|
|
* <P>
|
|
* This is a vector class that is designed to be used with pointer types and which implements
|
|
* owning semantics. That is, once a value is placed an element of the vector, the vector is
|
|
* considered to own it and is responsible for disposing it. This will happen both when the
|
|
* element is changed using atPut() or through an PointerTo****, and when the vector itself is
|
|
* disposed.
|
|
* <P>
|
|
* WARNING: The caller must be careful to avoid holding onto any dangling references
|
|
* after the vector is disposed, and the caller must also be careful not to put the same
|
|
* value into more than one element in the vector (unless the value is NULL).
|
|
* <P>
|
|
* As with VectorOf***>, the vector grows as necessary to accommodate all elements, the
|
|
* size is one plus the index of the highest element that's been set, and any elements below
|
|
* the highest element that aren't explicitly initialized are initialized to NULL.
|
|
*/
|
|
class VectorOfPToContractTable {
|
|
public:
|
|
/**
|
|
* The chunk size by which the array is grown.
|
|
* This probably shouldn't be in the API
|
|
*/
|
|
enum EGrowthRate { GROWTH_RATE = 4 };
|
|
/**
|
|
* Creates a vector that contains elements of PToContractTable.
|
|
* @param initialSize the initial size of the vector object.
|
|
*/
|
|
VectorOfPToContractTable(int32_t initialSize = 0);
|
|
/**
|
|
* Copy constructor.
|
|
*/
|
|
VectorOfPToContractTable(const VectorOfPToContractTable& that);
|
|
|
|
~VectorOfPToContractTable();
|
|
|
|
/**
|
|
* Assignment operator.
|
|
*/
|
|
const VectorOfPToContractTable&
|
|
operator=(const VectorOfPToContractTable& that);
|
|
|
|
/**
|
|
* Return a modifiable smart-pointer to the contraction table
|
|
* at the given index. Assigning to this smart pointer will work, e.g.
|
|
* <pre>
|
|
* VectorOfPToContractTable foo = ....;
|
|
* foo[5] = ...;
|
|
* </pre>
|
|
* This does range-checking; access to elements beyond the end of the
|
|
* array will cause the array to grow.
|
|
*/
|
|
PToContractTable operator[](int32_t index);
|
|
PToContractTable at(int32_t index);
|
|
|
|
/**
|
|
* Return a pointer to the contraction table at the given index.
|
|
* The pointer itself cannot be modified, but the elements it points to may:
|
|
* <pre>
|
|
* const VectorOfPToExpandTable foo = ....;
|
|
* foo[5] = ....; // NOT ALLOWED
|
|
* foo[5][0] = ....; // ok
|
|
* </pre>
|
|
* This does not do range-checking; an invalid index may cause a crash.
|
|
* @return the accessed element.
|
|
*/
|
|
VectorOfPToContractElement* operator[](int32_t index) const;
|
|
VectorOfPToContractElement* at(int32_t index) const;
|
|
|
|
/**
|
|
* Sets the element at the specified index to a different value.
|
|
* If there was aready an object stored at this index, it is deleted.
|
|
* @param index the specified index.
|
|
* @param value the new value.
|
|
*/
|
|
void atPut( int32_t index,
|
|
VectorOfPToContractElement* value);
|
|
/**
|
|
* "Orphan" the pointer at the specified index. The array will no
|
|
* longer contain a reference to the object, and the caller is
|
|
* now responsible for deleting its storage.
|
|
*/
|
|
VectorOfPToContractElement* orphanAt(int32_t index);
|
|
|
|
/**
|
|
* Returns the number of elements in the vector.
|
|
* @return the size of vector.
|
|
*/
|
|
int32_t size(void) const;
|
|
|
|
/**
|
|
* Checks if this vector object is valid.
|
|
* @return TRUE if the vector object is valid, FALSE otherwise.
|
|
*/
|
|
bool_t isBogus(void) const;
|
|
/**
|
|
* The streamIn and streamOut methods read and write objects of this
|
|
* class as binary, platform-dependent data in the iostream. The stream
|
|
* must be in ios::binary mode for this to work. These methods are not
|
|
* intended for general public use; they are used by the framework to improve
|
|
* performance by storing certain objects in binary files.
|
|
*/
|
|
void streamOut(FileStream* os) const;
|
|
void streamIn(FileStream* is);
|
|
|
|
private:
|
|
/**
|
|
* Resizes the vector if necessary when compared to a new size.
|
|
* @param newSize the new size.
|
|
*/
|
|
void resize(int32_t newSize);
|
|
|
|
int32_t fSize;
|
|
int32_t fCapacity;
|
|
VectorOfPToContractElement** fElements;
|
|
bool_t fBogus;
|
|
};
|
|
|
|
class PatternEntry;
|
|
class VectorOfPointersToPatternEntry;
|
|
|
|
/**
|
|
* Proxy class for accessing elements of a VectorOfPointersToPatternEntry
|
|
* <P>
|
|
* This class is a simple proxy class that implements the owning semantics for the
|
|
* operator[] and at() functions on VectorOfPointersToPatternEntry. It enables
|
|
* expressions like "v[3] = someNewValue". One never creates a PointerToPatternEntry
|
|
* directly, and one never declares variables of this type. It just exists to
|
|
* implement the API of VectorOfPointersToPatternEntry.
|
|
*/
|
|
|
|
class PointerToPatternEntry {
|
|
public:
|
|
/**
|
|
* Destructor.
|
|
*/
|
|
~PointerToPatternEntry();
|
|
|
|
/**
|
|
* Assignment operators
|
|
* The PatternEntry that this object already points to (if any) is deleted.
|
|
*/
|
|
const PointerToPatternEntry& operator=(PatternEntry* newValue);
|
|
const PointerToPatternEntry& operator=(const PointerToPatternEntry& pointerToNewValue);
|
|
|
|
/**
|
|
* Pointer operator override
|
|
*/
|
|
operator PatternEntry*() const;
|
|
|
|
private:
|
|
/**
|
|
* Constructor
|
|
*/
|
|
PointerToPatternEntry(PatternEntry*& value);
|
|
/**
|
|
* Copy constructor.
|
|
*/
|
|
PointerToPatternEntry(const PointerToPatternEntry& that);
|
|
|
|
PatternEntry*& fValue;
|
|
|
|
friend class VectorOfPointersToPatternEntry;
|
|
};
|
|
|
|
/**
|
|
* Simple owning-vector class
|
|
* This is a vector class that is designed to be used with pointer types and which implements
|
|
* owning semantics. That is, once a value is placed an element of the vector, the vector is
|
|
* considered to own it and is responsible for disposing it. This will happen both when the
|
|
* element is changed using atPut() or through an PointerTo****, and when the vector itself is
|
|
* disposed.
|
|
* <P>
|
|
* WARNING: The caller must be careful to avoid holding onto any dangling references
|
|
* after the vector is disposed, and the caller must also be careful not to put the same
|
|
* value into more than one element in the vector (unless the value is NULL).
|
|
* <P>
|
|
* As with VectorOf***>, the vector grows as necessary to accommodate all elements, the
|
|
* size is one plus the index of the highest element that's been set, and any elements below
|
|
* the highest element that aren't explicitly initialized are initialized to NULL.
|
|
*/
|
|
|
|
class VectorOfPointersToPatternEntry {
|
|
public:
|
|
/**
|
|
* The chunk size by which the array is grown.
|
|
* This probably shouldn't be in the API
|
|
*/
|
|
enum EGrowthRate { GROWTH_RATE = 4 };
|
|
/**
|
|
* Creates a vector that contains elements of PointerToPatternEntry.
|
|
* @param initialSize the initial size of the vector object.
|
|
*/
|
|
VectorOfPointersToPatternEntry(int32_t initialSize = 0);
|
|
/**
|
|
* Copy constructor.
|
|
*/
|
|
VectorOfPointersToPatternEntry(const VectorOfPointersToPatternEntry& that);
|
|
|
|
/**
|
|
* Destructor.
|
|
*/
|
|
~VectorOfPointersToPatternEntry();
|
|
|
|
/**
|
|
* Assignment operator.
|
|
*/
|
|
const VectorOfPointersToPatternEntry& operator=(const VectorOfPointersToPatternEntry& that);
|
|
|
|
/**
|
|
* Return a modifiable smart-pointer to the contraction table
|
|
* at the given index. Assigning to this smart pointer will work, e.g.
|
|
* <pre>
|
|
* VectorOfPointersToPatternEntry foo = ....;
|
|
* foo[5] = ...;
|
|
* </pre>
|
|
* This does range-checking; access to elements beyond the end of the
|
|
* array will cause the array to grow.
|
|
*/
|
|
PointerToPatternEntry operator[](int32_t index);
|
|
inline PointerToPatternEntry at(int32_t index) { return (*this)[index]; }
|
|
|
|
/**
|
|
* Return a pointer to the EntryPair at the given index.
|
|
* The pointer itself cannot be modified, but the elements it points to may:
|
|
* <pre>
|
|
* const VectorOfPointersToPatternEntryfoo = ....;
|
|
* foo[5] = ....; // NOT ALLOWED
|
|
* foo[5]->getStrength(); // ok
|
|
* </pre>
|
|
* This does not do range-checking; an invalid index may cause a crash.
|
|
* @return the accessed element.
|
|
*/
|
|
PatternEntry* operator[](int32_t index) const;
|
|
inline PatternEntry* at(int32_t index) const { return (*this)[index]; }
|
|
|
|
/**
|
|
* Sets the element at the specified index to a different value.
|
|
* If there was aready an object stored at this index, it is deleted.
|
|
* @param index the specified index.
|
|
* @param value the new value.
|
|
*/
|
|
void atPut( int32_t index,
|
|
PatternEntry* value);
|
|
/**
|
|
* Inserts a value at the specified index, sliding the rest of
|
|
* the elements in the array over to make room.
|
|
* @param index the specified index.
|
|
* @param value the value.
|
|
*/
|
|
void atInsert( int32_t index,
|
|
PatternEntry* value);
|
|
/**
|
|
* "Orphan" the pointer at the specified index. The array will no
|
|
* longer contain a reference to the object, and the caller is
|
|
* now responsible for deleting its storage.
|
|
*/
|
|
PatternEntry* orphanAt(int32_t index);
|
|
|
|
/**
|
|
* Remove all elements from the vector.
|
|
*/
|
|
void clear(void);
|
|
|
|
/**
|
|
* Returns the number of elements in the vector.
|
|
* @return the size of vector.
|
|
*/
|
|
int32_t size(void) const;
|
|
|
|
/**
|
|
* If the specified value exists in the vector, return its index.
|
|
* If not, return -1.
|
|
*/
|
|
int32_t indexOf(const PatternEntry* value) const;
|
|
|
|
/**
|
|
* Return the index of the last occurance of value in the vector,
|
|
* or -1 if the vector doesn't contain value.
|
|
*/
|
|
int32_t lastIndexOf(const PatternEntry* value) const;
|
|
|
|
/**
|
|
* Checks if this vector object is valid.
|
|
* @return TRUE if the vector object is valid, FALSE otherwise.
|
|
*/
|
|
bool_t isBogus(void) const;
|
|
private:
|
|
/**
|
|
* Resizes the vector if necessary when compared to a new size.
|
|
* @param newSize the new size.
|
|
*/
|
|
void resize(int32_t newSize);
|
|
|
|
int32_t fSize;
|
|
int32_t fCapacity;
|
|
PatternEntry** fElements;
|
|
bool_t fBogus;
|
|
};
|
|
|
|
inline
|
|
EntryPair::EntryPair()
|
|
: entryName(), value(0xffffffff), fwd(TRUE)
|
|
{
|
|
}
|
|
|
|
inline
|
|
EntryPair::EntryPair(const UnicodeString &name, int32_t aValue, bool_t aFwd)
|
|
: entryName(name), value(aValue), fwd(aFwd)
|
|
{
|
|
}
|
|
|
|
//=======================================================================================
|
|
// METHODS ON VectorOfInt
|
|
//=======================================================================================
|
|
|
|
inline int32_t
|
|
VectorOfInt::operator[](int32_t index) const
|
|
{
|
|
return (index < fCapacity) ? fElements[index] : 0;
|
|
}
|
|
|
|
|
|
inline int32_t
|
|
VectorOfInt::at(int32_t index) const
|
|
{
|
|
return (*this)[index];
|
|
}
|
|
|
|
inline int32_t&
|
|
VectorOfInt::at(int32_t index)
|
|
{
|
|
return (*this)[index];
|
|
}
|
|
|
|
inline int32_t
|
|
VectorOfInt::size() const
|
|
{
|
|
return fSize;
|
|
}
|
|
|
|
//=======================================================================================
|
|
// METHODS ON VectorOfPointer
|
|
//=======================================================================================
|
|
|
|
inline void*
|
|
VectorOfPointer::operator[](int32_t index) const
|
|
{
|
|
return (index < fCapacity) ? fElements[index] : 0;
|
|
}
|
|
|
|
|
|
inline void*
|
|
VectorOfPointer::at(int32_t index) const
|
|
{
|
|
return (*this)[index];
|
|
}
|
|
|
|
inline void*&
|
|
VectorOfPointer::at(int32_t index)
|
|
{
|
|
return (*this)[index];
|
|
}
|
|
|
|
inline int32_t
|
|
VectorOfPointer::size() const
|
|
{
|
|
return fSize;
|
|
}
|
|
//=======================================================================================
|
|
// METHODS ON PToExpandTable
|
|
//=======================================================================================
|
|
|
|
inline
|
|
PToExpandTable::operator VectorOfInt*() const
|
|
{
|
|
return fValue;
|
|
}
|
|
|
|
inline
|
|
PToExpandTable::PToExpandTable(VectorOfInt*& value)
|
|
: fValue(value)
|
|
{
|
|
}
|
|
|
|
inline
|
|
PToExpandTable::PToExpandTable(const PToExpandTable& that)
|
|
: fValue(that.fValue)
|
|
{
|
|
}
|
|
|
|
inline
|
|
PToExpandTable::~PToExpandTable()
|
|
{
|
|
}
|
|
|
|
inline const PToExpandTable&
|
|
PToExpandTable::operator=(VectorOfInt* newValue)
|
|
{
|
|
delete fValue;
|
|
fValue = newValue;
|
|
return *this;
|
|
}
|
|
|
|
inline const PToExpandTable&
|
|
PToExpandTable::operator=(const PToExpandTable& pointerToNewValue)
|
|
{
|
|
delete fValue;
|
|
fValue = (VectorOfInt*)(pointerToNewValue);
|
|
return *this;
|
|
}
|
|
|
|
//=======================================================================================
|
|
// METHODS ON VectorOfPToExpandTable
|
|
//=======================================================================================
|
|
inline VectorOfInt*
|
|
VectorOfPToExpandTable::operator[](int32_t index) const
|
|
{
|
|
return (index < fCapacity) ? fElements[index] : 0;
|
|
}
|
|
|
|
inline VectorOfInt*
|
|
VectorOfPToExpandTable::at(int32_t index) const
|
|
{
|
|
return (*this)[index];
|
|
}
|
|
|
|
inline PToExpandTable
|
|
VectorOfPToExpandTable::at(int32_t index)
|
|
{
|
|
return (*this)[index];
|
|
}
|
|
|
|
inline int32_t
|
|
VectorOfPToExpandTable::size() const
|
|
{
|
|
return fSize;
|
|
}
|
|
|
|
//=======================================================================================
|
|
// METHODS ON PToContractElement
|
|
//=======================================================================================
|
|
|
|
inline
|
|
PToContractElement::operator EntryPair*() const
|
|
{
|
|
return fValue;
|
|
}
|
|
|
|
inline
|
|
PToContractElement::PToContractElement(EntryPair*& value)
|
|
: fValue(value)
|
|
{
|
|
}
|
|
|
|
inline
|
|
PToContractElement::PToContractElement(const PToContractElement& that)
|
|
: fValue(that.fValue)
|
|
{
|
|
}
|
|
|
|
inline
|
|
PToContractElement::~PToContractElement()
|
|
{
|
|
}
|
|
|
|
inline const PToContractElement&
|
|
PToContractElement::operator=(EntryPair* newValue)
|
|
{
|
|
delete fValue;
|
|
fValue = newValue;
|
|
return *this;
|
|
}
|
|
|
|
inline const PToContractElement&
|
|
PToContractElement::operator=(const PToContractElement& pointerToNewValue)
|
|
{
|
|
delete fValue;
|
|
fValue = (EntryPair*)(pointerToNewValue);
|
|
return *this;
|
|
}
|
|
|
|
//=======================================================================================
|
|
// METHODS ON VectorOfPToContractElement
|
|
//=======================================================================================
|
|
|
|
inline EntryPair*
|
|
VectorOfPToContractElement::operator[](int32_t index) const
|
|
{
|
|
return (index < fCapacity) ? fElements[index] : 0;
|
|
}
|
|
|
|
inline EntryPair*
|
|
VectorOfPToContractElement::at(int32_t index) const
|
|
{
|
|
return (*this)[index];
|
|
}
|
|
|
|
inline PToContractElement
|
|
VectorOfPToContractElement::at(int32_t index)
|
|
{
|
|
return (*this)[index];
|
|
}
|
|
|
|
inline int32_t
|
|
VectorOfPToContractElement::size() const
|
|
{
|
|
return fSize;
|
|
}
|
|
|
|
//=======================================================================================
|
|
// METHODS ON PToContractTable
|
|
//=======================================================================================
|
|
|
|
inline
|
|
PToContractTable::operator VectorOfPToContractElement*() const
|
|
{
|
|
return fValue;
|
|
}
|
|
|
|
inline
|
|
PToContractTable::PToContractTable(VectorOfPToContractElement*& value)
|
|
: fValue(value)
|
|
{
|
|
}
|
|
|
|
inline
|
|
PToContractTable::PToContractTable(const PToContractTable& that)
|
|
: fValue(that.fValue)
|
|
{
|
|
}
|
|
|
|
inline
|
|
PToContractTable::~PToContractTable()
|
|
{
|
|
}
|
|
|
|
inline const PToContractTable&
|
|
PToContractTable::operator=(VectorOfPToContractElement* newValue)
|
|
{
|
|
delete fValue;
|
|
fValue = newValue;
|
|
return *this;
|
|
}
|
|
|
|
inline const PToContractTable&
|
|
PToContractTable::operator=(const PToContractTable& pointerToNewValue)
|
|
{
|
|
delete fValue;
|
|
fValue = (VectorOfPToContractElement*)(pointerToNewValue);
|
|
return *this;
|
|
}
|
|
|
|
//=======================================================================================
|
|
// METHODS ON VectorOfPToContractTable
|
|
//=======================================================================================
|
|
|
|
inline VectorOfPToContractElement*
|
|
VectorOfPToContractTable::operator[](int32_t index) const
|
|
{
|
|
return (index < fCapacity) ? fElements[index] : 0;
|
|
}
|
|
|
|
inline VectorOfPToContractElement*
|
|
VectorOfPToContractTable::at(int32_t index) const
|
|
{
|
|
return (*this)[index];
|
|
}
|
|
|
|
inline PToContractTable
|
|
VectorOfPToContractTable::at(int32_t index)
|
|
{
|
|
return (*this)[index];
|
|
}
|
|
|
|
inline int32_t
|
|
VectorOfPToContractTable::size() const
|
|
{
|
|
return fSize;
|
|
}
|
|
|
|
#endif
|