text: /* Copyright 2012. Bloomberg Finance L.P.
   *
   * Permission is hereby granted, free of charge, to any person obtaining a copy
   * of this software and associated documentation files (the "Software"), to
   * deal in the Software without restriction, including without limitation the
   * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
   * sell copies of the Software, and to permit persons to whom the Software is
   * furnished to do so, subject to the following conditions:  The above
   * copyright notice and this permission notice shall be included in all copies
   * or substantial portions of the Software.
   *
   * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
   * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
   * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
   * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
   * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
   * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
   * IN THE SOFTWARE.
   */
  // blpapi_schema.h                                                    -*-C++-*-
  #ifndef INCLUDED_BLPAPI_SCHEMA
  #define INCLUDED_BLPAPI_SCHEMA
  
  //@PURPOSE: Provide a representation of a schema describing structured messages
  //
  //@CLASSES:
  // blpapi::SchemaStatus: the version status of a schema
  // blpapi::SchemaTypeDefinition: definitions of schema types
  // blpapi::SchemaElementDefinition: definitions of message elements
  //
  //@DESCRIPTION: This component provides types for representing schemata which
  // describe structured messages. Such schemata consist of two distinct kinds of
  // definitions: "type" definitions (represented by 'SchemaTypeDefinition'
  // objects) declare types than can be used within other definitions (of both
  // kinds); an "element" definition defines a specific field by associating a
  // field identifier with a particular type, as well as the number of values of
  // that type that are permitted to be associated with that identifier.
  
  #ifndef INCLUDED_BLPAPI_CONSTANT
  #include <blpapi_constant.h>
  #endif
  
  #ifndef INCLUDED_BLPAPI_DEFS
  #include <blpapi_defs.h>
  #endif
  
  #ifndef INCLUDED_BLPAPI_EXCEPTION
  #include <blpapi_exception.h>
  #endif
  
  #ifndef INCLUDED_BLPAPI_NAME
  #include <blpapi_name.h>
  #endif
  
  #ifndef INCLUDED_BLPAPI_STREAMPROXY
  #include <blpapi_streamproxy.h>
  #endif
  
  #ifndef INCLUDED_BLPAPI_TYPES
  #include <blpapi_types.h>
  #endif
  
  typedef void *blpapi_SchemaElementDefinition_t;
  typedef void *blpapi_SchemaTypeDefinition_t;
  
  #ifdef __cplusplus
  extern "C" {
  #endif
  
  BLPAPI_EXPORT
  blpapi_Name_t *blpapi_SchemaElementDefinition_name(
          const blpapi_SchemaElementDefinition_t *field);
  
  BLPAPI_EXPORT
  const char *blpapi_SchemaElementDefinition_description(
          const blpapi_SchemaElementDefinition_t *field);
  
  BLPAPI_EXPORT
  int blpapi_SchemaElementDefinition_status(
          const blpapi_SchemaElementDefinition_t *field);
  
  BLPAPI_EXPORT
  blpapi_SchemaTypeDefinition_t *blpapi_SchemaElementDefinition_type(
          const blpapi_SchemaElementDefinition_t *field);
  
  BLPAPI_EXPORT
  size_t blpapi_SchemaElementDefinition_numAlternateNames(
          const blpapi_SchemaElementDefinition_t *field);
  
  BLPAPI_EXPORT
  blpapi_Name_t *blpapi_SchemaElementDefinition_getAlternateName(
          const blpapi_SchemaElementDefinition_t *field,
          size_t index);
  
  
  //   -- NOT USED or IMPLEMENTED: removing
  // BLPAPI_EXPORT
  // size_t blpapi_SchemaElementDefinition_numNames(
  //         const blpapi_SchemaElementDefinition_t *field);
  
  
  BLPAPI_EXPORT
  size_t blpapi_SchemaElementDefinition_minValues(
          const blpapi_SchemaElementDefinition_t *field);
  
  BLPAPI_EXPORT
  size_t blpapi_SchemaElementDefinition_maxValues(
          const blpapi_SchemaElementDefinition_t *field);
  
  BLPAPI_EXPORT
  int blpapi_SchemaElementDefinition_print(
          const blpapi_SchemaElementDefinition_t *element,
          blpapi_StreamWriter_t streamWriter,
          void *userStream,
          int level,
          int spacesPerLevel);
  
  BLPAPI_EXPORT
  void blpapi_SchemaElementDefinition_setUserData(
          blpapi_SchemaElementDefinition_t *field,
          void *userdata);
  
  BLPAPI_EXPORT
  void *blpapi_SchemaElementDefinition_userData(
          const blpapi_SchemaElementDefinition_t *field);
  
  BLPAPI_EXPORT
  blpapi_Name_t *blpapi_SchemaTypeDefinition_name(
          const blpapi_SchemaTypeDefinition_t *type);
  
  BLPAPI_EXPORT
  const char *blpapi_SchemaTypeDefinition_description(
          const blpapi_SchemaTypeDefinition_t *type);
  
  BLPAPI_EXPORT
  int blpapi_SchemaTypeDefinition_status(
          const blpapi_SchemaTypeDefinition_t *type);
  
  BLPAPI_EXPORT
  int blpapi_SchemaTypeDefinition_datatype(
          const blpapi_SchemaTypeDefinition_t *type);
  
  BLPAPI_EXPORT
  int blpapi_SchemaTypeDefinition_isComplexType(
          const blpapi_SchemaTypeDefinition_t *type);
  
  BLPAPI_EXPORT
  int blpapi_SchemaTypeDefinition_isSimpleType(
          const blpapi_SchemaTypeDefinition_t *type);
  
  BLPAPI_EXPORT
  int blpapi_SchemaTypeDefinition_isEnumerationType(
          const blpapi_SchemaTypeDefinition_t *type);
  
  BLPAPI_EXPORT
  int blpapi_SchemaTypeDefinition_isComplex(
          const blpapi_SchemaTypeDefinition_t *type);
  
  BLPAPI_EXPORT
  int blpapi_SchemaTypeDefinition_isSimple(
          const blpapi_SchemaTypeDefinition_t *type);
  
  BLPAPI_EXPORT
  int blpapi_SchemaTypeDefinition_isEnumeration(
          const blpapi_SchemaTypeDefinition_t *type);
  
  
  BLPAPI_EXPORT
  size_t blpapi_SchemaTypeDefinition_numElementDefinitions(
          const blpapi_SchemaTypeDefinition_t *type);
  
  BLPAPI_EXPORT
  blpapi_SchemaElementDefinition_t*
  blpapi_SchemaTypeDefinition_getElementDefinition(
          const blpapi_SchemaTypeDefinition_t *type,
          const char *nameString,
          const blpapi_Name_t *name);
  
  BLPAPI_EXPORT
  blpapi_SchemaElementDefinition_t*
  blpapi_SchemaTypeDefinition_getElementDefinitionAt(
          const blpapi_SchemaTypeDefinition_t *type,
          size_t index);
  
  BLPAPI_EXPORT
  int blpapi_SchemaTypeDefinition_print(
          const blpapi_SchemaTypeDefinition_t *element,
          blpapi_StreamWriter_t streamWriter,
          void *userStream,
          int level,
          int spacesPerLevel);
  
  BLPAPI_EXPORT
  void blpapi_SchemaTypeDefinition_setUserData(
          blpapi_SchemaTypeDefinition_t *element,
          void *userdata);
  
  BLPAPI_EXPORT
  void *blpapi_SchemaTypeDefinition_userData(
          const blpapi_SchemaTypeDefinition_t *element);
  
  BLPAPI_EXPORT
  blpapi_ConstantList_t*
  blpapi_SchemaTypeDefinition_enumeration(
          const blpapi_SchemaTypeDefinition_t *element);
  
  
  #ifdef __cplusplus
  }
  
  #ifndef INCLUDED_IOSFWD
  #include <iosfwd>
  #define INCLUDED_IOSFWD
  #endif
  
  namespace BloombergLP {
  namespace blpapi {
                           // ===================
                           // struct SchemaStatus
                           // ===================
  
  struct SchemaStatus {
      // This 'struct' provides a namespace for enumerating the possible
      // deprecation statuses of a schema element or type.
  
      enum Value {
          ACTIVE              = BLPAPI_STATUS_ACTIVE,     // This item is current
                                                          // and may appear in
                                                          // Messages
          DEPRECATED          = BLPAPI_STATUS_DEPRECATED, // This item is current
                                                          // and may appear in
                                                          // Messages but will be
                                                          // removed in due
                                                          // course
          INACTIVE            = BLPAPI_STATUS_INACTIVE,   // This item is not
                                                          // current and will not
                                                          // appear in Messages
          PENDING_DEPRECATION = BLPAPI_STATUS_PENDING_DEPRECATION
                                                          // This item is
                                                          // expected to be
                                                          // deprecated in the
                                                          // future; clients are
                                                          // advised to migrate
                                                          // away from use of
                                                          // this item.
      };
  };
  
  class SchemaTypeDefinition;
  
                         // =============================
                         // class SchemaElementDefinition
                         // =============================
  
  class SchemaElementDefinition {
      // This class implements the definition of an individual field within a
      // schema type. An element is defined by an identifer/name, a type, and the
      // number of values of that type that may be associated with the
      // identifier/name. In addition, this class offers access to metadata
      // providing a description and deprecation status for the field. Finally,
      // 'SchemaElementDefinition' provides an interface for associating
      // arbitrary user-defined data (specified as a 'void*') with an element
      // definition.
      //
      // 'SchemaElementDefinition' objects are returned by 'Service' and
      // 'Operation' objects to define the content of requests, replies and
      // events. The 'SchemaTypeDefinition' returned by
      // 'SchemaElementDefinition::typeDefinition()' may itself provide access to
      // 'SchemaElementDefinition' objects when the schema contains nested
      // elements. (See the 'SchemaTypeDefinition' documentation for more
      // information on complex types.)
      //
      // An optional element has 'minValues() == 0'.
      //
      // A mandatory element has 'minValues() >= 1'.
      //
      // An element that must constain a single value has
      // 'minValues() == maxValues() == 1'.
      //
      // An element containing an array has 'maxValues() > 1'.
      //
      // An element with no upper limit on the number of values has
      // 'maxValues() == UNBOUNDED'.
      //
      // 'SchemaElementDefinition' objects are read-only, with the exception of a
      // single 'void*' attribute for storing user data.
      // 'SchemaElementDefinition' objects have *reference* *semantics* with
      // respect to this user data field: calling 'c.setUserData(void*)' modifies
      // the user data associated with 'c', as well as that associated with all
      // copies of 'c'. As a result, functions which set or read this attribute
      // are *NOT* per-object thread-safe. Clients must syncrhonize such
      // operations across *all* *copies* of an object.
      //
      // Application clients need never create fresh 'SchemaElementDefinition'
      // objects directly; applications will typically work with copies of
      // objects returned by other 'blpapi' components.
  
      blpapi_SchemaElementDefinition_t *d_impl_p;
  
    public:
      // Constants used in the SchemaElementDefinition interface.
  
      enum {
          UNBOUNDED = BLPAPI_ELEMENTDEFINITION_UNBOUNDED  // Indicates an array
                                                          // has an unbounded
                                                          // number of values.
      };
  
      SchemaElementDefinition(blpapi_SchemaElementDefinition_t *handle);
  
      ~SchemaElementDefinition();
          // Destroy this object.
  
      // MANIPULATORS
  
      void setUserData(void *userData);
          // Set the user data associated with this 'SchemaElementDefinition' --
          // and all copies of this 'SchemaElementDefinition' -- to the specified
          // 'userData'. Clients are responsible for synchronizing calls to this
          // function, and to 'userData()', across all copies of this
          // 'SchemaElementDefinition' object.
  
      // ACCESSORS
  
      Name name() const;
          // Return the name identifying this element within its containing
          // structure/type.
  
      const char *description() const;
          // Return a null-terminated string containing a human-readable
          // description of this element. This pointer is valid until this
          // 'SchemaElementDefinition' is destroyed.
  
      int status() const;
          // Return the deprecation status, as a 'SchemaStatus::Value', of this
          // element.
  
      const SchemaTypeDefinition typeDefinition() const;
          // Return the type of values contained in this element.
  
      size_t minValues() const;
          // Return the minimum number of occurrences of this element. This value
          // is always greater than or equal to zero.
  
      size_t maxValues() const ;
          // Return the maximum number of occurrences of this element. This value
          // is always greater than or equal to one.
  
      size_t numAlternateNames() const;
          // Return the number of alternate names for this element.
  
      Name getAlternateName(size_t index) const;
          // Return the specified 'index'th alternate name for this element. If
          // 'index >=numAlternateNames()' an exception is thrown.
  
      void *userData() const;
          // Return the user data associated with this 'SchemaElementDefinition'.
          // If no user data has been associated with this
          // 'SchemaElementDefinition' then return 0. Clients are responsible for
          // synchronizing calls to this function with calls to
          // 'setUserData(void*)' made on not only this
          // 'SchemaElementDefinition', but also all copies of this
          // 'SchemaElementDefinition'. Note that 'SchemaElementDefinition'
          // objects have reference semantics: this function will reflect the
          // last value set on *any* copy of this 'SchemaElementDefinition'.
  
      std::ostream& print(std::ostream& stream,
                          int level=0,
                          int spacesPerLevel=4) const;
          // Format this SchemaElementDefinition to the specified output 'stream'
          // at the (absolute value of) the optionally specified indentation
          // 'level' and return a reference to 'stream'. If 'level' is specified,
          // optionally specify 'spacesPerLevel', the number of spaces per
          // indentation level for this and all of its nested objects. If 'level'
          // is negative, suppress indentation of the first line. If
          // 'spacesPerLevel' is negative, format the entire output on one line,
          // suppressing all but the initial indentation (as governed by
          // 'level').
  
      blpapi_SchemaElementDefinition_t *impl() const;
  };
  
  // FREE OPERATORS
  std::ostream& operator<<(std::ostream& stream,
                           const SchemaElementDefinition& element);
      // Write the value of the specified 'element' object to the specified
      // output 'stream' in a single-line format, and return a reference to
      // 'stream'.  If 'stream' is not valid on entry, this operation has no
      // effect.  Note that this human-readable format is not fully specified,
      // can change without notice, and is logically equivalent to:
      //..
      //  print(stream, 0, -1);
      //..
  
                         // ==========================
                         // class SchemaTypeDefinition
                         // ==========================
  
  class SchemaTypeDefinition {
      // This class implements a representation of a "type" that can be used
      // within a schema, including both simple atomic types (integers, dates,
      // strings, etc.) as well as "complex" types defined a sequences of or
      // choice among a collection (named) elements, each of which is in turn
      // described by another type. In addition to accessors for the type's
      // structure, this class also offers access to metadata providing a
      // description and deprecation status for the type. Finally,
      // 'SchemaTypeDefinition' provides an interface for associating arbitrary
      // user-defined data (specified as a 'void*') with a type definition.
      //
      // Each 'SchemaElementDefinition' object is associated with a single
      // 'SchemaTypeDefinition'; one 'SchemaTypeDefinition' may be used by zero,
      // one, or many 'SchemaElementDefinition' objects.
      //
      // 'SchemaTypeDefinition' objects are read-only, with the exception of a
      // single 'void*' attribute for storing user data. 'SchemaTypeDefinition'
      // objects have *reference* *semantics* with respect to this user data
      // field: calling 'c.setUserData(void*)' modifies the user data associated
      // with 'c', as well as that associated with all copies of 'c'. As a
      // result, functions which set or read this attribute are *NOT* per-object
      // thread-safe. Clients must syncrhonize such operations across *all*
      // *copies* of an object.
      //
      // Application clients need never create fresh 'SchemaTypeDefinition'
      // objects directly; applications will typically work with copies of
      // objects returned by other 'blpapi' components.
  
      blpapi_SchemaTypeDefinition_t *d_impl_p;
  
    public:
      SchemaTypeDefinition(blpapi_SchemaTypeDefinition_t *handle);
  
      ~SchemaTypeDefinition();
          // Destroy this object.
  
      // MANIPULATORS
  
      void setUserData(void *userData);
          // Set the user data associated with this 'SchemaTypeDefinition' -- and
          // all copies of this 'SchemaTypeDefinition' -- to the specified
          // 'userData'. Clients are responsible for synchronizing calls to this
          // function, and to 'userData()', across all copies of this
          // 'SchemaTypeDefinition' object.
  
      // ACCESSORS
  
      int datatype() const;
          // Return the 'DataType' of this 'SchemaTypeDefinition'.
  
      Name name() const;
          // Return the name of this 'SchemaTypeDefinition'.
  
      const char *description() const;
          // Return a null-terminated string which contains a human readable
          // description of this 'SchemaTypeDefinition'. The returned pointer
          // remains valid until this 'SchemaTypeDefinition' is destroyed.
  
      int status() const;
          // Return the deprecation status, as a 'SchemaStatus::Value', of this
          // 'SchemaTypeDefinition'.
  
      size_t numElementDefinitions() const;
          // Return the number of 'SchemaElementDefinition' objects contained by
          // this 'SchemaTypeDefinition'. If this 'SchemaTypeDefinition' is
          // neither a choice nor a sequence this will return 0.
  
      bool isComplexType() const;
          // Return 'true' if this 'SchemaTypeDefinition' represents a sequence
          // or choice type.
  
      bool isSimpleType() const;
          // Return 'true' if this 'SchemaTypeDefinition' represents neither a
          // sequence nor a choice type.
  
      bool isEnumerationType() const;
          // Return 'true' if this 'SchemaTypeDefinition' represents an enumeration
          // type.
  
      bool hasElementDefinition(const Name& name) const;
          // Return 'true' if this 'SchemaTypeDefinition' contains an element
          // with the specified 'name'; otherwise returns 'false'.
  
      bool hasElementDefinition(const char *name) const;
          // Return 'true' if this 'SchemaTypeDefinition' contains an element
          // with the specified 'name'; otherwise returns 'false'.
  
      SchemaElementDefinition getElementDefinition(const Name& name) const;
          // Return the definition of the element identified by the specified
          // 'name'. If 'hasElementDefinition(name) != true' then an exception is
          // thrown.
  
      SchemaElementDefinition getElementDefinition(const char *nameString) const;
          // Return the definition of the element identified by the specified
          // 'nameString'. If 'hasElementDefinition(nameString) != true' then an
          // exception is thrown.
  
      SchemaElementDefinition getElementDefinition(size_t index) const;
          // Return the definition of the element a the specified 'index' in the
          // sequence of elements. If 'index >= numElementDefinitions()' an
          // exception is thrown.
  
      const ConstantList enumeration() const;
          // Return a 'ConstantList' containing all possible values of the
          // enumeration defined by this type. The behavior of this function is
          // undefined unless 'isEnumerationType() == true'.
  
      void *userData() const;
          // Return the user data associated with this 'SchemaTypeDefinition'. If
          // no user data has been associated with this 'SchemaTypeDefinition'
          // then return 0. Clients are responsible for synchronizing calls to
          // this function with calls to 'setUserData(void*)' made on not only
          // this 'SchemaTypeDefinition', but also all copies of this
          // 'SchemaTypeDefinition'. Note that 'SchemaTypeDefinition' objects
          // have reference semantics: this function will reflect the last value
          // set on *any* copy of this 'SchemaTypeDefinition'.
  
      std::ostream& print(std::ostream& stream,
                          int level=0,
                          int spacesPerLevel=4) const;
          // Format this SchemaTypeDefinition to the specified output 'stream' at
          // the (absolute value of) the optionally specified indentation 'level'
          // and return a reference to 'stream'. If 'level' is specified,
          // optionally specify 'spacesPerLevel', the number of spaces per
          // indentation level for this and all of its nested objects. If 'level'
          // is negative, suppress indentation of the first line. If
          // 'spacesPerLevel' is negative, format the entire output on one line,
          // suppressing all but the initial indentation (as governed by
          // 'level').
  };
  
  // FREE OPERATORS
  std::ostream& operator<<(std::ostream& stream,
                           const SchemaTypeDefinition& typeDef);
      // Write the value of the specified 'typeDef' object to the specified
      // output 'stream' in a single-line format, and return a reference to
      // 'stream'.  If 'stream' is not valid on entry, this operation has no
      // effect.  Note that this human-readable format is not fully specified,
      // can change without notice, and is logically equivalent to:
      //..
      //  print(stream, 0, -1);
      //..
  
  // ============================================================================
  //                      INLINE FUNCTION DEFINITIONS
  // ============================================================================
  
                         // -----------------------------
                         // class SchemaElementDefinition
                         // -----------------------------
  
  inline
  SchemaElementDefinition::SchemaElementDefinition(
      blpapi_SchemaElementDefinition_t *handle)
  : d_impl_p(handle)
  {
  }
  
  
  inline
  SchemaElementDefinition::~SchemaElementDefinition()
  {
  }
  
  inline
  Name SchemaElementDefinition::name() const
  {
      return Name(blpapi_SchemaElementDefinition_name(d_impl_p));
  }
  
  inline
  const char *SchemaElementDefinition::description() const
  {
      return blpapi_SchemaElementDefinition_description(d_impl_p);
  }
  
  inline
  int SchemaElementDefinition::status() const
  {
      return blpapi_SchemaElementDefinition_status(d_impl_p);
  }
  
  inline
  const SchemaTypeDefinition SchemaElementDefinition::typeDefinition() const
  {
      return blpapi_SchemaElementDefinition_type(d_impl_p);
  }
  
  inline
  size_t SchemaElementDefinition::minValues() const
  {
      return blpapi_SchemaElementDefinition_minValues(d_impl_p);
  }
  
  inline
  size_t SchemaElementDefinition::maxValues() const
  {
      return blpapi_SchemaElementDefinition_maxValues(d_impl_p);
  }
  
  inline
  size_t SchemaElementDefinition::numAlternateNames() const
  {
      return blpapi_SchemaElementDefinition_numAlternateNames(d_impl_p);
  }
  
  inline
  Name SchemaElementDefinition::getAlternateName(size_t index) const
  {
      blpapi_Name_t *alternateName =
          blpapi_SchemaElementDefinition_getAlternateName(d_impl_p, index);
      if (alternateName == 0) {
          ExceptionUtil::throwOnError(BLPAPI_ERROR_INDEX_OUT_OF_RANGE);
      }
      return alternateName;
  }
  
  inline
  std::ostream& SchemaElementDefinition::print(
          std::ostream& stream,
          int level,
          int spacesPerLevel) const
  {
      blpapi_SchemaElementDefinition_print(d_impl_p,
                                           StreamProxyOstream::writeToStream,
                                           &stream,
                                           level,
                                           spacesPerLevel);
      return stream;
  }
  
  inline
  std::ostream& operator<<(
          std::ostream& stream,
          const SchemaElementDefinition& element)
  {
      element.print(stream, 0, -1);
      return stream;
  }
  
  inline
  void SchemaElementDefinition::setUserData(void *newUserData)
  {
      blpapi_SchemaElementDefinition_setUserData(d_impl_p, newUserData);
  }
  
  inline
  void *SchemaElementDefinition::userData() const
  {
      return blpapi_SchemaElementDefinition_userData(d_impl_p);
  }
  
  inline
  blpapi_SchemaElementDefinition_t *SchemaElementDefinition::impl() const
  {
      return d_impl_p;
  }
                         // --------------------------
                         // class SchemaTypeDefinition
                         // --------------------------
  
  inline
  SchemaTypeDefinition::SchemaTypeDefinition(
                                           blpapi_SchemaTypeDefinition_t *handle)
  : d_impl_p(handle)
  {
  }
  
  inline
  SchemaTypeDefinition::~SchemaTypeDefinition()
  {
  }
  
  inline
  int SchemaTypeDefinition::datatype() const
  {
      return blpapi_SchemaTypeDefinition_datatype(d_impl_p);
  }
  
  inline
  Name SchemaTypeDefinition::name() const
  {
      return blpapi_SchemaTypeDefinition_name(d_impl_p);
  }
  
  inline
  const char *SchemaTypeDefinition::description() const
  {
      return blpapi_SchemaTypeDefinition_description(d_impl_p);
  }
  
  inline
  int SchemaTypeDefinition::status() const
  {
      return blpapi_SchemaTypeDefinition_status(d_impl_p);
  }
  
  inline
  size_t SchemaTypeDefinition::numElementDefinitions() const
  {
      return blpapi_SchemaTypeDefinition_numElementDefinitions(d_impl_p);
  }
  
  inline
  bool SchemaTypeDefinition::hasElementDefinition(const Name& elementName) const
  {
      return blpapi_SchemaTypeDefinition_getElementDefinition(
              d_impl_p, 0, elementName.impl()) ? true : false;
  }
  
  inline
  bool
  SchemaTypeDefinition::hasElementDefinition(const char *nameString) const
  {
      return blpapi_SchemaTypeDefinition_getElementDefinition(
              d_impl_p, nameString, 0) ? true : false;
  }
  
  inline
  SchemaElementDefinition
  SchemaTypeDefinition::getElementDefinition(const Name& elementName) const
  {
      blpapi_SchemaElementDefinition_t *def =
          blpapi_SchemaTypeDefinition_getElementDefinition(d_impl_p,
                                                           0,
                                                           elementName.impl());
      if (def == 0) {
          ExceptionUtil::throwOnError(BLPAPI_ERROR_ITEM_NOT_FOUND);
      }
      return def;
  }
  
  inline
  SchemaElementDefinition
  SchemaTypeDefinition::getElementDefinition(const char *nameString) const
  {
      blpapi_SchemaElementDefinition_t *def =
          blpapi_SchemaTypeDefinition_getElementDefinition(d_impl_p,
                                                           nameString,
                                                           0);
      if (def == 0) {
          ExceptionUtil::throwOnError(BLPAPI_ERROR_ITEM_NOT_FOUND);
      }
      return def;
  }
  
  inline
  SchemaElementDefinition
  SchemaTypeDefinition::getElementDefinition(size_t index) const
  {
      blpapi_SchemaElementDefinition_t *def =
          blpapi_SchemaTypeDefinition_getElementDefinitionAt(d_impl_p, index);
      if (def == 0) {
          ExceptionUtil::throwOnError(BLPAPI_ERROR_INDEX_OUT_OF_RANGE);
      }
      return def;
  }
  
  inline
  bool SchemaTypeDefinition::isComplexType() const
  {
      return blpapi_SchemaTypeDefinition_isComplexType(d_impl_p) ? true : false;
  }
  
  inline
  bool SchemaTypeDefinition::isSimpleType() const
  {
      return blpapi_SchemaTypeDefinition_isSimpleType(d_impl_p) ? true : false;
  }
  
  inline
  bool SchemaTypeDefinition::isEnumerationType() const
  {
      return blpapi_SchemaTypeDefinition_isEnumerationType(d_impl_p)
          ? true
          : false;
  }
  
  inline
  std::ostream& SchemaTypeDefinition::print(
          std::ostream& stream,
          int level,
          int spacesPerLevel) const
  {
      blpapi_SchemaTypeDefinition_print(d_impl_p,
                                        StreamProxyOstream::writeToStream,
                                        &stream,
                                        level,
                                        spacesPerLevel);
      return stream;
  }
  
  inline
  std::ostream& operator<<(
          std::ostream& stream,
          const SchemaTypeDefinition& typeDef)
  {
      typeDef.print(stream, 0, -1);
      return stream;
  }
  
  inline
  void SchemaTypeDefinition::setUserData(void *newUserData)
  {
      blpapi_SchemaTypeDefinition_setUserData(d_impl_p, newUserData);
  }
  
  inline
  void *SchemaTypeDefinition::userData() const
  {
      return blpapi_SchemaTypeDefinition_userData(d_impl_p);
  }
  
  inline
  const ConstantList SchemaTypeDefinition::enumeration() const
  {
      return blpapi_SchemaTypeDefinition_enumeration(d_impl_p);
  }
  
  }  // close namespace blpapi
  }  // close namespace BloombergLP
  
  #endif // #ifdef __cplusplus
  
  #endif // #ifndef INCLUDED_BLPAPI_SCHEMA
  