RunArrays.h

Go to the documentation of this file.

// © 2016 and later: Unicode, Inc. and others.
// License & terms of use: http://www.unicode.org/copyright.html
/*
 **********************************************************************
 *   Copyright (C) 2003-2008, International Business Machines
 *   Corporation and others.  All Rights Reserved.
 **********************************************************************
 */
 
#ifndef __RUNARRAYS_H
 
#define __RUNARRAYS_H
 
#include "layout/LETypes.h"
#include "layout/LEFontInstance.h"
 
#include "unicode/utypes.h"
#include "unicode/locid.h"
 
U_NAMESPACE_BEGIN
 
#define INITIAL_CAPACITY 16
 
#define CAPACITY_GROW_LIMIT 128
 
class U_LAYOUTEX_API RunArray : public UObject
{
public:
    inline RunArray(const le_int32 *limits, le_int32 count);
 
    RunArray(le_int32 initialCapacity);
 
    virtual ~RunArray();
 
    inline le_int32 getCount() const;
 
    inline void reset();
 
    inline le_int32 getLimit() const;
 
    inline le_int32 getLimit(le_int32 run) const;
 
    le_int32 add(le_int32 limit);
 
    static inline UClassID getStaticClassID() { return (UClassID)&fgClassID; }
 
    inline UClassID getDynamicClassID() const override { return getStaticClassID(); }
 
protected:
    virtual void init(le_int32 capacity);
 
    virtual void grow(le_int32 capacity);
 
    le_bool fClientArrays;
 
private:
    static const char fgClassID;
 
    le_int32 ensureCapacity();
 
    inline RunArray();
    inline RunArray(const RunArray & /*other*/);
    inline RunArray &operator=(const RunArray & /*other*/) { return *this; }
 
    const le_int32 *fLimits;
          le_int32  fCount;
          le_int32  fCapacity;
};
 
inline RunArray::RunArray()
    : UObject(), fClientArrays(false), fLimits(nullptr), fCount(0), fCapacity(0)
{
    // nothing else to do...
}
 
inline RunArray::RunArray(const RunArray & /*other*/)
    : UObject(), fClientArrays(false), fLimits(nullptr), fCount(0), fCapacity(0)
{
    // nothing else to do...
}
 
inline RunArray::RunArray(const le_int32 *limits, le_int32 count)
    : UObject(), fClientArrays(true), fLimits(limits), fCount(count), fCapacity(count)
{
    // nothing else to do...
}
 
inline le_int32 RunArray::getCount() const
{
    return fCount;
}
 
inline void RunArray::reset()
{
    fCount = 0;
}
 
inline le_int32 RunArray::getLimit(le_int32 run) const
{
    if (run < 0 || run >= fCount) {
        return -1;
    }
 
    return fLimits[run];
}
 
inline le_int32 RunArray::getLimit() const
{
    return getLimit(fCount - 1);
}
 
class U_LAYOUTEX_API FontRuns : public RunArray
{
public:
    inline FontRuns(const LEFontInstance **fonts, const le_int32 *limits, le_int32 count);
 
    FontRuns(le_int32 initialCapacity);
 
    virtual ~FontRuns();
 
    const LEFontInstance *getFont(le_int32 run) const;
 
 
    le_int32 add(const LEFontInstance *font, le_int32 limit);
 
    static inline UClassID getStaticClassID() { return (UClassID)&fgClassID; }
 
    inline UClassID getDynamicClassID() const override { return getStaticClassID(); }
 
protected:
    void init(le_int32 capacity) override;
    void grow(le_int32 capacity) override;
 
private:
 
    inline FontRuns();
    inline FontRuns(const FontRuns &other);
    inline FontRuns &operator=(const FontRuns & /*other*/) { return *this; }
 
    static const char fgClassID;
 
    const LEFontInstance **fFonts;
};
 
inline FontRuns::FontRuns()
    : RunArray(0), fFonts(nullptr)
{
    // nothing else to do...
}
 
inline FontRuns::FontRuns(const FontRuns & /*other*/)
    : RunArray(0), fFonts(nullptr)
{
    // nothing else to do...
}
 
inline FontRuns::FontRuns(const LEFontInstance **fonts, const le_int32 *limits, le_int32 count)
    : RunArray(limits, count), fFonts(fonts)
{
    // nothing else to do...
}
 
class U_LAYOUTEX_API LocaleRuns : public RunArray
{
public:
    inline LocaleRuns(const Locale **locales, const le_int32 *limits, le_int32 count);
 
    LocaleRuns(le_int32 initialCapacity);
 
    virtual ~LocaleRuns();
 
    const Locale *getLocale(le_int32 run) const;
 
 
    le_int32 add(const Locale *locale, le_int32 limit);
 
    static inline UClassID getStaticClassID() { return (UClassID)&fgClassID; }
 
    inline UClassID getDynamicClassID() const override { return getStaticClassID(); }
 
protected:
    void init(le_int32 capacity) override;
    void grow(le_int32 capacity) override;
 
    const Locale **fLocales;
 
private:
 
    inline LocaleRuns();
    inline LocaleRuns(const LocaleRuns &other);
    inline LocaleRuns &operator=(const LocaleRuns & /*other*/) { return *this; }
 
    static const char fgClassID;
};
 
inline LocaleRuns::LocaleRuns()
    : RunArray(0), fLocales(nullptr)
{
    // nothing else to do...
}
 
inline LocaleRuns::LocaleRuns(const LocaleRuns & /*other*/)
    : RunArray(0), fLocales(nullptr)
{
    // nothing else to do...
}
 
inline LocaleRuns::LocaleRuns(const Locale **locales, const le_int32 *limits, le_int32 count)
    : RunArray(limits, count), fLocales(locales)
{
    // nothing else to do...
}
 
class U_LAYOUTEX_API ValueRuns : public RunArray
{
public:
    inline ValueRuns(const le_int32 *values, const le_int32 *limits, le_int32 count);
 
    ValueRuns(le_int32 initialCapacity);
 
    virtual ~ValueRuns();
 
    le_int32 getValue(le_int32 run) const;
 
 
    le_int32 add(le_int32 value, le_int32 limit);
 
    static inline UClassID getStaticClassID() { return (UClassID)&fgClassID; }
 
    inline UClassID getDynamicClassID() const override { return getStaticClassID(); }
 
protected:
    void init(le_int32 capacity) override;
    void grow(le_int32 capacity) override;
 
private:
 
    inline ValueRuns();
    inline ValueRuns(const ValueRuns &other);
    inline ValueRuns &operator=(const ValueRuns & /*other*/) { return *this; }
 
    static const char fgClassID;
 
    const le_int32 *fValues;
};
 
inline ValueRuns::ValueRuns()
    : RunArray(0), fValues(nullptr)
{
    // nothing else to do...
}
 
inline ValueRuns::ValueRuns(const ValueRuns & /*other*/)
    : RunArray(0), fValues(nullptr)
{
    // nothing else to do...
}
 
inline ValueRuns::ValueRuns(const le_int32 *values, const le_int32 *limits, le_int32 count)
    : RunArray(limits, count), fValues(values)
{
    // nothing else to do...
}
 
U_NAMESPACE_END
#endif