#ifndef HB_OPEN_TYPE_HH

#define HB_OPEN_TYPE_HH

#include "hb.hh"

#include "hb-blob.hh"

#include "hb-face.hh"

#include "hb-machinery.hh"

#include "hb-subset.hh"

template <bool is_signed> struct hb_signedness_int;

template <> struct hb_signedness_int<false> { typedef unsigned int value; };

template <> struct hb_signedness_int<true>  { typedef   signed int value; };

  typedef Type type;

  typedef typename hb_signedness_int<hb_is_signed<Type>::value>::value wide_type;

  void set (wide_type i) { v.set (i); }

  operator wide_type () const { return v; }

  bool operator == (const IntType<Type,Size> &o) const { return (Type) v == (Type) o.v; }

  bool operator != (const IntType<Type,Size> &o) const { return !(*this == o); }

  static int cmp (const IntType<Type,Size> *a, const IntType<Type,Size> *b) { return b->cmp (*a); }

  int cmp (Type2 a) const

  bool sanitize (hb_sanitize_context_t *c) const

/* Note: we cannot defined a signed HBINT24 because there's no corresponding C type.

 * Works for unsigned, but not signed, since we rely on compiler for sign-extension. */

/* 32-bit signed integer (HBINT32) that describes a quantity in FUnits. */

typedef HBINT32 FWORD32;

  float to_float () const  { return ((int32_t) v) / 16384.f; }

  void set_float (float f) { v.set (round (f * 16384.f)); }

  float to_float () const  { return ((int32_t) v) / 65536.f; }

  void set_float (float f) { v.set (round (f * 65536.f)); }

  bool sanitize (hb_sanitize_context_t *c) const

  operator const char* () const { return reinterpret_cast<const char *> (&this->v); }

  operator char* ()             { return reinterpret_cast<char *> (&this->v); }

  static constexpr unsigned NOT_FOUND_INDEX = 0xFFFFu;

DECLARE_NULL_NAMESPACE_BYTES (OT, Index);

typedef Index NameID;

template <typename Type, bool has_null=true>

  typedef Type type;

  bool is_null () const { return has_null && 0 == *this; }

  void *serialize (hb_serialize_context_t *c, const void *base)

  DEFINE_SIZE_STATIC (sizeof (Type));

  static uint32_t CalcTableChecksum (const HBUINT32 *Table, uint32_t Length)

  void set_for_data (const void *data, unsigned int length)

  uint32_t to_int () const { return (major << (sizeof (FixedType) * 8)) + minor; }

  bool sanitize (hb_sanitize_context_t *c) const

  DEFINE_SIZE_STATIC (2 * sizeof (FixedType));

template <typename Type, bool has_null>

struct _hb_has_null

{

  static const Type *get_null () { return nullptr; }

  static Type *get_crap ()       { return nullptr; }

};

template <typename Type>

struct _hb_has_null<Type, true>

  static const Type *get_null () { return &Null(Type); }

  static Type *get_crap ()       { return &Crap(Type); }

};

template <typename Type, typename OffsetType=HBUINT16, bool has_null=true>

struct OffsetTo : Offset<OffsetType, has_null>

{

  const Type& operator () (const void *base) const

    if (unlikely (this->is_null ())) return *_hb_has_null<Type, has_null>::get_null ();

    return StructAtOffset<const Type> (base, *this);

  Type& operator () (void *base) const

    if (unlikely (this->is_null ())) return *_hb_has_null<Type, has_null>::get_crap ();

    return StructAtOffset<Type> (base, *this);

  Type& serialize (hb_serialize_context_t *c, const void *base)

  template <typename T>

  void serialize_subset (hb_subset_context_t *c, const T &src, const void *base)

    if (&src == &Null (T))

    {

      this->set (0);

      return;

    }

    serialize (c->serializer, base);

    if (!src.subset (c))

      this->set (0);

  bool sanitize_shallow (hb_sanitize_context_t *c, const void *base) const

    if (unlikely (this->is_null ())) return_trace (true);

    if (unlikely (!c->check_range (base, *this))) return_trace (false);

