/*

 **********************************************************************

 * Copyright (c) 2002-2004, International Business Machines

 * Corporation and others.  All Rights Reserved.

 **********************************************************************

 * Author: Alan Liu

 * Created: October 30 2002

 * Since: ICU 2.4

 **********************************************************************

 */

 #ifndef PROPNAME_H

 #define PROPNAME_H

 #include "unicode/utypes.h"

 #include "unicode/uchar.h"

 #include "udataswp.h"

 #include "uprops.h"

 /*

  * This header defines the in-memory layout of the property names data

  * structure representing the UCD data files PropertyAliases.txt and

  * PropertyValueAliases.txt.  It is used by:

  *   propname.cpp - reads data

  *   genpname     - creates data

  */

 /* low-level char * property name comparison -------------------------------- */

 U_CDECL_BEGIN

 /**

  * \var uprv_comparePropertyNames

  * Unicode property names and property value names are compared "loosely".

  *

  * UCD.html 4.0.1 says:

  *   For all property names, property value names, and for property values for

  *   Enumerated, Binary, or Catalog properties, use the following

  *   loose matching rule:

  *

  *   LM3. Ignore case, whitespace, underscore ('_'), and hyphens.

  *

  * This function does just that, for (char *) name strings.

  * It is almost identical to ucnv_compareNames() but also ignores

  * C0 White_Space characters (U+0009..U+000d, and U+0085 on EBCDIC).

  *

  * @internal

  */

 U_CAPI int32_t U_EXPORT2

 uprv_compareASCIIPropertyNames(const char *name1, const char *name2);

 U_CAPI int32_t U_EXPORT2

 uprv_compareEBCDICPropertyNames(const char *name1, const char *name2);

 #if U_CHARSET_FAMILY==U_ASCII_FAMILY

 #   define uprv_comparePropertyNames uprv_compareASCIIPropertyNames

 #elif U_CHARSET_FAMILY==U_EBCDIC_FAMILY

 #   define uprv_comparePropertyNames uprv_compareEBCDICPropertyNames

 #else

 #   error U_CHARSET_FAMILY is not valid

 #endif

 U_CDECL_END

 /* UDataMemory structure and signatures ------------------------------------- */

 #define PNAME_DATA_NAME "pnames"

 #define PNAME_DATA_TYPE "icu"

 /* Fields in UDataInfo: */

 /* PNAME_SIG[] is encoded as numeric literals for compatibility with the HP compiler */

 #define PNAME_SIG_0 ((uint8_t)0x70) /* p */

 #define PNAME_SIG_1 ((uint8_t)0x6E) /* n */

 #define PNAME_SIG_2 ((uint8_t)0x61) /* a */

 #define PNAME_SIG_3 ((uint8_t)0x6D) /* m */

 #define PNAME_FORMAT_VERSION ((int8_t)1) /* formatVersion[0] */

 /**

  * Swap pnames.icu. See udataswp.h.

  * @internal

  */

 U_CAPI int32_t U_EXPORT2

 upname_swap(const UDataSwapper *ds,

             const void *inData, int32_t length, void *outData,

             UErrorCode *pErrorCode);

 #ifdef XP_CPLUSPLUS

 class Builder;

 U_NAMESPACE_BEGIN

 /**

  * An offset from the start of the pnames data to a contained entity.

  * This must be a signed value, since negative offsets are used as an

  * end-of-list marker.  Offsets to actual objects are non-zero.  A

  * zero offset indicates an absent entry; this corresponds to aliases

  * marked "n/a" in the original Unicode data files.

  */

 typedef int16_t Offset; /*  must be signed */

 #define MAX_OFFSET 0x7FFF

 /**

  * A generic value for a property or property value.  Typically an

  * enum from uchar.h, but sometimes a non-enum value.  It must be

  * large enough to accomodate the largest enum value, which as of this

  * writing is the largest general category mask.  Need not be signed

  * but may be.  Typically it doesn't matter, since the caller will

  * cast it to the proper type before use.  Takes the special value

  * UCHAR_INVALID_CODE for invalid input.

  */

 typedef int32_t EnumValue;

 /* ---------------------------------------------------------------------- */

 /*  ValueMap */

 /**

  * For any top-level property that has named values (binary and

  * enumerated properties), there is a ValueMap object.  This object

  * maps from enum values to two other maps.  One goes from value enums

  * to value names.  The other goes from value names to value enums.

  * 

  * The value enum values may be contiguous or disjoint.  If they are

  * contiguous then the enumToName_offset is nonzero, and the

  * ncEnumToName_offset is zero.  Vice versa if the value enums are

  * disjoint.

  *

  * There are n of these objects, where n is the number of binary

  * properties + the number of enumerated properties.

  */

 struct ValueMap {

     /*  -- begin pnames data -- */

     /*  Enum=>name EnumToOffset / NonContiguousEnumToOffset objects. */

     /*  Exactly one of these will be nonzero. */

     Offset enumToName_offset;

     Offset ncEnumToName_offset;

     Offset nameToEnum_offset; /*  Name=>enum data */

     /*  -- end pnames data -- */

 };

 /* ---------------------------------------------------------------------- */

 /*  PropertyAliases class */

 /**

  * A class encapsulating access to the memory-mapped data representing

  * property aliases and property value aliases (pnames).  The class

  * MUST have no v-table and declares certain methods inline -- small

  * methods and methods that are called from only one point.

  *

  * The data members in this class correspond to the in-memory layout

  * of the header of the pnames data.

  */

 class PropertyAliases {

     /*  -- begin pnames data -- */

     /*  Enum=>name EnumToOffset object for binary and enumerated */

     /*  properties */

     Offset enumToName_offset;

     /*  Name=>enum data for binary & enumerated properties */

     Offset nameToEnum_offset;

     /*  Enum=>offset EnumToOffset object mapping enumerated properties */

     /*  to ValueMap objects */

     Offset enumToValue_offset;

     /*  The following are needed by external readers of this data. */

     /*  We don't use them ourselves. */

     int16_t total_size; /*  size in bytes excluding the udata header */

     Offset valueMap_offset; /*  offset to start of array */

     int16_t valueMap_count; /*  number of entries */

     Offset nameGroupPool_offset; /*  offset to start of array */

     int16_t nameGroupPool_count; /*  number of entries (not groups) */

     Offset stringPool_offset; /*  offset to start of pool */

     int16_t stringPool_count; /*  number of strings (not size in bytes) */

     /*  -- end pnames data -- */

     friend class ::Builder;

     const ValueMap* getValueMap(EnumValue prop) const;

     const char* chooseNameInGroup(Offset offset,

                                   UPropertyNameChoice choice) const;

  public:

     inline const int8_t* getPointer(Offset o) const {

         return ((const int8_t*) this) + o;

     }

     inline const int8_t* getPointerNull(Offset o) const {

         return o ? getPointer(o) : NULL;

     }

     inline const char* getPropertyName(EnumValue prop,

                                        UPropertyNameChoice choice) const;

     inline EnumValue getPropertyEnum(const char* alias) const;

     inline const char* getPropertyValueName(EnumValue prop, EnumValue value,

                                             UPropertyNameChoice choice) const;

     inline EnumValue getPropertyValueEnum(EnumValue prop,

                                           const char* alias) const;

     static int32_t

     swap(const UDataSwapper *ds,

          const uint8_t *inBytes, int32_t length, uint8_t *outBytes,

          UErrorCode *pErrorCode);

 };

 /* ---------------------------------------------------------------------- */

 /*  EnumToOffset */

 /**

  * A generic map from enum values to Offsets.  The enum values must be

  * contiguous, from enumStart to enumLimit.  The Offset values may

  * point to anything.

  */

 class EnumToOffset {

     /*  -- begin pnames data -- */

     EnumValue enumStart;

     EnumValue enumLimit;

     Offset _offsetArray; /*  [array of enumLimit-enumStart] */

     /*  -- end pnames data -- */

     friend class ::Builder;

     Offset* getOffsetArray() {

         return &_offsetArray;

     }

     const Offset* getOffsetArray() const {

         return &_offsetArray;

     }

     static int32_t getSize(int32_t n) {

         return sizeof(EnumToOffset) + sizeof(Offset) * (n - 1);

     }

     int32_t getSize() {

         return getSize(enumLimit - enumStart);

     }

  public:

     Offset getOffset(EnumValue enumProbe) const {

         if (enumProbe < enumStart ||

             enumProbe >= enumLimit) {

             return 0; /*  not found */

         }

         const Offset* p = getOffsetArray();

         return p[enumProbe - enumStart];

     }

     static int32_t

     swap(const UDataSwapper *ds,

          const uint8_t *inBytes, int32_t length, uint8_t *outBytes,

          uint8_t *temp, int32_t pos,

          UErrorCode *pErrorCode);

 };

 /* ---------------------------------------------------------------------- */

 /*  NonContiguousEnumToOffset */

 /**

  * A generic map from enum values to Offsets.  The enum values may be

  * disjoint.  If they are contiguous, an EnumToOffset should be used

  * instead.  The Offset values may point to anything.

  */

 class NonContiguousEnumToOffset {

     /*  -- begin pnames data -- */

     int32_t count;

     EnumValue _enumArray; /*  [array of count] */

     /*  Offset _offsetArray; // [array of count] after enumValue[count-1] */

     /*  -- end pnames data -- */

     friend class ::Builder;

     EnumValue* getEnumArray() {

         return &_enumArray;

     }

     const EnumValue* getEnumArray() const {

         return &_enumArray;

     }

     Offset* getOffsetArray() {

         return (Offset*) (getEnumArray() + count);

     }

     const Offset* getOffsetArray() const {

         return (Offset*) (getEnumArray() + count);

     }

     static int32_t getSize(int32_t n) {

         return sizeof(int32_t) + (sizeof(EnumValue) + sizeof(Offset)) * n;

     }

     int32_t getSize() {

         return getSize(count);

     }

  public:

     Offset getOffset(EnumValue enumProbe) const {

         const EnumValue* e = getEnumArray();

         const Offset* p = getOffsetArray();

         /*  linear search; binary later if warranted */

         /*  (binary is not faster for short lists) */

         for (int32_t i=0; i<count; ++i) {

             if (e[i] < enumProbe) continue;

             if (e[i] > enumProbe) break;

             return p[i];

         }

         return 0; /*  not found */

     }

     static int32_t

     swap(const UDataSwapper *ds,

          const uint8_t *inBytes, int32_t length, uint8_t *outBytes,

          uint8_t *temp, int32_t pos,

          UErrorCode *pErrorCode);

 };

 /* ---------------------------------------------------------------------- */

 /*  NameToEnum */

 /**

  * A map from names to enum values.

  */

 class NameToEnum {

     /*  -- begin pnames data -- */

     int32_t count;       /*  number of entries */

     EnumValue _enumArray; /*  [array of count] EnumValues */

     /*  Offset _nameArray; // [array of count] offsets to names */

     /*  -- end pnames data -- */

     friend class ::Builder;

     EnumValue* getEnumArray() {

         return &_enumArray;

     }

     const EnumValue* getEnumArray() const {

         return &_enumArray;

     }

     Offset* getNameArray() {

         return (Offset*) (getEnumArray() + count);

     }

     const Offset* getNameArray() const {

         return (Offset*) (getEnumArray() + count);

     }

     static int32_t getSize(int32_t n) {

         return sizeof(int32_t) + (sizeof(Offset) + sizeof(EnumValue)) * n;

     }

     int32_t getSize() {

         return getSize(count);

     }

  public:

     EnumValue getEnum(const char* alias, const PropertyAliases& data) const {

         const Offset* n = getNameArray();

         const EnumValue* e = getEnumArray();

         /*  linear search; binary later if warranted */

         /*  (binary is not faster for short lists) */

         for (int32_t i=0; i<count; ++i) {

             const char* name = (const char*) data.getPointer(n[i]);

             int32_t c = uprv_comparePropertyNames(alias, name);

             if (c > 0) continue;

             if (c < 0) break;

             return e[i];

         }

         return UCHAR_INVALID_CODE;

     }

     static int32_t

     swap(const UDataSwapper *ds,

          const uint8_t *inBytes, int32_t length, uint8_t *outBytes,

          uint8_t *temp, int32_t pos,

          UErrorCode *pErrorCode);

 };

 /*----------------------------------------------------------------------

  * 

  * In-memory layout.  THIS IS NOT A STANDALONE DOCUMENT.  It goes

  * together with above C++ declarations and gives an overview.

  *

  * See above for definitions of Offset and EnumValue.  Also, refer to

  * above class declarations for the "bottom line" on data layout.

  *

  * Sizes:

  * '*_offset' is an Offset (see above)

  * 'count' members are typically int32_t (see above declarations)

  * 'enumArray' is an array of EnumValue (see above)

  * 'offsetArray' is an array of Offset (see above)

  * 'nameArray' is an array of Offset (see above)

  * 'enum*' is an EnumValue (see above)

  * '*Array [x n]' means that *Array has n elements

  *

  * References:

  * Instead of pointers, this flat data structure contains offsets.

  * All offsets are relative to the start of 'header'.  A notation

  * is used to indicate what structure each offset points to:

  * 'foo (>x)' the offset(s) in foo point to structure x

  * 

  * Structures:

  * Each structure is assigned a number, except for the header,

  * which is called 'header'.  The numbers are not contiguous

  * for historical reasons.  Some structures have sub-parts

  * that are denoted with a letter, e.g., "5a".

  * 

  * BEGIN LAYOUT

  * ============

  * header:

  *  enumToName_offset (>0)

  *  nameToEnum_offset (>2)

  *  enumToValue_offset (>3)

  *  (alignment padding build in to header)

  *

  * The header also contains the following, used by "external readers"

  * like ICU4J and icuswap.

  *

  *  // The following are needed by external readers of this data.

  *  // We don't use them ourselves.

  *  int16_t total_size; // size in bytes excluding the udata header

  *  Offset valueMap_offset; // offset to start of array

  *  int16_t valueMap_count; // number of entries

  *  Offset nameGroupPool_offset; // offset to start of array

  *  int16_t nameGroupPool_count; // number of entries (not groups)

  *  Offset stringPool_offset; // offset to start of pool

  *  int16_t stringPool_count; // number of strings (not size in bytes)

  *

  * 0: # NonContiguousEnumToOffset obj for props => name groups

  *  count

  *  enumArray [x count]

  *  offsetArray [x count] (>98)

  * 

  * => pad to next 4-byte boundary

  * 

  * (1: omitted -- no longer used)

  * 

  * 2: # NameToEnum obj for binary & enumerated props

  *  count

  *  enumArray [x count]

  *  nameArray [x count] (>99)

  * 

  * => pad to next 4-byte boundary

  * 

  * 3: # NonContiguousEnumToOffset obj for enumerated props => ValueMaps

  *  count

  *  enumArray [x count]

  *  offsetArray [x count] (>4)

  * 

  * => pad to next 4-byte boundary

  * 

  * 4: # ValueMap array [x one for each enumerated prop i]

  *  enumToName_offset (>5a +2*i)   one of these two is NULL, one is not

  *  ncEnumToName_offset (>5b +2*i)

  *  nameToEnums_offset (>6 +2*i)

  * 

  * => pad to next 4-byte boundary

  * 

  * for each enumerated prop (either 5a or 5b):

  * 

  *   5a: # EnumToOffset for enumerated prop's values => name groups

  *    enumStart

  *    enumLimit

  *    offsetArray [x enumLimit - enumStart] (>98) 

  * 

  *   => pad to next 4-byte boundary

  * 

  *   5b: # NonContiguousEnumToOffset for enumerated prop's values => name groups

  *    count

  *    enumArray [x count]

  *    offsetArray [x count] (>98)

  * 

  *   => pad to next 4-byte boundary

  * 

  *   6: # NameToEnum for enumerated prop's values

  *    count

  *    enumArray [x count]

  *    nameArray [x count] (>99)

  * 

  *   => pad to next 4-byte boundary

  * 

  * 98: # name group pool {NGP}

  *  [array of Offset values] (>99)

  * 

  * 99: # string pool {SP}

  *  [pool of nul-terminated char* strings]

  */

 U_NAMESPACE_END

 #endif /* C++ */

 #endif