/*
**********************************************************************
* Copyright (c) 2002, 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 "uprops.h"

class Builder;

U_NAMESPACE_BEGIN

// 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

//----------------------------------------------------------------------
// 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] */

/**
 * 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;
};

//----------------------------------------------------------------------
// 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);
    }

 public:

    Offset getOffset(EnumValue enumProbe) const {
        if (enumProbe < enumStart ||
            enumProbe >= enumLimit) {
            return 0; // not found
        }
        const Offset* p = getOffsetArray();
        return p[enumProbe - enumStart];
    }
};

//----------------------------------------------------------------------
// 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;
    }

 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
    }
};

//----------------------------------------------------------------------
// 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;
    }

 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;
    }
};

/*----------------------------------------------------------------------
 * 
 * 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)
 * 
 * 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

//eof