    return_trace (true);

  }

  bool sanitize (hb_sanitize_context_t *c, const void *base) const

  {

    TRACE_SANITIZE (this);

    return_trace (sanitize_shallow (c, base) &&

                  (this->is_null () ||

                   StructAtOffset<Type> (base, *this).sanitize (c) ||

                   neuter (c)));

  }

  template <typename T1>

  bool sanitize (hb_sanitize_context_t *c, const void *base, T1 d1) const

  {

    TRACE_SANITIZE (this);

    return_trace (sanitize_shallow (c, base) &&

                  (this->is_null () ||

                   StructAtOffset<Type> (base, *this).sanitize (c, d1) ||

                   neuter (c)));

  }

  template <typename T1, typename T2>

  bool sanitize (hb_sanitize_context_t *c, const void *base, T1 d1, T2 d2) const

  {

    TRACE_SANITIZE (this);

    return_trace (sanitize_shallow (c, base) &&

                  (this->is_null () ||

                   StructAtOffset<Type> (base, *this).sanitize (c, d1, d2) ||

                   neuter (c)));

  }

  template <typename T1, typename T2, typename T3>

  bool sanitize (hb_sanitize_context_t *c, const void *base, T1 d1, T2 d2, T3 d3) const

  {

    TRACE_SANITIZE (this);

    return_trace (sanitize_shallow (c, base) &&

                  (this->is_null () ||

                   StructAtOffset<Type> (base, *this).sanitize (c, d1, d2, d3) ||

                   neuter (c)));

  bool neuter (hb_sanitize_context_t *c) const

  {

    if (!has_null) return false;

  DEFINE_SIZE_STATIC (sizeof (OffsetType));

/* Partial specializations. */

template <typename Type,                               bool has_null=true> struct   LOffsetTo : OffsetTo<Type, HBUINT32,   has_null> {};

template <typename Type, typename OffsetType=HBUINT16                    > struct  NNOffsetTo : OffsetTo<Type, OffsetType, false> {};

template <typename Type                                                  > struct LNNOffsetTo : OffsetTo<Type, HBUINT32,   false> {};

template <typename Base, typename OffsetType, bool has_null, typename Type>

static inline const Type& operator + (const Base &base, const OffsetTo<Type, OffsetType, has_null> &offset) { return offset (base); }

template <typename Base, typename OffsetType, bool has_null, typename Type>

static inline Type& operator + (Base &base, OffsetTo<Type, OffsetType, has_null> &offset) { return offset (base); }

  typedef Type item_t;

  static constexpr unsigned item_size = hb_static_size (Type);

  HB_NO_CREATE_COPY_ASSIGN_TEMPLATE (UnsizedArrayOf, Type);

  const Type& operator [] (int i_) const

  {

    unsigned int i = (unsigned int) i_;

    const Type *p = &arrayZ[i];

    if (unlikely (p < arrayZ)) return Null (Type); /* Overflowed. */

    return *p;

  }

  Type& operator [] (int i_)

  {

    unsigned int i = (unsigned int) i_;

    Type *p = &arrayZ[i];

    if (unlikely (p < arrayZ)) return Crap (Type); /* Overflowed. */

    return *p;

  }

  unsigned int get_size (unsigned int len) const

  { return len * Type::static_size; }

  template <typename T> operator T * () { return arrayZ; }

  template <typename T> operator const T * () const { return arrayZ; }

  hb_array_t<Type> as_array (unsigned int len)

  { return hb_array (arrayZ, len); }

  hb_array_t<const Type> as_array (unsigned int len) const

  { return hb_array (arrayZ, len); }

  operator hb_array_t<Type> ()             { return as_array (); }

  operator hb_array_t<const Type> () const { return as_array (); }

  template <typename T>

  Type &lsearch (unsigned int len, const T &x, Type &not_found = Crap (Type))

  { return *as_array (len).lsearch (x, &not_found); }

  template <typename T>

  const Type &lsearch (unsigned int len, const T &x, const Type &not_found = Null (Type)) const

  { return *as_array (len).lsearch (x, &not_found); }

  void qsort (unsigned int len, unsigned int start = 0, unsigned int end = (unsigned int) -1)

  { as_array (len).qsort (start, end); }

  bool sanitize (hb_sanitize_context_t *c, unsigned int count) const

  bool sanitize (hb_sanitize_context_t *c, unsigned int count, const void *base) const

  bool sanitize (hb_sanitize_context_t *c, unsigned int count, const void *base, T user_data) const

  bool sanitize_shallow (hb_sanitize_context_t *c, unsigned int count) const

    return_trace (c->check_array (arrayZ, count));

  Type          arrayZ[VAR];

  DEFINE_SIZE_UNBOUNDED (0);

template <typename Type, typename OffsetType, bool has_null=true>

struct UnsizedOffsetArrayOf : UnsizedArrayOf<OffsetTo<Type, OffsetType, has_null> > {};

template <typename Type, typename OffsetType, bool has_null=true>

struct UnsizedOffsetListOf : UnsizedOffsetArrayOf<Type, OffsetType, has_null>

  const Type& operator [] (int i_) const

    unsigned int i = (unsigned int) i_;

    const OffsetTo<Type, OffsetType, has_null> *p = &this->arrayZ[i];

    if (unlikely (p < this->arrayZ)) return Null (Type); /* Overflowed. */

    return this+*p;

  }

  Type& operator [] (int i_)

  {

    unsigned int i = (unsigned int) i_;

    const OffsetTo<Type, OffsetType, has_null> *p = &this->arrayZ[i];

    if (unlikely (p < this->arrayZ)) return Crap (Type); /* Overflowed. */

    return this+*p;

  bool sanitize (hb_sanitize_context_t *c, unsigned int count) const

    return_trace ((UnsizedOffsetArrayOf<Type, OffsetType, has_null>::sanitize (c, count, this)));

  bool sanitize (hb_sanitize_context_t *c, unsigned int count, T user_data) const

    return_trace ((UnsizedOffsetArrayOf<Type, OffsetType, has_null>::sanitize (c, count, this, user_data)));

/* An array with sorted elements.  Supports binary searching. */

template <typename Type>

struct SortedUnsizedArrayOf : UnsizedArrayOf<Type>

{

  hb_sorted_array_t<Type> as_array (unsigned int len)

  { return hb_sorted_array (this->arrayZ, len); }

  hb_sorted_array_t<const Type> as_array (unsigned int len) const

  { return hb_sorted_array (this->arrayZ, len); }

  operator hb_sorted_array_t<Type> ()             { return as_array (); }

  operator hb_sorted_array_t<const Type> () const { return as_array (); }

  template <typename T>

  Type &bsearch (unsigned int len, const T &x, Type &not_found = Crap (Type))