text: // s_baltst_mysequencewithnillable.h     *DO NOT EDIT*     @generated -*-C++-*-
  #ifndef INCLUDED_S_BALTST_MYSEQUENCEWITHNILLABLE
  #define INCLUDED_S_BALTST_MYSEQUENCEWITHNILLABLE
  
  #include <bsls_ident.h>
  BSLS_IDENT_RCSID(s_baltst_mysequencewithnillable_h, "$Id$ $CSID$")
  BSLS_IDENT_PRAGMA_ONCE
  
  //@PURPOSE: Provide value-semantic attribute classes
  
  #include <bslalg_typetraits.h>
  
  #include <bdlat_attributeinfo.h>
  
  #include <bdlat_selectioninfo.h>
  
  #include <bdlat_typetraits.h>
  
  #include <bsls_objectbuffer.h>
  
  #include <bslma_default.h>
  
  #include <bsls_assert.h>
  
  #include <bdlb_nullablevalue.h>
  
  #include <bsl_string.h>
  
  #include <bsl_vector.h>
  
  #include <bsl_iosfwd.h>
  #include <bsl_limits.h>
  
  #include <bslma_allocator.h>
  
  namespace BloombergLP {
  
  
  namespace s_baltst { class MySequenceWithNillable; }
  namespace s_baltst { class MySequenceWithNillableBase64Binary; }
  namespace s_baltst { class MySequenceWithNillableHexBinary; }
  namespace s_baltst { class MySequenceWithNillableIntArray; }
  namespace s_baltst { class MySequenceWithNillableIntSequenceArraySequence; }
  namespace s_baltst { class MySequenceWithNillableStringArray; }
  namespace s_baltst { class MySequenceWithNillableStringSequenceArraySequence; }
  namespace s_baltst { class MySequenceWithNillableIntList; }
  namespace s_baltst { class MySequenceWithNillableIntSequenceArray; }
  namespace s_baltst { class MySequenceWithNillableStringList; }
  namespace s_baltst { class MySequenceWithNillableStringSequenceArray; }
  namespace s_baltst {
  
                          // ============================
                          // class MySequenceWithNillable
                          // ============================
  
  class MySequenceWithNillable {
  
      // INSTANCE DATA
      bsl::string                       d_attribute2;
      bdlb::NullableValue<bsl::string>  d_myNillable;
      int                               d_attribute1;
  
    public:
      // TYPES
      enum {
          ATTRIBUTE_ID_ATTRIBUTE1  = 0
        , ATTRIBUTE_ID_MY_NILLABLE = 1
        , ATTRIBUTE_ID_ATTRIBUTE2  = 2
      };
  
      enum {
          NUM_ATTRIBUTES = 3
      };
  
      enum {
          ATTRIBUTE_INDEX_ATTRIBUTE1  = 0
        , ATTRIBUTE_INDEX_MY_NILLABLE = 1
        , ATTRIBUTE_INDEX_ATTRIBUTE2  = 2
      };
  
      // CONSTANTS
      static const char CLASS_NAME[];
  
      static const bdlat_AttributeInfo ATTRIBUTE_INFO_ARRAY[];
  
    public:
      // CLASS METHODS
      static const bdlat_AttributeInfo *lookupAttributeInfo(int id);
          // Return attribute information for the attribute indicated by the
          // specified 'id' if the attribute exists, and 0 otherwise.
  
      static const bdlat_AttributeInfo *lookupAttributeInfo(
                                                         const char *name,
                                                         int         nameLength);
          // Return attribute information for the attribute indicated by the
          // specified 'name' of the specified 'nameLength' if the attribute
          // exists, and 0 otherwise.
  
      // CREATORS
      explicit MySequenceWithNillable(bslma::Allocator *basicAllocator = 0);
          // Create an object of type 'MySequenceWithNillable' having the default
          // value.  Use the optionally specified 'basicAllocator' to supply
          // memory.  If 'basicAllocator' is 0, the currently installed default
          // allocator is used.
  
      MySequenceWithNillable(const MySequenceWithNillable& original,
                             bslma::Allocator *basicAllocator = 0);
          // Create an object of type 'MySequenceWithNillable' having the value
          // of the specified 'original' object.  Use the optionally specified
          // 'basicAllocator' to supply memory.  If 'basicAllocator' is 0, the
          // currently installed default allocator is used.
  
  #if defined(BSLS_COMPILERFEATURES_SUPPORT_RVALUE_REFERENCES) \
   && defined(BSLS_COMPILERFEATURES_SUPPORT_NOEXCEPT)
      MySequenceWithNillable(MySequenceWithNillable&& original) noexcept;
          // Create an object of type 'MySequenceWithNillable' having the value
          // of the specified 'original' object.  After performing this action,
          // the 'original' object will be left in a valid, but unspecified
          // state.
  
      MySequenceWithNillable(MySequenceWithNillable&& original,
                             bslma::Allocator *basicAllocator);
          // Create an object of type 'MySequenceWithNillable' having the value
          // of the specified 'original' object.  After performing this action,
          // the 'original' object will be left in a valid, but unspecified
          // state.  Use the optionally specified 'basicAllocator' to supply
          // memory.  If 'basicAllocator' is 0, the currently installed default
          // allocator is used.
  #endif
  
      ~MySequenceWithNillable();
          // Destroy this object.
  
      // MANIPULATORS
      MySequenceWithNillable& operator=(const MySequenceWithNillable& rhs);
          // Assign to this object the value of the specified 'rhs' object.
  
  #if defined(BSLS_COMPILERFEATURES_SUPPORT_RVALUE_REFERENCES) \
   && defined(BSLS_COMPILERFEATURES_SUPPORT_NOEXCEPT)
      MySequenceWithNillable& operator=(MySequenceWithNillable&& rhs);
          // Assign to this object the value of the specified 'rhs' object.
          // After performing this action, the 'rhs' object will be left in a
          // valid, but unspecified state.
  #endif
  
      void reset();
          // Reset this object to the default value (i.e., its value upon
          // default construction).
  
      template<class MANIPULATOR>
      int manipulateAttributes(MANIPULATOR& manipulator);
          // Invoke the specified 'manipulator' sequentially on the address of
          // each (modifiable) attribute of this object, supplying 'manipulator'
          // with the corresponding attribute information structure until such
          // invocation returns a non-zero value.  Return the value from the
          // last invocation of 'manipulator' (i.e., the invocation that
          // terminated the sequence).
  
      template<class MANIPULATOR>
      int manipulateAttribute(MANIPULATOR& manipulator, int id);
          // Invoke the specified 'manipulator' on the address of
          // the (modifiable) attribute indicated by the specified 'id',
          // supplying 'manipulator' with the corresponding attribute
          // information structure.  Return the value returned from the
          // invocation of 'manipulator' if 'id' identifies an attribute of this
          // class, and -1 otherwise.
  
      template<class MANIPULATOR>
      int manipulateAttribute(MANIPULATOR&  manipulator,
                              const char   *name,
                              int           nameLength);
          // Invoke the specified 'manipulator' on the address of
          // the (modifiable) attribute indicated by the specified 'name' of the
          // specified 'nameLength', supplying 'manipulator' with the
          // corresponding attribute information structure.  Return the value
          // returned from the invocation of 'manipulator' if 'name' identifies
          // an attribute of this class, and -1 otherwise.
  
      int& attribute1();
          // Return a reference to the modifiable "Attribute1" attribute of this
          // object.
  
      bdlb::NullableValue<bsl::string>& myNillable();
          // Return a reference to the modifiable "MyNillable" attribute of this
          // object.
  
      bsl::string& attribute2();
          // Return a reference to the modifiable "Attribute2" attribute of this
          // object.
  
      // ACCESSORS
      bsl::ostream& print(bsl::ostream& stream,
                          int           level = 0,
                          int           spacesPerLevel = 4) const;
          // Format this object to the specified output 'stream' at the
          // optionally specified indentation 'level' and return a reference to
          // the modifiable 'stream'.  If 'level' is specified, optionally
          // specify 'spacesPerLevel', the number of spaces per indentation level
          // for this and all of its nested objects.  Each line is indented by
          // the absolute value of 'level * spacesPerLevel'.  If 'level' is
          // negative, suppress indentation of the first line.  If
          // 'spacesPerLevel' is negative, suppress line breaks and format the
          // entire output on one line.  If 'stream' is initially invalid, this
          // operation has no effect.  Note that a trailing newline is provided
          // in multiline mode only.
  
      template<class ACCESSOR>
      int accessAttributes(ACCESSOR& accessor) const;
          // Invoke the specified 'accessor' sequentially on each
          // (non-modifiable) attribute of this object, supplying 'accessor'
          // with the corresponding attribute information structure until such
          // invocation returns a non-zero value.  Return the value from the
          // last invocation of 'accessor' (i.e., the invocation that terminated
          // the sequence).
  
      template<class ACCESSOR>
      int accessAttribute(ACCESSOR& accessor, int id) const;
          // Invoke the specified 'accessor' on the (non-modifiable) attribute
          // of this object indicated by the specified 'id', supplying 'accessor'
          // with the corresponding attribute information structure.  Return the
          // value returned from the invocation of 'accessor' if 'id' identifies
          // an attribute of this class, and -1 otherwise.
  
      template<class ACCESSOR>
      int accessAttribute(ACCESSOR&   accessor,
                          const char *name,
                          int         nameLength) const;
          // Invoke the specified 'accessor' on the (non-modifiable) attribute
          // of this object indicated by the specified 'name' of the specified
          // 'nameLength', supplying 'accessor' with the corresponding attribute
          // information structure.  Return the value returned from the
          // invocation of 'accessor' if 'name' identifies an attribute of this
          // class, and -1 otherwise.
  
      int attribute1() const;
          // Return the value of the "Attribute1" attribute of this object.
  
      const bdlb::NullableValue<bsl::string>& myNillable() const;
          // Return a reference offering non-modifiable access to the
          // "MyNillable" attribute of this object.
  
      const bsl::string& attribute2() const;
          // Return a reference offering non-modifiable access to the
          // "Attribute2" attribute of this object.
  };
  
  // FREE OPERATORS
  inline
  bool operator==(const MySequenceWithNillable& lhs, const MySequenceWithNillable& rhs);
      // Return 'true' if the specified 'lhs' and 'rhs' attribute objects have
      // the same value, and 'false' otherwise.  Two attribute objects have the
      // same value if each respective attribute has the same value.
  
  inline
  bool operator!=(const MySequenceWithNillable& lhs, const MySequenceWithNillable& rhs);
      // Return 'true' if the specified 'lhs' and 'rhs' attribute objects do not
      // have the same value, and 'false' otherwise.  Two attribute objects do
      // not have the same value if one or more respective attributes differ in
      // values.
  
  inline
  bsl::ostream& operator<<(bsl::ostream& stream, const MySequenceWithNillable& rhs);
      // Format the specified 'rhs' to the specified output 'stream' and
      // return a reference to the modifiable 'stream'.
  
  }  // close package namespace
  
  // TRAITS
  
  BDLAT_DECL_SEQUENCE_WITH_ALLOCATOR_BITWISEMOVEABLE_TRAITS(s_baltst::MySequenceWithNillable)
  
  namespace s_baltst {
  
                    // ========================================
                    // class MySequenceWithNillableBase64Binary
                    // ========================================
  
  class MySequenceWithNillableBase64Binary {
  
      // INSTANCE DATA
      bdlb::NullableValue<bsl::vector<char> >  d_attribute1;
  
    public:
      // TYPES
      enum {
          ATTRIBUTE_ID_ATTRIBUTE1 = 0
      };
  
      enum {
          NUM_ATTRIBUTES = 1
      };
  
      enum {
          ATTRIBUTE_INDEX_ATTRIBUTE1 = 0
      };
  
      // CONSTANTS
      static const char CLASS_NAME[];
  
      static const bdlat_AttributeInfo ATTRIBUTE_INFO_ARRAY[];
  
    public:
      // CLASS METHODS
      static const bdlat_AttributeInfo *lookupAttributeInfo(int id);
          // Return attribute information for the attribute indicated by the
          // specified 'id' if the attribute exists, and 0 otherwise.
  
      static const bdlat_AttributeInfo *lookupAttributeInfo(
                                                         const char *name,
                                                         int         nameLength);
          // Return attribute information for the attribute indicated by the
          // specified 'name' of the specified 'nameLength' if the attribute
          // exists, and 0 otherwise.
  
      // CREATORS
      explicit MySequenceWithNillableBase64Binary(bslma::Allocator *basicAllocator = 0);
          // Create an object of type 'MySequenceWithNillableBase64Binary' having
          // the default value.  Use the optionally specified 'basicAllocator' to
          // supply memory.  If 'basicAllocator' is 0, the currently installed
          // default allocator is used.
  
      MySequenceWithNillableBase64Binary(const MySequenceWithNillableBase64Binary& original,
                                         bslma::Allocator *basicAllocator = 0);
          // Create an object of type 'MySequenceWithNillableBase64Binary' having
          // the value of the specified 'original' object.  Use the optionally
          // specified 'basicAllocator' to supply memory.  If 'basicAllocator' is
          // 0, the currently installed default allocator is used.
  
  #if defined(BSLS_COMPILERFEATURES_SUPPORT_RVALUE_REFERENCES) \
   && defined(BSLS_COMPILERFEATURES_SUPPORT_NOEXCEPT)
      MySequenceWithNillableBase64Binary(MySequenceWithNillableBase64Binary&& original) noexcept;
          // Create an object of type 'MySequenceWithNillableBase64Binary' having
          // the value of the specified 'original' object.  After performing this
          // action, the 'original' object will be left in a valid, but
          // unspecified state.
  
      MySequenceWithNillableBase64Binary(MySequenceWithNillableBase64Binary&& original,
                                         bslma::Allocator *basicAllocator);
          // Create an object of type 'MySequenceWithNillableBase64Binary' having
          // the value of the specified 'original' object.  After performing this
          // action, the 'original' object will be left in a valid, but
          // unspecified state.  Use the optionally specified 'basicAllocator' to
          // supply memory.  If 'basicAllocator' is 0, the currently installed
          // default allocator is used.
  #endif
  
      ~MySequenceWithNillableBase64Binary();
          // Destroy this object.
  
      // MANIPULATORS
      MySequenceWithNillableBase64Binary& operator=(const MySequenceWithNillableBase64Binary& rhs);
          // Assign to this object the value of the specified 'rhs' object.
  
  #if defined(BSLS_COMPILERFEATURES_SUPPORT_RVALUE_REFERENCES) \
   && defined(BSLS_COMPILERFEATURES_SUPPORT_NOEXCEPT)
      MySequenceWithNillableBase64Binary& operator=(MySequenceWithNillableBase64Binary&& rhs);
          // Assign to this object the value of the specified 'rhs' object.
          // After performing this action, the 'rhs' object will be left in a
          // valid, but unspecified state.
  #endif
  
      void reset();
          // Reset this object to the default value (i.e., its value upon
          // default construction).
  
      template<class MANIPULATOR>
      int manipulateAttributes(MANIPULATOR& manipulator);
          // Invoke the specified 'manipulator' sequentially on the address of
          // each (modifiable) attribute of this object, supplying 'manipulator'
          // with the corresponding attribute information structure until such
          // invocation returns a non-zero value.  Return the value from the
          // last invocation of 'manipulator' (i.e., the invocation that
          // terminated the sequence).
  
      template<class MANIPULATOR>
      int manipulateAttribute(MANIPULATOR& manipulator, int id);
          // Invoke the specified 'manipulator' on the address of
          // the (modifiable) attribute indicated by the specified 'id',
          // supplying 'manipulator' with the corresponding attribute
          // information structure.  Return the value returned from the
          // invocation of 'manipulator' if 'id' identifies an attribute of this
          // class, and -1 otherwise.
  
      template<class MANIPULATOR>
      int manipulateAttribute(MANIPULATOR&  manipulator,
                              const char   *name,
                              int           nameLength);
          // Invoke the specified 'manipulator' on the address of
          // the (modifiable) attribute indicated by the specified 'name' of the
          // specified 'nameLength', supplying 'manipulator' with the
          // corresponding attribute information structure.  Return the value
          // returned from the invocation of 'manipulator' if 'name' identifies
          // an attribute of this class, and -1 otherwise.
  
      bdlb::NullableValue<bsl::vector<char> >& attribute1();
          // Return a reference to the modifiable "Attribute1" attribute of this
          // object.
  
      // ACCESSORS
      bsl::ostream& print(bsl::ostream& stream,
                          int           level = 0,
                          int           spacesPerLevel = 4) const;
          // Format this object to the specified output 'stream' at the
          // optionally specified indentation 'level' and return a reference to
          // the modifiable 'stream'.  If 'level' is specified, optionally
          // specify 'spacesPerLevel', the number of spaces per indentation level
          // for this and all of its nested objects.  Each line is indented by
          // the absolute value of 'level * spacesPerLevel'.  If 'level' is
          // negative, suppress indentation of the first line.  If
          // 'spacesPerLevel' is negative, suppress line breaks and format the
          // entire output on one line.  If 'stream' is initially invalid, this
          // operation has no effect.  Note that a trailing newline is provided
          // in multiline mode only.
  
      template<class ACCESSOR>
      int accessAttributes(ACCESSOR& accessor) const;
          // Invoke the specified 'accessor' sequentially on each
          // (non-modifiable) attribute of this object, supplying 'accessor'
          // with the corresponding attribute information structure until such
          // invocation returns a non-zero value.  Return the value from the
          // last invocation of 'accessor' (i.e., the invocation that terminated
          // the sequence).
  
      template<class ACCESSOR>
      int accessAttribute(ACCESSOR& accessor, int id) const;
          // Invoke the specified 'accessor' on the (non-modifiable) attribute
          // of this object indicated by the specified 'id', supplying 'accessor'
          // with the corresponding attribute information structure.  Return the
          // value returned from the invocation of 'accessor' if 'id' identifies
          // an attribute of this class, and -1 otherwise.
  
      template<class ACCESSOR>
      int accessAttribute(ACCESSOR&   accessor,
                          const char *name,
                          int         nameLength) const;
          // Invoke the specified 'accessor' on the (non-modifiable) attribute
          // of this object indicated by the specified 'name' of the specified
          // 'nameLength', supplying 'accessor' with the corresponding attribute
          // information structure.  Return the value returned from the
          // invocation of 'accessor' if 'name' identifies an attribute of this
          // class, and -1 otherwise.
  
      const bdlb::NullableValue<bsl::vector<char> >& attribute1() const;
          // Return a reference offering non-modifiable access to the
          // "Attribute1" attribute of this object.
  };
  
  // FREE OPERATORS
  inline
  bool operator==(const MySequenceWithNillableBase64Binary& lhs, const MySequenceWithNillableBase64Binary& rhs);
      // Return 'true' if the specified 'lhs' and 'rhs' attribute objects have
      // the same value, and 'false' otherwise.  Two attribute objects have the
      // same value if each respective attribute has the same value.
  
  inline
  bool operator!=(const MySequenceWithNillableBase64Binary& lhs, const MySequenceWithNillableBase64Binary& rhs);
      // Return 'true' if the specified 'lhs' and 'rhs' attribute objects do not
      // have the same value, and 'false' otherwise.  Two attribute objects do
      // not have the same value if one or more respective attributes differ in
      // values.
  
  inline
  bsl::ostream& operator<<(bsl::ostream& stream, const MySequenceWithNillableBase64Binary& rhs);
      // Format the specified 'rhs' to the specified output 'stream' and
      // return a reference to the modifiable 'stream'.
  
  }  // close package namespace
  
  // TRAITS
  
  BDLAT_DECL_SEQUENCE_WITH_ALLOCATOR_BITWISEMOVEABLE_TRAITS(s_baltst::MySequenceWithNillableBase64Binary)
  
  namespace s_baltst {
  
                     // =====================================
                     // class MySequenceWithNillableHexBinary
                     // =====================================
  
  class MySequenceWithNillableHexBinary {
  
      // INSTANCE DATA
      bdlb::NullableValue<bsl::vector<char> >  d_attribute1;
  
    public:
      // TYPES
      enum {
          ATTRIBUTE_ID_ATTRIBUTE1 = 0
      };
  
      enum {
          NUM_ATTRIBUTES = 1
      };
  
      enum {
          ATTRIBUTE_INDEX_ATTRIBUTE1 = 0
      };
  
      // CONSTANTS
      static const char CLASS_NAME[];
  
      static const bdlat_AttributeInfo ATTRIBUTE_INFO_ARRAY[];
  
    public:
      // CLASS METHODS
      static const bdlat_AttributeInfo *lookupAttributeInfo(int id);
          // Return attribute information for the attribute indicated by the
          // specified 'id' if the attribute exists, and 0 otherwise.
  
      static const bdlat_AttributeInfo *lookupAttributeInfo(
                                                         const char *name,
                                                         int         nameLength);
          // Return attribute information for the attribute indicated by the
          // specified 'name' of the specified 'nameLength' if the attribute
          // exists, and 0 otherwise.
  
      // CREATORS
      explicit MySequenceWithNillableHexBinary(bslma::Allocator *basicAllocator = 0);
          // Create an object of type 'MySequenceWithNillableHexBinary' having
          // the default value.  Use the optionally specified 'basicAllocator' to
          // supply memory.  If 'basicAllocator' is 0, the currently installed
          // default allocator is used.
  
      MySequenceWithNillableHexBinary(const MySequenceWithNillableHexBinary& original,
                                      bslma::Allocator *basicAllocator = 0);
          // Create an object of type 'MySequenceWithNillableHexBinary' having
          // the value of the specified 'original' object.  Use the optionally
          // specified 'basicAllocator' to supply memory.  If 'basicAllocator' is
          // 0, the currently installed default allocator is used.
  
  #if defined(BSLS_COMPILERFEATURES_SUPPORT_RVALUE_REFERENCES) \
   && defined(BSLS_COMPILERFEATURES_SUPPORT_NOEXCEPT)
      MySequenceWithNillableHexBinary(MySequenceWithNillableHexBinary&& original) noexcept;
          // Create an object of type 'MySequenceWithNillableHexBinary' having
          // the value of the specified 'original' object.  After performing this
          // action, the 'original' object will be left in a valid, but
          // unspecified state.
  
      MySequenceWithNillableHexBinary(MySequenceWithNillableHexBinary&& original,
                                      bslma::Allocator *basicAllocator);
          // Create an object of type 'MySequenceWithNillableHexBinary' having
          // the value of the specified 'original' object.  After performing this
          // action, the 'original' object will be left in a valid, but
          // unspecified state.  Use the optionally specified 'basicAllocator' to
          // supply memory.  If 'basicAllocator' is 0, the currently installed
          // default allocator is used.
  #endif
  
      ~MySequenceWithNillableHexBinary();
          // Destroy this object.
  
      // MANIPULATORS
      MySequenceWithNillableHexBinary& operator=(const MySequenceWithNillableHexBinary& rhs);
          // Assign to this object the value of the specified 'rhs' object.
  
  #if defined(BSLS_COMPILERFEATURES_SUPPORT_RVALUE_REFERENCES) \
   && defined(BSLS_COMPILERFEATURES_SUPPORT_NOEXCEPT)
      MySequenceWithNillableHexBinary& operator=(MySequenceWithNillableHexBinary&& rhs);
          // Assign to this object the value of the specified 'rhs' object.
          // After performing this action, the 'rhs' object will be left in a
          // valid, but unspecified state.
  #endif
  
      void reset();
          // Reset this object to the default value (i.e., its value upon
          // default construction).
  
      template<class MANIPULATOR>
      int manipulateAttributes(MANIPULATOR& manipulator);
          // Invoke the specified 'manipulator' sequentially on the address of
          // each (modifiable) attribute of this object, supplying 'manipulator'
          // with the corresponding attribute information structure until such
          // invocation returns a non-zero value.  Return the value from the
          // last invocation of 'manipulator' (i.e., the invocation that
          // terminated the sequence).
  
      template<class MANIPULATOR>
      int manipulateAttribute(MANIPULATOR& manipulator, int id);
          // Invoke the specified 'manipulator' on the address of
          // the (modifiable) attribute indicated by the specified 'id',
          // supplying 'manipulator' with the corresponding attribute
          // information structure.  Return the value returned from the
          // invocation of 'manipulator' if 'id' identifies an attribute of this
          // class, and -1 otherwise.
  
      template<class MANIPULATOR>
      int manipulateAttribute(MANIPULATOR&  manipulator,
                              const char   *name,
                              int           nameLength);
          // Invoke the specified 'manipulator' on the address of
          // the (modifiable) attribute indicated by the specified 'name' of the
          // specified 'nameLength', supplying 'manipulator' with the
          // corresponding attribute information structure.  Return the value
          // returned from the invocation of 'manipulator' if 'name' identifies
          // an attribute of this class, and -1 otherwise.
  
      bdlb::NullableValue<bsl::vector<char> >& attribute1();
          // Return a reference to the modifiable "Attribute1" attribute of this
          // object.
  
      // ACCESSORS
      bsl::ostream& print(bsl::ostream& stream,
                          int           level = 0,
                          int           spacesPerLevel = 4) const;
          // Format this object to the specified output 'stream' at the
          // optionally specified indentation 'level' and return a reference to
          // the modifiable 'stream'.  If 'level' is specified, optionally
          // specify 'spacesPerLevel', the number of spaces per indentation level
          // for this and all of its nested objects.  Each line is indented by
          // the absolute value of 'level * spacesPerLevel'.  If 'level' is
          // negative, suppress indentation of the first line.  If
          // 'spacesPerLevel' is negative, suppress line breaks and format the
          // entire output on one line.  If 'stream' is initially invalid, this
          // operation has no effect.  Note that a trailing newline is provided
          // in multiline mode only.
  
      template<class ACCESSOR>
      int accessAttributes(ACCESSOR& accessor) const;
          // Invoke the specified 'accessor' sequentially on each
          // (non-modifiable) attribute of this object, supplying 'accessor'
          // with the corresponding attribute information structure until such
          // invocation returns a non-zero value.  Return the value from the
          // last invocation of 'accessor' (i.e., the invocation that terminated
          // the sequence).
  
      template<class ACCESSOR>
      int accessAttribute(ACCESSOR& accessor, int id) const;
          // Invoke the specified 'accessor' on the (non-modifiable) attribute
          // of this object indicated by the specified 'id', supplying 'accessor'
          // with the corresponding attribute information structure.  Return the
          // value returned from the invocation of 'accessor' if 'id' identifies
          // an attribute of this class, and -1 otherwise.
  
      template<class ACCESSOR>
      int accessAttribute(ACCESSOR&   accessor,
                          const char *name,
                          int         nameLength) const;
          // Invoke the specified 'accessor' on the (non-modifiable) attribute
          // of this object indicated by the specified 'name' of the specified
          // 'nameLength', supplying 'accessor' with the corresponding attribute
          // information structure.  Return the value returned from the
          // invocation of 'accessor' if 'name' identifies an attribute of this
          // class, and -1 otherwise.
  
      const bdlb::NullableValue<bsl::vector<char> >& attribute1() const;
          // Return a reference offering non-modifiable access to the
          // "Attribute1" attribute of this object.
  };
  
  // FREE OPERATORS
  inline
  bool operator==(const MySequenceWithNillableHexBinary& lhs, const MySequenceWithNillableHexBinary& rhs);
      // Return 'true' if the specified 'lhs' and 'rhs' attribute objects have
      // the same value, and 'false' otherwise.  Two attribute objects have the
      // same value if each respective attribute has the same value.
  
  inline
  bool operator!=(const MySequenceWithNillableHexBinary& lhs, const MySequenceWithNillableHexBinary& rhs);
      // Return 'true' if the specified 'lhs' and 'rhs' attribute objects do not
      // have the same value, and 'false' otherwise.  Two attribute objects do
      // not have the same value if one or more respective attributes differ in
      // values.
  
  inline
  bsl::ostream& operator<<(bsl::ostream& stream, const MySequenceWithNillableHexBinary& rhs);
      // Format the specified 'rhs' to the specified output 'stream' and
      // return a reference to the modifiable 'stream'.
  
  }  // close package namespace
  
  // TRAITS
  
  BDLAT_DECL_SEQUENCE_WITH_ALLOCATOR_BITWISEMOVEABLE_TRAITS(s_baltst::MySequenceWithNillableHexBinary)
  
  namespace s_baltst {
  
                      // ====================================
                      // class MySequenceWithNillableIntArray
                      // ====================================
  
  class MySequenceWithNillableIntArray {
  
      // INSTANCE DATA
      bsl::vector<bdlb::NullableValue<int> >  d_attribute1;
  
    public:
      // TYPES
      enum {
          ATTRIBUTE_ID_ATTRIBUTE1 = 0
      };
  
      enum {
          NUM_ATTRIBUTES = 1
      };
  
      enum {
          ATTRIBUTE_INDEX_ATTRIBUTE1 = 0
      };
  
      // CONSTANTS
      static const char CLASS_NAME[];
  
      static const bdlat_AttributeInfo ATTRIBUTE_INFO_ARRAY[];
  
    public:
      // CLASS METHODS
      static const bdlat_AttributeInfo *lookupAttributeInfo(int id);
          // Return attribute information for the attribute indicated by the
          // specified 'id' if the attribute exists, and 0 otherwise.
  
      static const bdlat_AttributeInfo *lookupAttributeInfo(
                                                         const char *name,
                                                         int         nameLength);
          // Return attribute information for the attribute indicated by the
          // specified 'name' of the specified 'nameLength' if the attribute
          // exists, and 0 otherwise.
  
      // CREATORS
      explicit MySequenceWithNillableIntArray(bslma::Allocator *basicAllocator = 0);
          // Create an object of type 'MySequenceWithNillableIntArray' having the
          // default value.  Use the optionally specified 'basicAllocator' to
          // supply memory.  If 'basicAllocator' is 0, the currently installed
          // default allocator is used.
  
      MySequenceWithNillableIntArray(const MySequenceWithNillableIntArray& original,
                                     bslma::Allocator *basicAllocator = 0);
          // Create an object of type 'MySequenceWithNillableIntArray' having the
          // value of the specified 'original' object.  Use the optionally
          // specified 'basicAllocator' to supply memory.  If 'basicAllocator' is
          // 0, the currently installed default allocator is used.
  
  #if defined(BSLS_COMPILERFEATURES_SUPPORT_RVALUE_REFERENCES) \
   && defined(BSLS_COMPILERFEATURES_SUPPORT_NOEXCEPT)
      MySequenceWithNillableIntArray(MySequenceWithNillableIntArray&& original) noexcept;
          // Create an object of type 'MySequenceWithNillableIntArray' having the
          // value of the specified 'original' object.  After performing this
          // action, the 'original' object will be left in a valid, but
          // unspecified state.
  
      MySequenceWithNillableIntArray(MySequenceWithNillableIntArray&& original,
                                     bslma::Allocator *basicAllocator);
          // Create an object of type 'MySequenceWithNillableIntArray' having the
          // value of the specified 'original' object.  After performing this
          // action, the 'original' object will be left in a valid, but
          // unspecified state.  Use the optionally specified 'basicAllocator' to
          // supply memory.  If 'basicAllocator' is 0, the currently installed
          // default allocator is used.
  #endif
  
      ~MySequenceWithNillableIntArray();
          // Destroy this object.
  
      // MANIPULATORS
      MySequenceWithNillableIntArray& operator=(const MySequenceWithNillableIntArray& rhs);
          // Assign to this object the value of the specified 'rhs' object.
  
  #if defined(BSLS_COMPILERFEATURES_SUPPORT_RVALUE_REFERENCES) \
   && defined(BSLS_COMPILERFEATURES_SUPPORT_NOEXCEPT)
      MySequenceWithNillableIntArray& operator=(MySequenceWithNillableIntArray&& rhs);
          // Assign to this object the value of the specified 'rhs' object.
          // After performing this action, the 'rhs' object will be left in a
          // valid, but unspecified state.
  #endif
  
      void reset();
          // Reset this object to the default value (i.e., its value upon
          // default construction).
  
      template<class MANIPULATOR>
      int manipulateAttributes(MANIPULATOR& manipulator);
          // Invoke the specified 'manipulator' sequentially on the address of
          // each (modifiable) attribute of this object, supplying 'manipulator'
          // with the corresponding attribute information structure until such
          // invocation returns a non-zero value.  Return the value from the
          // last invocation of 'manipulator' (i.e., the invocation that
          // terminated the sequence).
  
      template<class MANIPULATOR>
      int manipulateAttribute(MANIPULATOR& manipulator, int id);
          // Invoke the specified 'manipulator' on the address of
          // the (modifiable) attribute indicated by the specified 'id',
          // supplying 'manipulator' with the corresponding attribute
          // information structure.  Return the value returned from the
          // invocation of 'manipulator' if 'id' identifies an attribute of this
          // class, and -1 otherwise.
  
      template<class MANIPULATOR>
      int manipulateAttribute(MANIPULATOR&  manipulator,
                              const char   *name,
                              int           nameLength);
          // Invoke the specified 'manipulator' on the address of
          // the (modifiable) attribute indicated by the specified 'name' of the
          // specified 'nameLength', supplying 'manipulator' with the
          // corresponding attribute information structure.  Return the value
          // returned from the invocation of 'manipulator' if 'name' identifies
          // an attribute of this class, and -1 otherwise.
  
      bsl::vector<bdlb::NullableValue<int> >& attribute1();
          // Return a reference to the modifiable "Attribute1" attribute of this
          // object.
  
      // ACCESSORS
      bsl::ostream& print(bsl::ostream& stream,
                          int           level = 0,
                          int           spacesPerLevel = 4) const;
          // Format this object to the specified output 'stream' at the
          // optionally specified indentation 'level' and return a reference to
          // the modifiable 'stream'.  If 'level' is specified, optionally
          // specify 'spacesPerLevel', the number of spaces per indentation level
          // for this and all of its nested objects.  Each line is indented by
          // the absolute value of 'level * spacesPerLevel'.  If 'level' is
          // negative, suppress indentation of the first line.  If
          // 'spacesPerLevel' is negative, suppress line breaks and format the
          // entire output on one line.  If 'stream' is initially invalid, this
          // operation has no effect.  Note that a trailing newline is provided
          // in multiline mode only.
  
      template<class ACCESSOR>
      int accessAttributes(ACCESSOR& accessor) const;
          // Invoke the specified 'accessor' sequentially on each
          // (non-modifiable) attribute of this object, supplying 'accessor'
          // with the corresponding attribute information structure until such
          // invocation returns a non-zero value.  Return the value from the
          // last invocation of 'accessor' (i.e., the invocation that terminated
          // the sequence).
  
      template<class ACCESSOR>
      int accessAttribute(ACCESSOR& accessor, int id) const;
          // Invoke the specified 'accessor' on the (non-modifiable) attribute
          // of this object indicated by the specified 'id', supplying 'accessor'
          // with the corresponding attribute information structure.  Return the
          // value returned from the invocation of 'accessor' if 'id' identifies
          // an attribute of this class, and -1 otherwise.
  
      template<class ACCESSOR>
      int accessAttribute(ACCESSOR&   accessor,
                          const char *name,
                          int         nameLength) const;
          // Invoke the specified 'accessor' on the (non-modifiable) attribute
          // of this object indicated by the specified 'name' of the specified
          // 'nameLength', supplying 'accessor' with the corresponding attribute
          // information structure.  Return the value returned from the
          // invocation of 'accessor' if 'name' identifies an attribute of this
          // class, and -1 otherwise.
  
      const bsl::vector<bdlb::NullableValue<int> >& attribute1() const;
          // Return a reference offering non-modifiable access to the
          // "Attribute1" attribute of this object.
  };
  
  // FREE OPERATORS
  inline
  bool operator==(const MySequenceWithNillableIntArray& lhs, const MySequenceWithNillableIntArray& rhs);
      // Return 'true' if the specified 'lhs' and 'rhs' attribute objects have
      // the same value, and 'false' otherwise.  Two attribute objects have the
      // same value if each respective attribute has the same value.
  
  inline
  bool operator!=(const MySequenceWithNillableIntArray& lhs, const MySequenceWithNillableIntArray& rhs);
      // Return 'true' if the specified 'lhs' and 'rhs' attribute objects do not
      // have the same value, and 'false' otherwise.  Two attribute objects do
      // not have the same value if one or more respective attributes differ in
      // values.
  
  inline
  bsl::ostream& operator<<(bsl::ostream& stream, const MySequenceWithNillableIntArray& rhs);
      // Format the specified 'rhs' to the specified output 'stream' and
      // return a reference to the modifiable 'stream'.
  
  }  // close package namespace
  
  // TRAITS
  
  BDLAT_DECL_SEQUENCE_WITH_ALLOCATOR_BITWISEMOVEABLE_TRAITS(s_baltst::MySequenceWithNillableIntArray)
  
  namespace s_baltst {
  
              // ====================================================
              // class MySequenceWithNillableIntSequenceArraySequence
              // ====================================================
  
  class MySequenceWithNillableIntSequenceArraySequence {
  
      // INSTANCE DATA
      int  d_attribute1;
  
    public:
      // TYPES
      enum {
          ATTRIBUTE_ID_ATTRIBUTE1 = 0
      };
  
      enum {
          NUM_ATTRIBUTES = 1
      };
  
      enum {
          ATTRIBUTE_INDEX_ATTRIBUTE1 = 0
      };
  
      // CONSTANTS
      static const char CLASS_NAME[];
  
      static const bdlat_AttributeInfo ATTRIBUTE_INFO_ARRAY[];
  
    public:
      // CLASS METHODS
      static const bdlat_AttributeInfo *lookupAttributeInfo(int id);
          // Return attribute information for the attribute indicated by the
          // specified 'id' if the attribute exists, and 0 otherwise.
  
      static const bdlat_AttributeInfo *lookupAttributeInfo(
                                                         const char *name,
                                                         int         nameLength);
          // Return attribute information for the attribute indicated by the
          // specified 'name' of the specified 'nameLength' if the attribute
          // exists, and 0 otherwise.
  
      // CREATORS
      MySequenceWithNillableIntSequenceArraySequence();
          // Create an object of type
          // 'MySequenceWithNillableIntSequenceArraySequence' having the default
          // value.
  
      MySequenceWithNillableIntSequenceArraySequence(const MySequenceWithNillableIntSequenceArraySequence& original);
          // Create an object of type
          // 'MySequenceWithNillableIntSequenceArraySequence' having the value of
          // the specified 'original' object.
  
  #if defined(BSLS_COMPILERFEATURES_SUPPORT_RVALUE_REFERENCES) \
   && defined(BSLS_COMPILERFEATURES_SUPPORT_NOEXCEPT)
      MySequenceWithNillableIntSequenceArraySequence(MySequenceWithNillableIntSequenceArraySequence&& original) = default;
          // Create an object of type
          // 'MySequenceWithNillableIntSequenceArraySequence' having the value of
          // the specified 'original' object.  After performing this action, the
          // 'original' object will be left in a valid, but unspecified state.
  #endif
  
      ~MySequenceWithNillableIntSequenceArraySequence();
          // Destroy this object.
  
      // MANIPULATORS
      MySequenceWithNillableIntSequenceArraySequence& operator=(const MySequenceWithNillableIntSequenceArraySequence& rhs);
          // Assign to this object the value of the specified 'rhs' object.
  
  #if defined(BSLS_COMPILERFEATURES_SUPPORT_RVALUE_REFERENCES) \
   && defined(BSLS_COMPILERFEATURES_SUPPORT_NOEXCEPT)
      MySequenceWithNillableIntSequenceArraySequence& operator=(MySequenceWithNillableIntSequenceArraySequence&& rhs);
          // Assign to this object the value of the specified 'rhs' object.
          // After performing this action, the 'rhs' object will be left in a
          // valid, but unspecified state.
  #endif
  
      void reset();
          // Reset this object to the default value (i.e., its value upon
          // default construction).
  
      template<class MANIPULATOR>
      int manipulateAttributes(MANIPULATOR& manipulator);
          // Invoke the specified 'manipulator' sequentially on the address of
          // each (modifiable) attribute of this object, supplying 'manipulator'
          // with the corresponding attribute information structure until such
          // invocation returns a non-zero value.  Return the value from the
          // last invocation of 'manipulator' (i.e., the invocation that
          // terminated the sequence).
  
      template<class MANIPULATOR>
      int manipulateAttribute(MANIPULATOR& manipulator, int id);
          // Invoke the specified 'manipulator' on the address of
          // the (modifiable) attribute indicated by the specified 'id',
          // supplying 'manipulator' with the corresponding attribute
          // information structure.  Return the value returned from the
          // invocation of 'manipulator' if 'id' identifies an attribute of this
          // class, and -1 otherwise.
  
      template<class MANIPULATOR>
      int manipulateAttribute(MANIPULATOR&  manipulator,
                              const char   *name,
                              int           nameLength);
          // Invoke the specified 'manipulator' on the address of
          // the (modifiable) attribute indicated by the specified 'name' of the
          // specified 'nameLength', supplying 'manipulator' with the
          // corresponding attribute information structure.  Return the value
          // returned from the invocation of 'manipulator' if 'name' identifies
          // an attribute of this class, and -1 otherwise.
  
      int& attribute1();
          // Return a reference to the modifiable "Attribute1" attribute of this
          // object.
  
      // ACCESSORS
      bsl::ostream& print(bsl::ostream& stream,
                          int           level = 0,
                          int           spacesPerLevel = 4) const;
          // Format this object to the specified output 'stream' at the
          // optionally specified indentation 'level' and return a reference to
          // the modifiable 'stream'.  If 'level' is specified, optionally
          // specify 'spacesPerLevel', the number of spaces per indentation level
          // for this and all of its nested objects.  Each line is indented by
          // the absolute value of 'level * spacesPerLevel'.  If 'level' is
          // negative, suppress indentation of the first line.  If
          // 'spacesPerLevel' is negative, suppress line breaks and format the
          // entire output on one line.  If 'stream' is initially invalid, this
          // operation has no effect.  Note that a trailing newline is provided
          // in multiline mode only.
  
      template<class ACCESSOR>
      int accessAttributes(ACCESSOR& accessor) const;
          // Invoke the specified 'accessor' sequentially on each
          // (non-modifiable) attribute of this object, supplying 'accessor'
          // with the corresponding attribute information structure until such
          // invocation returns a non-zero value.  Return the value from the
          // last invocation of 'accessor' (i.e., the invocation that terminated
          // the sequence).
  
      template<class ACCESSOR>
      int accessAttribute(ACCESSOR& accessor, int id) const;
          // Invoke the specified 'accessor' on the (non-modifiable) attribute
          // of this object indicated by the specified 'id', supplying 'accessor'
          // with the corresponding attribute information structure.  Return the
          // value returned from the invocation of 'accessor' if 'id' identifies
          // an attribute of this class, and -1 otherwise.
  
      template<class ACCESSOR>
      int accessAttribute(ACCESSOR&   accessor,
                          const char *name,
                          int         nameLength) const;
          // Invoke the specified 'accessor' on the (non-modifiable) attribute
          // of this object indicated by the specified 'name' of the specified
          // 'nameLength', supplying 'accessor' with the corresponding attribute
          // information structure.  Return the value returned from the
          // invocation of 'accessor' if 'name' identifies an attribute of this
          // class, and -1 otherwise.
  
      int attribute1() const;
          // Return the value of the "Attribute1" attribute of this object.
  };
  
  // FREE OPERATORS
  inline
  bool operator==(const MySequenceWithNillableIntSequenceArraySequence& lhs, const MySequenceWithNillableIntSequenceArraySequence& rhs);
      // Return 'true' if the specified 'lhs' and 'rhs' attribute objects have
      // the same value, and 'false' otherwise.  Two attribute objects have the
      // same value if each respective attribute has the same value.
  
  inline
  bool operator!=(const MySequenceWithNillableIntSequenceArraySequence& lhs, const MySequenceWithNillableIntSequenceArraySequence& rhs);
      // Return 'true' if the specified 'lhs' and 'rhs' attribute objects do not
      // have the same value, and 'false' otherwise.  Two attribute objects do
      // not have the same value if one or more respective attributes differ in
      // values.
  
  inline
  bsl::ostream& operator<<(bsl::ostream& stream, const MySequenceWithNillableIntSequenceArraySequence& rhs);
      // Format the specified 'rhs' to the specified output 'stream' and
      // return a reference to the modifiable 'stream'.
  
  }  // close package namespace
  
  // TRAITS
  
  BDLAT_DECL_SEQUENCE_WITH_BITWISEMOVEABLE_TRAITS(s_baltst::MySequenceWithNillableIntSequenceArraySequence)
  
  namespace s_baltst {
  
                    // =======================================
                    // class MySequenceWithNillableStringArray
                    // =======================================
  
  class MySequenceWithNillableStringArray {
  
      // INSTANCE DATA
      bsl::vector<bdlb::NullableValue<bsl::string> >  d_attribute1;
  
    public:
      // TYPES
      enum {
          ATTRIBUTE_ID_ATTRIBUTE1 = 0
      };
  
      enum {
          NUM_ATTRIBUTES = 1
      };
  
      enum {
          ATTRIBUTE_INDEX_ATTRIBUTE1 = 0
      };
  
      // CONSTANTS
      static const char CLASS_NAME[];
  
      static const bdlat_AttributeInfo ATTRIBUTE_INFO_ARRAY[];
  
    public:
      // CLASS METHODS
      static const bdlat_AttributeInfo *lookupAttributeInfo(int id);
          // Return attribute information for the attribute indicated by the
          // specified 'id' if the attribute exists, and 0 otherwise.
  
      static const bdlat_AttributeInfo *lookupAttributeInfo(
                                                         const char *name,
                                                         int         nameLength);
          // Return attribute information for the attribute indicated by the
          // specified 'name' of the specified 'nameLength' if the attribute
          // exists, and 0 otherwise.
  
      // CREATORS
      explicit MySequenceWithNillableStringArray(bslma::Allocator *basicAllocator = 0);
          // Create an object of type 'MySequenceWithNillableStringArray' having
          // the default value.  Use the optionally specified 'basicAllocator' to
          // supply memory.  If 'basicAllocator' is 0, the currently installed
          // default allocator is used.
  
      MySequenceWithNillableStringArray(const MySequenceWithNillableStringArray& original,
                                        bslma::Allocator *basicAllocator = 0);
          // Create an object of type 'MySequenceWithNillableStringArray' having
          // the value of the specified 'original' object.  Use the optionally
          // specified 'basicAllocator' to supply memory.  If 'basicAllocator' is
          // 0, the currently installed default allocator is used.
  
  #if defined(BSLS_COMPILERFEATURES_SUPPORT_RVALUE_REFERENCES) \
   && defined(BSLS_COMPILERFEATURES_SUPPORT_NOEXCEPT)
      MySequenceWithNillableStringArray(MySequenceWithNillableStringArray&& original) noexcept;
          // Create an object of type 'MySequenceWithNillableStringArray' having
          // the value of the specified 'original' object.  After performing this
          // action, the 'original' object will be left in a valid, but
          // unspecified state.
  
      MySequenceWithNillableStringArray(MySequenceWithNillableStringArray&& original,
                                        bslma::Allocator *basicAllocator);
          // Create an object of type 'MySequenceWithNillableStringArray' having
          // the value of the specified 'original' object.  After performing this
          // action, the 'original' object will be left in a valid, but
          // unspecified state.  Use the optionally specified 'basicAllocator' to
          // supply memory.  If 'basicAllocator' is 0, the currently installed
          // default allocator is used.
  #endif
  
      ~MySequenceWithNillableStringArray();
          // Destroy this object.
  
      // MANIPULATORS
      MySequenceWithNillableStringArray& operator=(const MySequenceWithNillableStringArray& rhs);
          // Assign to this object the value of the specified 'rhs' object.
  
  #if defined(BSLS_COMPILERFEATURES_SUPPORT_RVALUE_REFERENCES) \
   && defined(BSLS_COMPILERFEATURES_SUPPORT_NOEXCEPT)
      MySequenceWithNillableStringArray& operator=(MySequenceWithNillableStringArray&& rhs);
          // Assign to this object the value of the specified 'rhs' object.
          // After performing this action, the 'rhs' object will be left in a
          // valid, but unspecified state.
  #endif
  
      void reset();
          // Reset this object to the default value (i.e., its value upon
          // default construction).
  
      template<class MANIPULATOR>
      int manipulateAttributes(MANIPULATOR& manipulator);
          // Invoke the specified 'manipulator' sequentially on the address of
          // each (modifiable) attribute of this object, supplying 'manipulator'
          // with the corresponding attribute information structure until such
          // invocation returns a non-zero value.  Return the value from the
          // last invocation of 'manipulator' (i.e., the invocation that
          // terminated the sequence).
  
      template<class MANIPULATOR>
      int manipulateAttribute(MANIPULATOR& manipulator, int id);
          // Invoke the specified 'manipulator' on the address of
          // the (modifiable) attribute indicated by the specified 'id',
          // supplying 'manipulator' with the corresponding attribute
          // information structure.  Return the value returned from the
          // invocation of 'manipulator' if 'id' identifies an attribute of this
          // class, and -1 otherwise.
  
      template<class MANIPULATOR>
      int manipulateAttribute(MANIPULATOR&  manipulator,
                              const char   *name,
                              int           nameLength);
          // Invoke the specified 'manipulator' on the address of
          // the (modifiable) attribute indicated by the specified 'name' of the
          // specified 'nameLength', supplying 'manipulator' with the
          // corresponding attribute information structure.  Return the value
          // returned from the invocation of 'manipulator' if 'name' identifies
          // an attribute of this class, and -1 otherwise.
  
      bsl::vector<bdlb::NullableValue<bsl::string> >& attribute1();
          // Return a reference to the modifiable "Attribute1" attribute of this
          // object.
  
      // ACCESSORS
      bsl::ostream& print(bsl::ostream& stream,
                          int           level = 0,
                          int           spacesPerLevel = 4) const;
          // Format this object to the specified output 'stream' at the
          // optionally specified indentation 'level' and return a reference to
          // the modifiable 'stream'.  If 'level' is specified, optionally
          // specify 'spacesPerLevel', the number of spaces per indentation level
          // for this and all of its nested objects.  Each line is indented by
          // the absolute value of 'level * spacesPerLevel'.  If 'level' is
          // negative, suppress indentation of the first line.  If
          // 'spacesPerLevel' is negative, suppress line breaks and format the
          // entire output on one line.  If 'stream' is initially invalid, this
          // operation has no effect.  Note that a trailing newline is provided
          // in multiline mode only.
  
      template<class ACCESSOR>
      int accessAttributes(ACCESSOR& accessor) const;
          // Invoke the specified 'accessor' sequentially on each
          // (non-modifiable) attribute of this object, supplying 'accessor'
          // with the corresponding attribute information structure until such
          // invocation returns a non-zero value.  Return the value from the
          // last invocation of 'accessor' (i.e., the invocation that terminated
          // the sequence).
  
      template<class ACCESSOR>
      int accessAttribute(ACCESSOR& accessor, int id) const;
          // Invoke the specified 'accessor' on the (non-modifiable) attribute
          // of this object indicated by the specified 'id', supplying 'accessor'
          // with the corresponding attribute information structure.  Return the
          // value returned from the invocation of 'accessor' if 'id' identifies
          // an attribute of this class, and -1 otherwise.
  
      template<class ACCESSOR>
      int accessAttribute(ACCESSOR&   accessor,
                          const char *name,
                          int         nameLength) const;
          // Invoke the specified 'accessor' on the (non-modifiable) attribute
          // of this object indicated by the specified 'name' of the specified
          // 'nameLength', supplying 'accessor' with the corresponding attribute
          // information structure.  Return the value returned from the
          // invocation of 'accessor' if 'name' identifies an attribute of this
          // class, and -1 otherwise.
  
      const bsl::vector<bdlb::NullableValue<bsl::string> >& attribute1() const;
          // Return a reference offering non-modifiable access to the
          // "Attribute1" attribute of this object.
  };
  
  // FREE OPERATORS
  inline
  bool operator==(const MySequenceWithNillableStringArray& lhs, const MySequenceWithNillableStringArray& rhs);
      // Return 'true' if the specified 'lhs' and 'rhs' attribute objects have
      // the same value, and 'false' otherwise.  Two attribute objects have the
      // same value if each respective attribute has the same value.
  
  inline
  bool operator!=(const MySequenceWithNillableStringArray& lhs, const MySequenceWithNillableStringArray& rhs);
      // Return 'true' if the specified 'lhs' and 'rhs' attribute objects do not
      // have the same value, and 'false' otherwise.  Two attribute objects do
      // not have the same value if one or more respective attributes differ in
      // values.
  
  inline
  bsl::ostream& operator<<(bsl::ostream& stream, const MySequenceWithNillableStringArray& rhs);
      // Format the specified 'rhs' to the specified output 'stream' and
      // return a reference to the modifiable 'stream'.
  
  }  // close package namespace
  
  // TRAITS
  
  BDLAT_DECL_SEQUENCE_WITH_ALLOCATOR_BITWISEMOVEABLE_TRAITS(s_baltst::MySequenceWithNillableStringArray)
  
  namespace s_baltst {
  
            // =======================================================
            // class MySequenceWithNillableStringSequenceArraySequence
            // =======================================================
  
  class MySequenceWithNillableStringSequenceArraySequence {
  
      // INSTANCE DATA
      bsl::string  d_attribute1;
  
    public:
      // TYPES
      enum {
          ATTRIBUTE_ID_ATTRIBUTE1 = 0
      };
  
      enum {
          NUM_ATTRIBUTES = 1
      };
  
      enum {
          ATTRIBUTE_INDEX_ATTRIBUTE1 = 0
      };
  
      // CONSTANTS
      static const char CLASS_NAME[];
  
      static const bdlat_AttributeInfo ATTRIBUTE_INFO_ARRAY[];
  
    public:
      // CLASS METHODS
      static const bdlat_AttributeInfo *lookupAttributeInfo(int id);
          // Return attribute information for the attribute indicated by the
          // specified 'id' if the attribute exists, and 0 otherwise.
  
      static const bdlat_AttributeInfo *lookupAttributeInfo(
                                                         const char *name,
                                                         int         nameLength);
          // Return attribute information for the attribute indicated by the
          // specified 'name' of the specified 'nameLength' if the attribute
          // exists, and 0 otherwise.
  
      // CREATORS
      explicit MySequenceWithNillableStringSequenceArraySequence(bslma::Allocator *basicAllocator = 0);
          // Create an object of type
          // 'MySequenceWithNillableStringSequenceArraySequence' having the
          // default value.  Use the optionally specified 'basicAllocator' to
          // supply memory.  If 'basicAllocator' is 0, the currently installed
          // default allocator is used.
  
      MySequenceWithNillableStringSequenceArraySequence(const MySequenceWithNillableStringSequenceArraySequence& original,
                                                        bslma::Allocator *basicAllocator = 0);
          // Create an object of type
          // 'MySequenceWithNillableStringSequenceArraySequence' having the value
          // of the specified 'original' object.  Use the optionally specified
          // 'basicAllocator' to supply memory.  If 'basicAllocator' is 0, the
          // currently installed default allocator is used.
  
  #if defined(BSLS_COMPILERFEATURES_SUPPORT_RVALUE_REFERENCES) \
   && defined(BSLS_COMPILERFEATURES_SUPPORT_NOEXCEPT)
      MySequenceWithNillableStringSequenceArraySequence(MySequenceWithNillableStringSequenceArraySequence&& original) noexcept;
          // Create an object of type
          // 'MySequenceWithNillableStringSequenceArraySequence' having the value
          // of the specified 'original' object.  After performing this action,
          // the 'original' object will be left in a valid, but unspecified
          // state.
  
      MySequenceWithNillableStringSequenceArraySequence(MySequenceWithNillableStringSequenceArraySequence&& original,
                                                        bslma::Allocator *basicAllocator);
          // Create an object of type
          // 'MySequenceWithNillableStringSequenceArraySequence' having the value
          // of the specified 'original' object.  After performing this action,
          // the 'original' object will be left in a valid, but unspecified
          // state.  Use the optionally specified 'basicAllocator' to supply
          // memory.  If 'basicAllocator' is 0, the currently installed default
          // allocator is used.
  #endif
  
      ~MySequenceWithNillableStringSequenceArraySequence();
          // Destroy this object.
  
      // MANIPULATORS
      MySequenceWithNillableStringSequenceArraySequence& operator=(const MySequenceWithNillableStringSequenceArraySequence& rhs);
          // Assign to this object the value of the specified 'rhs' object.
  
  #if defined(BSLS_COMPILERFEATURES_SUPPORT_RVALUE_REFERENCES) \
   && defined(BSLS_COMPILERFEATURES_SUPPORT_NOEXCEPT)
      MySequenceWithNillableStringSequenceArraySequence& operator=(MySequenceWithNillableStringSequenceArraySequence&& rhs);
          // Assign to this object the value of the specified 'rhs' object.
          // After performing this action, the 'rhs' object will be left in a
          // valid, but unspecified state.
  #endif
  
      void reset();
          // Reset this object to the default value (i.e., its value upon
          // default construction).
  
      template<class MANIPULATOR>
      int manipulateAttributes(MANIPULATOR& manipulator);
          // Invoke the specified 'manipulator' sequentially on the address of
          // each (modifiable) attribute of this object, supplying 'manipulator'
          // with the corresponding attribute information structure until such
          // invocation returns a non-zero value.  Return the value from the
          // last invocation of 'manipulator' (i.e., the invocation that
          // terminated the sequence).
  
      template<class MANIPULATOR>
      int manipulateAttribute(MANIPULATOR& manipulator, int id);
          // Invoke the specified 'manipulator' on the address of
          // the (modifiable) attribute indicated by the specified 'id',
          // supplying 'manipulator' with the corresponding attribute
          // information structure.  Return the value returned from the
          // invocation of 'manipulator' if 'id' identifies an attribute of this
          // class, and -1 otherwise.
  
      template<class MANIPULATOR>
      int manipulateAttribute(MANIPULATOR&  manipulator,
                              const char   *name,
                              int           nameLength);
          // Invoke the specified 'manipulator' on the address of
          // the (modifiable) attribute indicated by the specified 'name' of the
          // specified 'nameLength', supplying 'manipulator' with the
          // corresponding attribute information structure.  Return the value
          // returned from the invocation of 'manipulator' if 'name' identifies
          // an attribute of this class, and -1 otherwise.
  
      bsl::string& attribute1();
          // Return a reference to the modifiable "Attribute1" attribute of this
          // object.
  
      // ACCESSORS
      bsl::ostream& print(bsl::ostream& stream,
                          int           level = 0,
                          int           spacesPerLevel = 4) const;
          // Format this object to the specified output 'stream' at the
          // optionally specified indentation 'level' and return a reference to
          // the modifiable 'stream'.  If 'level' is specified, optionally
          // specify 'spacesPerLevel', the number of spaces per indentation level
          // for this and all of its nested objects.  Each line is indented by
          // the absolute value of 'level * spacesPerLevel'.  If 'level' is
          // negative, suppress indentation of the first line.  If
          // 'spacesPerLevel' is negative, suppress line breaks and format the
          // entire output on one line.  If 'stream' is initially invalid, this
          // operation has no effect.  Note that a trailing newline is provided
          // in multiline mode only.
  
      template<class ACCESSOR>
      int accessAttributes(ACCESSOR& accessor) const;
          // Invoke the specified 'accessor' sequentially on each
          // (non-modifiable) attribute of this object, supplying 'accessor'
          // with the corresponding attribute information structure until such
          // invocation returns a non-zero value.  Return the value from the
          // last invocation of 'accessor' (i.e., the invocation that terminated
          // the sequence).
  
      template<class ACCESSOR>
      int accessAttribute(ACCESSOR& accessor, int id) const;
          // Invoke the specified 'accessor' on the (non-modifiable) attribute
          // of this object indicated by the specified 'id', supplying 'accessor'
          // with the corresponding attribute information structure.  Return the
          // value returned from the invocation of 'accessor' if 'id' identifies
          // an attribute of this class, and -1 otherwise.
  
      template<class ACCESSOR>
      int accessAttribute(ACCESSOR&   accessor,
                          const char *name,
                          int         nameLength) const;
          // Invoke the specified 'accessor' on the (non-modifiable) attribute
          // of this object indicated by the specified 'name' of the specified
          // 'nameLength', supplying 'accessor' with the corresponding attribute
          // information structure.  Return the value returned from the
          // invocation of 'accessor' if 'name' identifies an attribute of this
          // class, and -1 otherwise.
  
      const bsl::string& attribute1() const;
          // Return a reference offering non-modifiable access to the
          // "Attribute1" attribute of this object.
  };
  
  // FREE OPERATORS
  inline
  bool operator==(const MySequenceWithNillableStringSequenceArraySequence& lhs, const MySequenceWithNillableStringSequenceArraySequence& rhs);
      // Return 'true' if the specified 'lhs' and 'rhs' attribute objects have
      // the same value, and 'false' otherwise.  Two attribute objects have the
      // same value if each respective attribute has the same value.
  
  inline
  bool operator!=(const MySequenceWithNillableStringSequenceArraySequence& lhs, const MySequenceWithNillableStringSequenceArraySequence& rhs);
      // Return 'true' if the specified 'lhs' and 'rhs' attribute objects do not
      // have the same value, and 'false' otherwise.  Two attribute objects do
      // not have the same value if one or more respective attributes differ in
      // values.
  
  inline
  bsl::ostream& operator<<(bsl::ostream& stream, const MySequenceWithNillableStringSequenceArraySequence& rhs);
      // Format the specified 'rhs' to the specified output 'stream' and
      // return a reference to the modifiable 'stream'.
  
  }  // close package namespace
  
  // TRAITS
  
  BDLAT_DECL_SEQUENCE_WITH_ALLOCATOR_BITWISEMOVEABLE_TRAITS(s_baltst::MySequenceWithNillableStringSequenceArraySequence)
  
  namespace s_baltst {
  
                      // ===================================
                      // class MySequenceWithNillableIntList
                      // ===================================
  
  class MySequenceWithNillableIntList {
  
      // INSTANCE DATA
      bsl::vector<bdlb::NullableValue<int> >  d_attribute1;
  
    public:
      // TYPES
      enum {
          ATTRIBUTE_ID_ATTRIBUTE1 = 0
      };
  
      enum {
          NUM_ATTRIBUTES = 1
      };
  
      enum {
          ATTRIBUTE_INDEX_ATTRIBUTE1 = 0
      };
  
      // CONSTANTS
      static const char CLASS_NAME[];
  
      static const bdlat_AttributeInfo ATTRIBUTE_INFO_ARRAY[];
  
    public:
      // CLASS METHODS
      static const bdlat_AttributeInfo *lookupAttributeInfo(int id);
          // Return attribute information for the attribute indicated by the
          // specified 'id' if the attribute exists, and 0 otherwise.
  
      static const bdlat_AttributeInfo *lookupAttributeInfo(
                                                         const char *name,
                                                         int         nameLength);
          // Return attribute information for the attribute indicated by the
          // specified 'name' of the specified 'nameLength' if the attribute
          // exists, and 0 otherwise.
  
      // CREATORS
      explicit MySequenceWithNillableIntList(bslma::Allocator *basicAllocator = 0);
          // Create an object of type 'MySequenceWithNillableIntList' having the
          // default value.  Use the optionally specified 'basicAllocator' to
          // supply memory.  If 'basicAllocator' is 0, the currently installed
          // default allocator is used.
  
      MySequenceWithNillableIntList(const MySequenceWithNillableIntList& original,
                                    bslma::Allocator *basicAllocator = 0);
          // Create an object of type 'MySequenceWithNillableIntList' having the
          // value of the specified 'original' object.  Use the optionally
          // specified 'basicAllocator' to supply memory.  If 'basicAllocator' is
          // 0, the currently installed default allocator is used.
  
  #if defined(BSLS_COMPILERFEATURES_SUPPORT_RVALUE_REFERENCES) \
   && defined(BSLS_COMPILERFEATURES_SUPPORT_NOEXCEPT)
      MySequenceWithNillableIntList(MySequenceWithNillableIntList&& original) noexcept;
          // Create an object of type 'MySequenceWithNillableIntList' having the
          // value of the specified 'original' object.  After performing this
          // action, the 'original' object will be left in a valid, but
          // unspecified state.
  
      MySequenceWithNillableIntList(MySequenceWithNillableIntList&& original,
                                    bslma::Allocator *basicAllocator);
          // Create an object of type 'MySequenceWithNillableIntList' having the
          // value of the specified 'original' object.  After performing this
          // action, the 'original' object will be left in a valid, but
          // unspecified state.  Use the optionally specified 'basicAllocator' to
          // supply memory.  If 'basicAllocator' is 0, the currently installed
          // default allocator is used.
  #endif
  
      ~MySequenceWithNillableIntList();
          // Destroy this object.
  
      // MANIPULATORS
      MySequenceWithNillableIntList& operator=(const MySequenceWithNillableIntList& rhs);
          // Assign to this object the value of the specified 'rhs' object.
  
  #if defined(BSLS_COMPILERFEATURES_SUPPORT_RVALUE_REFERENCES) \
   && defined(BSLS_COMPILERFEATURES_SUPPORT_NOEXCEPT)
      MySequenceWithNillableIntList& operator=(MySequenceWithNillableIntList&& rhs);
          // Assign to this object the value of the specified 'rhs' object.
          // After performing this action, the 'rhs' object will be left in a
          // valid, but unspecified state.
  #endif
  
      void reset();
          // Reset this object to the default value (i.e., its value upon
          // default construction).
  
      template<class MANIPULATOR>
      int manipulateAttributes(MANIPULATOR& manipulator);
          // Invoke the specified 'manipulator' sequentially on the address of
          // each (modifiable) attribute of this object, supplying 'manipulator'
          // with the corresponding attribute information structure until such
          // invocation returns a non-zero value.  Return the value from the
          // last invocation of 'manipulator' (i.e., the invocation that
          // terminated the sequence).
  
      template<class MANIPULATOR>
      int manipulateAttribute(MANIPULATOR& manipulator, int id);
          // Invoke the specified 'manipulator' on the address of
          // the (modifiable) attribute indicated by the specified 'id',
          // supplying 'manipulator' with the corresponding attribute
          // information structure.  Return the value returned from the
          // invocation of 'manipulator' if 'id' identifies an attribute of this
          // class, and -1 otherwise.
  
      template<class MANIPULATOR>
      int manipulateAttribute(MANIPULATOR&  manipulator,
                              const char   *name,
                              int           nameLength);
          // Invoke the specified 'manipulator' on the address of
          // the (modifiable) attribute indicated by the specified 'name' of the
          // specified 'nameLength', supplying 'manipulator' with the
          // corresponding attribute information structure.  Return the value
          // returned from the invocation of 'manipulator' if 'name' identifies
          // an attribute of this class, and -1 otherwise.
  
      bsl::vector<bdlb::NullableValue<int> >& attribute1();
          // Return a reference to the modifiable "Attribute1" attribute of this
          // object.
  
      // ACCESSORS
      bsl::ostream& print(bsl::ostream& stream,
                          int           level = 0,
                          int           spacesPerLevel = 4) const;
          // Format this object to the specified output 'stream' at the
          // optionally specified indentation 'level' and return a reference to
          // the modifiable 'stream'.  If 'level' is specified, optionally
          // specify 'spacesPerLevel', the number of spaces per indentation level
          // for this and all of its nested objects.  Each line is indented by
          // the absolute value of 'level * spacesPerLevel'.  If 'level' is
          // negative, suppress indentation of the first line.  If
          // 'spacesPerLevel' is negative, suppress line breaks and format the
          // entire output on one line.  If 'stream' is initially invalid, this
          // operation has no effect.  Note that a trailing newline is provided
          // in multiline mode only.
  
      template<class ACCESSOR>
      int accessAttributes(ACCESSOR& accessor) const;
          // Invoke the specified 'accessor' sequentially on each
          // (non-modifiable) attribute of this object, supplying 'accessor'
          // with the corresponding attribute information structure until such
          // invocation returns a non-zero value.  Return the value from the
          // last invocation of 'accessor' (i.e., the invocation that terminated
          // the sequence).
  
      template<class ACCESSOR>
      int accessAttribute(ACCESSOR& accessor, int id) const;
          // Invoke the specified 'accessor' on the (non-modifiable) attribute
          // of this object indicated by the specified 'id', supplying 'accessor'
          // with the corresponding attribute information structure.  Return the
          // value returned from the invocation of 'accessor' if 'id' identifies
          // an attribute of this class, and -1 otherwise.
  
      template<class ACCESSOR>
      int accessAttribute(ACCESSOR&   accessor,
                          const char *name,
                          int         nameLength) const;
          // Invoke the specified 'accessor' on the (non-modifiable) attribute
          // of this object indicated by the specified 'name' of the specified
          // 'nameLength', supplying 'accessor' with the corresponding attribute
          // information structure.  Return the value returned from the
          // invocation of 'accessor' if 'name' identifies an attribute of this
          // class, and -1 otherwise.
  
      const bsl::vector<bdlb::NullableValue<int> >& attribute1() const;
          // Return a reference offering non-modifiable access to the
          // "Attribute1" attribute of this object.
  };
  
  // FREE OPERATORS
  inline
  bool operator==(const MySequenceWithNillableIntList& lhs, const MySequenceWithNillableIntList& rhs);
      // Return 'true' if the specified 'lhs' and 'rhs' attribute objects have
      // the same value, and 'false' otherwise.  Two attribute objects have the
      // same value if each respective attribute has the same value.
  
  inline
  bool operator!=(const MySequenceWithNillableIntList& lhs, const MySequenceWithNillableIntList& rhs);
      // Return 'true' if the specified 'lhs' and 'rhs' attribute objects do not
      // have the same value, and 'false' otherwise.  Two attribute objects do
      // not have the same value if one or more respective attributes differ in
      // values.
  
  inline
  bsl::ostream& operator<<(bsl::ostream& stream, const MySequenceWithNillableIntList& rhs);
      // Format the specified 'rhs' to the specified output 'stream' and
      // return a reference to the modifiable 'stream'.
  
  }  // close package namespace
  
  // TRAITS
  
  BDLAT_DECL_SEQUENCE_WITH_ALLOCATOR_BITWISEMOVEABLE_TRAITS(s_baltst::MySequenceWithNillableIntList)
  
  namespace s_baltst {
  
                  // ============================================
                  // class MySequenceWithNillableIntSequenceArray
                  // ============================================
  
  class MySequenceWithNillableIntSequenceArray {
  
      // INSTANCE DATA
      bsl::vector<bdlb::NullableValue<MySequenceWithNillableIntSequenceArraySequence> >  d_attribute1;
  
    public:
      // TYPES
      enum {
          ATTRIBUTE_ID_ATTRIBUTE1 = 0
      };
  
      enum {
          NUM_ATTRIBUTES = 1
      };
  
      enum {
          ATTRIBUTE_INDEX_ATTRIBUTE1 = 0
      };
  
      // CONSTANTS
      static const char CLASS_NAME[];
  
      static const bdlat_AttributeInfo ATTRIBUTE_INFO_ARRAY[];
  
    public:
      // CLASS METHODS
      static const bdlat_AttributeInfo *lookupAttributeInfo(int id);
          // Return attribute information for the attribute indicated by the
          // specified 'id' if the attribute exists, and 0 otherwise.
  
      static const bdlat_AttributeInfo *lookupAttributeInfo(
                                                         const char *name,
                                                         int         nameLength);
          // Return attribute information for the attribute indicated by the
          // specified 'name' of the specified 'nameLength' if the attribute
          // exists, and 0 otherwise.
  
      // CREATORS
      explicit MySequenceWithNillableIntSequenceArray(bslma::Allocator *basicAllocator = 0);
          // Create an object of type 'MySequenceWithNillableIntSequenceArray'
          // having the default value.  Use the optionally specified
          // 'basicAllocator' to supply memory.  If 'basicAllocator' is 0, the
          // currently installed default allocator is used.
  
      MySequenceWithNillableIntSequenceArray(const MySequenceWithNillableIntSequenceArray& original,
                                             bslma::Allocator *basicAllocator = 0);
          // Create an object of type 'MySequenceWithNillableIntSequenceArray'
          // having the value of the specified 'original' object.  Use the
          // optionally specified 'basicAllocator' to supply memory.  If
          // 'basicAllocator' is 0, the currently installed default allocator is
          // used.
  
  #if defined(BSLS_COMPILERFEATURES_SUPPORT_RVALUE_REFERENCES) \
   && defined(BSLS_COMPILERFEATURES_SUPPORT_NOEXCEPT)
      MySequenceWithNillableIntSequenceArray(MySequenceWithNillableIntSequenceArray&& original) noexcept;
          // Create an object of type 'MySequenceWithNillableIntSequenceArray'
          // having the value of the specified 'original' object.  After
          // performing this action, the 'original' object will be left in a
          // valid, but unspecified state.
  
      MySequenceWithNillableIntSequenceArray(MySequenceWithNillableIntSequenceArray&& original,
                                             bslma::Allocator *basicAllocator);
          // Create an object of type 'MySequenceWithNillableIntSequenceArray'
          // having the value of the specified 'original' object.  After
          // performing this action, the 'original' object will be left in a
          // valid, but unspecified state.  Use the optionally specified
          // 'basicAllocator' to supply memory.  If 'basicAllocator' is 0, the
          // currently installed default allocator is used.
  #endif
  
      ~MySequenceWithNillableIntSequenceArray();
          // Destroy this object.
  
      // MANIPULATORS
      MySequenceWithNillableIntSequenceArray& operator=(const MySequenceWithNillableIntSequenceArray& rhs);
          // Assign to this object the value of the specified 'rhs' object.
  
  #if defined(BSLS_COMPILERFEATURES_SUPPORT_RVALUE_REFERENCES) \
   && defined(BSLS_COMPILERFEATURES_SUPPORT_NOEXCEPT)
      MySequenceWithNillableIntSequenceArray& operator=(MySequenceWithNillableIntSequenceArray&& rhs);
          // Assign to this object the value of the specified 'rhs' object.
          // After performing this action, the 'rhs' object will be left in a
          // valid, but unspecified state.
  #endif
  
      void reset();
          // Reset this object to the default value (i.e., its value upon
          // default construction).
  
      template<class MANIPULATOR>
      int manipulateAttributes(MANIPULATOR& manipulator);
          // Invoke the specified 'manipulator' sequentially on the address of
          // each (modifiable) attribute of this object, supplying 'manipulator'
          // with the corresponding attribute information structure until such
          // invocation returns a non-zero value.  Return the value from the
          // last invocation of 'manipulator' (i.e., the invocation that
          // terminated the sequence).
  
      template<class MANIPULATOR>
      int manipulateAttribute(MANIPULATOR& manipulator, int id);
          // Invoke the specified 'manipulator' on the address of
          // the (modifiable) attribute indicated by the specified 'id',
          // supplying 'manipulator' with the corresponding attribute
          // information structure.  Return the value returned from the
          // invocation of 'manipulator' if 'id' identifies an attribute of this
          // class, and -1 otherwise.
  
      template<class MANIPULATOR>
      int manipulateAttribute(MANIPULATOR&  manipulator,
                              const char   *name,
                              int           nameLength);
          // Invoke the specified 'manipulator' on the address of
          // the (modifiable) attribute indicated by the specified 'name' of the
          // specified 'nameLength', supplying 'manipulator' with the
          // corresponding attribute information structure.  Return the value
          // returned from the invocation of 'manipulator' if 'name' identifies
          // an attribute of this class, and -1 otherwise.
  
      bsl::vector<bdlb::NullableValue<MySequenceWithNillableIntSequenceArraySequence> >& attribute1();
          // Return a reference to the modifiable "Attribute1" attribute of this
          // object.
  
      // ACCESSORS
      bsl::ostream& print(bsl::ostream& stream,
                          int           level = 0,
                          int           spacesPerLevel = 4) const;
          // Format this object to the specified output 'stream' at the
          // optionally specified indentation 'level' and return a reference to
          // the modifiable 'stream'.  If 'level' is specified, optionally
          // specify 'spacesPerLevel', the number of spaces per indentation level
          // for this and all of its nested objects.  Each line is indented by
          // the absolute value of 'level * spacesPerLevel'.  If 'level' is
          // negative, suppress indentation of the first line.  If
          // 'spacesPerLevel' is negative, suppress line breaks and format the
          // entire output on one line.  If 'stream' is initially invalid, this
          // operation has no effect.  Note that a trailing newline is provided
          // in multiline mode only.
  
      template<class ACCESSOR>
      int accessAttributes(ACCESSOR& accessor) const;
          // Invoke the specified 'accessor' sequentially on each
          // (non-modifiable) attribute of this object, supplying 'accessor'
          // with the corresponding attribute information structure until such
          // invocation returns a non-zero value.  Return the value from the
          // last invocation of 'accessor' (i.e., the invocation that terminated
          // the sequence).
  
      template<class ACCESSOR>
      int accessAttribute(ACCESSOR& accessor, int id) const;
          // Invoke the specified 'accessor' on the (non-modifiable) attribute
          // of this object indicated by the specified 'id', supplying 'accessor'
          // with the corresponding attribute information structure.  Return the
          // value returned from the invocation of 'accessor' if 'id' identifies
          // an attribute of this class, and -1 otherwise.
  
      template<class ACCESSOR>
      int accessAttribute(ACCESSOR&   accessor,
                          const char *name,
                          int         nameLength) const;
          // Invoke the specified 'accessor' on the (non-modifiable) attribute
          // of this object indicated by the specified 'name' of the specified
          // 'nameLength', supplying 'accessor' with the corresponding attribute
          // information structure.  Return the value returned from the
          // invocation of 'accessor' if 'name' identifies an attribute of this
          // class, and -1 otherwise.
  
      const bsl::vector<bdlb::NullableValue<MySequenceWithNillableIntSequenceArraySequence> >& attribute1() const;
          // Return a reference offering non-modifiable access to the
          // "Attribute1" attribute of this object.
  };
  
  // FREE OPERATORS
  inline
  bool operator==(const MySequenceWithNillableIntSequenceArray& lhs, const MySequenceWithNillableIntSequenceArray& rhs);
      // Return 'true' if the specified 'lhs' and 'rhs' attribute objects have
      // the same value, and 'false' otherwise.  Two attribute objects have the
      // same value if each respective attribute has the same value.
  
  inline
  bool operator!=(const MySequenceWithNillableIntSequenceArray& lhs, const MySequenceWithNillableIntSequenceArray& rhs);
      // Return 'true' if the specified 'lhs' and 'rhs' attribute objects do not
      // have the same value, and 'false' otherwise.  Two attribute objects do
      // not have the same value if one or more respective attributes differ in
      // values.
  
  inline
  bsl::ostream& operator<<(bsl::ostream& stream, const MySequenceWithNillableIntSequenceArray& rhs);
      // Format the specified 'rhs' to the specified output 'stream' and
      // return a reference to the modifiable 'stream'.
  
  }  // close package namespace
  
  // TRAITS
  
  BDLAT_DECL_SEQUENCE_WITH_ALLOCATOR_BITWISEMOVEABLE_TRAITS(s_baltst::MySequenceWithNillableIntSequenceArray)
  
  namespace s_baltst {
  
                     // ======================================
                     // class MySequenceWithNillableStringList
                     // ======================================
  
  class MySequenceWithNillableStringList {
  
      // INSTANCE DATA
      bsl::vector<bdlb::NullableValue<bsl::string> >  d_attribute1;
  
    public:
      // TYPES
      enum {
          ATTRIBUTE_ID_ATTRIBUTE1 = 0
      };
  
      enum {
          NUM_ATTRIBUTES = 1
      };
  
      enum {
          ATTRIBUTE_INDEX_ATTRIBUTE1 = 0
      };
  
      // CONSTANTS
      static const char CLASS_NAME[];
  
      static const bdlat_AttributeInfo ATTRIBUTE_INFO_ARRAY[];
  
    public:
      // CLASS METHODS
      static const bdlat_AttributeInfo *lookupAttributeInfo(int id);
          // Return attribute information for the attribute indicated by the
          // specified 'id' if the attribute exists, and 0 otherwise.
  
      static const bdlat_AttributeInfo *lookupAttributeInfo(
                                                         const char *name,
                                                         int         nameLength);
          // Return attribute information for the attribute indicated by the
          // specified 'name' of the specified 'nameLength' if the attribute
          // exists, and 0 otherwise.
  
      // CREATORS
      explicit MySequenceWithNillableStringList(bslma::Allocator *basicAllocator = 0);
          // Create an object of type 'MySequenceWithNillableStringList' having
          // the default value.  Use the optionally specified 'basicAllocator' to
          // supply memory.  If 'basicAllocator' is 0, the currently installed
          // default allocator is used.
  
      MySequenceWithNillableStringList(const MySequenceWithNillableStringList& original,
                                       bslma::Allocator *basicAllocator = 0);
          // Create an object of type 'MySequenceWithNillableStringList' having
          // the value of the specified 'original' object.  Use the optionally
          // specified 'basicAllocator' to supply memory.  If 'basicAllocator' is
          // 0, the currently installed default allocator is used.
  
  #if defined(BSLS_COMPILERFEATURES_SUPPORT_RVALUE_REFERENCES) \
   && defined(BSLS_COMPILERFEATURES_SUPPORT_NOEXCEPT)
      MySequenceWithNillableStringList(MySequenceWithNillableStringList&& original) noexcept;
          // Create an object of type 'MySequenceWithNillableStringList' having
          // the value of the specified 'original' object.  After performing this
          // action, the 'original' object will be left in a valid, but
          // unspecified state.
  
      MySequenceWithNillableStringList(MySequenceWithNillableStringList&& original,
                                       bslma::Allocator *basicAllocator);
          // Create an object of type 'MySequenceWithNillableStringList' having
          // the value of the specified 'original' object.  After performing this
          // action, the 'original' object will be left in a valid, but
          // unspecified state.  Use the optionally specified 'basicAllocator' to
          // supply memory.  If 'basicAllocator' is 0, the currently installed
          // default allocator is used.
  #endif
  
      ~MySequenceWithNillableStringList();
          // Destroy this object.
  
      // MANIPULATORS
      MySequenceWithNillableStringList& operator=(const MySequenceWithNillableStringList& rhs);
          // Assign to this object the value of the specified 'rhs' object.
  
  #if defined(BSLS_COMPILERFEATURES_SUPPORT_RVALUE_REFERENCES) \
   && defined(BSLS_COMPILERFEATURES_SUPPORT_NOEXCEPT)
      MySequenceWithNillableStringList& operator=(MySequenceWithNillableStringList&& rhs);
          // Assign to this object the value of the specified 'rhs' object.
          // After performing this action, the 'rhs' object will be left in a
          // valid, but unspecified state.
  #endif
  
      void reset();
          // Reset this object to the default value (i.e., its value upon
          // default construction).
  
      template<class MANIPULATOR>
      int manipulateAttributes(MANIPULATOR& manipulator);
          // Invoke the specified 'manipulator' sequentially on the address of
          // each (modifiable) attribute of this object, supplying 'manipulator'
          // with the corresponding attribute information structure until such
          // invocation returns a non-zero value.  Return the value from the
          // last invocation of 'manipulator' (i.e., the invocation that
          // terminated the sequence).
  
      template<class MANIPULATOR>
      int manipulateAttribute(MANIPULATOR& manipulator, int id);
          // Invoke the specified 'manipulator' on the address of
          // the (modifiable) attribute indicated by the specified 'id',
          // supplying 'manipulator' with the corresponding attribute
          // information structure.  Return the value returned from the
          // invocation of 'manipulator' if 'id' identifies an attribute of this
          // class, and -1 otherwise.
  
      template<class MANIPULATOR>
      int manipulateAttribute(MANIPULATOR&  manipulator,
                              const char   *name,
                              int           nameLength);
          // Invoke the specified 'manipulator' on the address of
          // the (modifiable) attribute indicated by the specified 'name' of the
          // specified 'nameLength', supplying 'manipulator' with the
          // corresponding attribute information structure.  Return the value
          // returned from the invocation of 'manipulator' if 'name' identifies
          // an attribute of this class, and -1 otherwise.
  
      bsl::vector<bdlb::NullableValue<bsl::string> >& attribute1();
          // Return a reference to the modifiable "Attribute1" attribute of this
          // object.
  
      // ACCESSORS
      bsl::ostream& print(bsl::ostream& stream,
                          int           level = 0,
                          int           spacesPerLevel = 4) const;
          // Format this object to the specified output 'stream' at the
          // optionally specified indentation 'level' and return a reference to
          // the modifiable 'stream'.  If 'level' is specified, optionally
          // specify 'spacesPerLevel', the number of spaces per indentation level
          // for this and all of its nested objects.  Each line is indented by
          // the absolute value of 'level * spacesPerLevel'.  If 'level' is
          // negative, suppress indentation of the first line.  If
          // 'spacesPerLevel' is negative, suppress line breaks and format the
          // entire output on one line.  If 'stream' is initially invalid, this
          // operation has no effect.  Note that a trailing newline is provided
          // in multiline mode only.
  
      template<class ACCESSOR>
      int accessAttributes(ACCESSOR& accessor) const;
          // Invoke the specified 'accessor' sequentially on each
          // (non-modifiable) attribute of this object, supplying 'accessor'
          // with the corresponding attribute information structure until such
          // invocation returns a non-zero value.  Return the value from the
          // last invocation of 'accessor' (i.e., the invocation that terminated
          // the sequence).
  
      template<class ACCESSOR>
      int accessAttribute(ACCESSOR& accessor, int id) const;
          // Invoke the specified 'accessor' on the (non-modifiable) attribute
          // of this object indicated by the specified 'id', supplying 'accessor'
          // with the corresponding attribute information structure.  Return the
          // value returned from the invocation of 'accessor' if 'id' identifies
          // an attribute of this class, and -1 otherwise.
  
      template<class ACCESSOR>
      int accessAttribute(ACCESSOR&   accessor,
                          const char *name,
                          int         nameLength) const;
          // Invoke the specified 'accessor' on the (non-modifiable) attribute
          // of this object indicated by the specified 'name' of the specified
          // 'nameLength', supplying 'accessor' with the corresponding attribute
          // information structure.  Return the value returned from the
          // invocation of 'accessor' if 'name' identifies an attribute of this
          // class, and -1 otherwise.
  
      const bsl::vector<bdlb::NullableValue<bsl::string> >& attribute1() const;
          // Return a reference offering non-modifiable access to the
          // "Attribute1" attribute of this object.
  };
  
  // FREE OPERATORS
  inline
  bool operator==(const MySequenceWithNillableStringList& lhs, const MySequenceWithNillableStringList& rhs);
      // Return 'true' if the specified 'lhs' and 'rhs' attribute objects have
      // the same value, and 'false' otherwise.  Two attribute objects have the
      // same value if each respective attribute has the same value.
  
  inline
  bool operator!=(const MySequenceWithNillableStringList& lhs, const MySequenceWithNillableStringList& rhs);
      // Return 'true' if the specified 'lhs' and 'rhs' attribute objects do not
      // have the same value, and 'false' otherwise.  Two attribute objects do
      // not have the same value if one or more respective attributes differ in
      // values.
  
  inline
  bsl::ostream& operator<<(bsl::ostream& stream, const MySequenceWithNillableStringList& rhs);
      // Format the specified 'rhs' to the specified output 'stream' and
      // return a reference to the modifiable 'stream'.
  
  }  // close package namespace
  
  // TRAITS
  
  BDLAT_DECL_SEQUENCE_WITH_ALLOCATOR_BITWISEMOVEABLE_TRAITS(s_baltst::MySequenceWithNillableStringList)
  
  namespace s_baltst {
  
                // ===============================================
                // class MySequenceWithNillableStringSequenceArray
                // ===============================================
  
  class MySequenceWithNillableStringSequenceArray {
  
      // INSTANCE DATA
      bsl::vector<bdlb::NullableValue<MySequenceWithNillableStringSequenceArraySequence> >  d_attribute1;
  
    public:
      // TYPES
      enum {
          ATTRIBUTE_ID_ATTRIBUTE1 = 0
      };
  
      enum {
          NUM_ATTRIBUTES = 1
      };
  
      enum {
          ATTRIBUTE_INDEX_ATTRIBUTE1 = 0
      };
  
      // CONSTANTS
      static const char CLASS_NAME[];
  
      static const bdlat_AttributeInfo ATTRIBUTE_INFO_ARRAY[];
  
    public:
      // CLASS METHODS
      static const bdlat_AttributeInfo *lookupAttributeInfo(int id);
          // Return attribute information for the attribute indicated by the
          // specified 'id' if the attribute exists, and 0 otherwise.
  
      static const bdlat_AttributeInfo *lookupAttributeInfo(
                                                         const char *name,
                                                         int         nameLength);
          // Return attribute information for the attribute indicated by the
          // specified 'name' of the specified 'nameLength' if the attribute
          // exists, and 0 otherwise.
  
      // CREATORS
      explicit MySequenceWithNillableStringSequenceArray(bslma::Allocator *basicAllocator = 0);
          // Create an object of type 'MySequenceWithNillableStringSequenceArray'
          // having the default value.  Use the optionally specified
          // 'basicAllocator' to supply memory.  If 'basicAllocator' is 0, the
          // currently installed default allocator is used.
  
      MySequenceWithNillableStringSequenceArray(const MySequenceWithNillableStringSequenceArray& original,
                                                bslma::Allocator *basicAllocator = 0);
          // Create an object of type 'MySequenceWithNillableStringSequenceArray'
          // having the value of the specified 'original' object.  Use the
          // optionally specified 'basicAllocator' to supply memory.  If
          // 'basicAllocator' is 0, the currently installed default allocator is
          // used.
  
  #if defined(BSLS_COMPILERFEATURES_SUPPORT_RVALUE_REFERENCES) \
   && defined(BSLS_COMPILERFEATURES_SUPPORT_NOEXCEPT)
      MySequenceWithNillableStringSequenceArray(MySequenceWithNillableStringSequenceArray&& original) noexcept;
          // Create an object of type 'MySequenceWithNillableStringSequenceArray'
          // having the value of the specified 'original' object.  After
          // performing this action, the 'original' object will be left in a
          // valid, but unspecified state.
  
      MySequenceWithNillableStringSequenceArray(MySequenceWithNillableStringSequenceArray&& original,
                                                bslma::Allocator *basicAllocator);
          // Create an object of type 'MySequenceWithNillableStringSequenceArray'
          // having the value of the specified 'original' object.  After
          // performing this action, the 'original' object will be left in a
          // valid, but unspecified state.  Use the optionally specified
          // 'basicAllocator' to supply memory.  If 'basicAllocator' is 0, the
          // currently installed default allocator is used.
  #endif
  
      ~MySequenceWithNillableStringSequenceArray();
          // Destroy this object.
  
      // MANIPULATORS
      MySequenceWithNillableStringSequenceArray& operator=(const MySequenceWithNillableStringSequenceArray& rhs);
          // Assign to this object the value of the specified 'rhs' object.
  
  #if defined(BSLS_COMPILERFEATURES_SUPPORT_RVALUE_REFERENCES) \
   && defined(BSLS_COMPILERFEATURES_SUPPORT_NOEXCEPT)
      MySequenceWithNillableStringSequenceArray& operator=(MySequenceWithNillableStringSequenceArray&& rhs);
          // Assign to this object the value of the specified 'rhs' object.
          // After performing this action, the 'rhs' object will be left in a
          // valid, but unspecified state.
  #endif
  
      void reset();
          // Reset this object to the default value (i.e., its value upon
          // default construction).
  
      template<class MANIPULATOR>
      int manipulateAttributes(MANIPULATOR& manipulator);
          // Invoke the specified 'manipulator' sequentially on the address of
          // each (modifiable) attribute of this object, supplying 'manipulator'
          // with the corresponding attribute information structure until such
          // invocation returns a non-zero value.  Return the value from the
          // last invocation of 'manipulator' (i.e., the invocation that
          // terminated the sequence).
  
      template<class MANIPULATOR>
      int manipulateAttribute(MANIPULATOR& manipulator, int id);
          // Invoke the specified 'manipulator' on the address of
          // the (modifiable) attribute indicated by the specified 'id',
          // supplying 'manipulator' with the corresponding attribute
          // information structure.  Return the value returned from the
          // invocation of 'manipulator' if 'id' identifies an attribute of this
          // class, and -1 otherwise.
  
      template<class MANIPULATOR>
      int manipulateAttribute(MANIPULATOR&  manipulator,
                              const char   *name,
                              int           nameLength);
          // Invoke the specified 'manipulator' on the address of
          // the (modifiable) attribute indicated by the specified 'name' of the
          // specified 'nameLength', supplying 'manipulator' with the
          // corresponding attribute information structure.  Return the value
          // returned from the invocation of 'manipulator' if 'name' identifies
          // an attribute of this class, and -1 otherwise.
  
      bsl::vector<bdlb::NullableValue<MySequenceWithNillableStringSequenceArraySequence> >& attribute1();
          // Return a reference to the modifiable "Attribute1" attribute of this
          // object.
  
      // ACCESSORS
      bsl::ostream& print(bsl::ostream& stream,
                          int           level = 0,
                          int           spacesPerLevel = 4) const;
          // Format this object to the specified output 'stream' at the
          // optionally specified indentation 'level' and return a reference to
          // the modifiable 'stream'.  If 'level' is specified, optionally
          // specify 'spacesPerLevel', the number of spaces per indentation level
          // for this and all of its nested objects.  Each line is indented by
          // the absolute value of 'level * spacesPerLevel'.  If 'level' is
          // negative, suppress indentation of the first line.  If
          // 'spacesPerLevel' is negative, suppress line breaks and format the
          // entire output on one line.  If 'stream' is initially invalid, this
          // operation has no effect.  Note that a trailing newline is provided
          // in multiline mode only.
  
      template<class ACCESSOR>
      int accessAttributes(ACCESSOR& accessor) const;
          // Invoke the specified 'accessor' sequentially on each
          // (non-modifiable) attribute of this object, supplying 'accessor'
          // with the corresponding attribute information structure until such
          // invocation returns a non-zero value.  Return the value from the
          // last invocation of 'accessor' (i.e., the invocation that terminated
          // the sequence).
  
      template<class ACCESSOR>
      int accessAttribute(ACCESSOR& accessor, int id) const;
          // Invoke the specified 'accessor' on the (non-modifiable) attribute
          // of this object indicated by the specified 'id', supplying 'accessor'
          // with the corresponding attribute information structure.  Return the
          // value returned from the invocation of 'accessor' if 'id' identifies
          // an attribute of this class, and -1 otherwise.
  
      template<class ACCESSOR>
      int accessAttribute(ACCESSOR&   accessor,
                          const char *name,
                          int         nameLength) const;
          // Invoke the specified 'accessor' on the (non-modifiable) attribute
          // of this object indicated by the specified 'name' of the specified
          // 'nameLength', supplying 'accessor' with the corresponding attribute
          // information structure.  Return the value returned from the
          // invocation of 'accessor' if 'name' identifies an attribute of this
          // class, and -1 otherwise.
  
      const bsl::vector<bdlb::NullableValue<MySequenceWithNillableStringSequenceArraySequence> >& attribute1() const;
          // Return a reference offering non-modifiable access to the
          // "Attribute1" attribute of this object.
  };
  
  // FREE OPERATORS
  inline
  bool operator==(const MySequenceWithNillableStringSequenceArray& lhs, const MySequenceWithNillableStringSequenceArray& rhs);
      // Return 'true' if the specified 'lhs' and 'rhs' attribute objects have
      // the same value, and 'false' otherwise.  Two attribute objects have the
      // same value if each respective attribute has the same value.
  
  inline
  bool operator!=(const MySequenceWithNillableStringSequenceArray& lhs, const MySequenceWithNillableStringSequenceArray& rhs);
      // Return 'true' if the specified 'lhs' and 'rhs' attribute objects do not
      // have the same value, and 'false' otherwise.  Two attribute objects do
      // not have the same value if one or more respective attributes differ in
      // values.
  
  inline
  bsl::ostream& operator<<(bsl::ostream& stream, const MySequenceWithNillableStringSequenceArray& rhs);
      // Format the specified 'rhs' to the specified output 'stream' and
      // return a reference to the modifiable 'stream'.
  
  }  // close package namespace
  
  // TRAITS
  
  BDLAT_DECL_SEQUENCE_WITH_ALLOCATOR_BITWISEMOVEABLE_TRAITS(s_baltst::MySequenceWithNillableStringSequenceArray)
  
  // ============================================================================
  //                         INLINE FUNCTION DEFINITIONS
  // ============================================================================
  
  namespace s_baltst {
  
                          // ----------------------------
                          // class MySequenceWithNillable
                          // ----------------------------
  
  // CLASS METHODS
  // MANIPULATORS
  template <class MANIPULATOR>
  int MySequenceWithNillable::manipulateAttributes(MANIPULATOR& manipulator)
  {
      int ret;
  
      ret = manipulator(&d_attribute1, ATTRIBUTE_INFO_ARRAY[ATTRIBUTE_INDEX_ATTRIBUTE1]);
      if (ret) {
          return ret;
      }
  
      ret = manipulator(&d_myNillable, ATTRIBUTE_INFO_ARRAY[ATTRIBUTE_INDEX_MY_NILLABLE]);
      if (ret) {
          return ret;
      }
  
      ret = manipulator(&d_attribute2, ATTRIBUTE_INFO_ARRAY[ATTRIBUTE_INDEX_ATTRIBUTE2]);
      if (ret) {
          return ret;
      }
  
      return 0;
  }
  
  template <class MANIPULATOR>
  int MySequenceWithNillable::manipulateAttribute(MANIPULATOR& manipulator, int id)
  {
      enum { NOT_FOUND = -1 };
  
      switch (id) {
        case ATTRIBUTE_ID_ATTRIBUTE1: {
          return manipulator(&d_attribute1, ATTRIBUTE_INFO_ARRAY[ATTRIBUTE_INDEX_ATTRIBUTE1]);
        }
        case ATTRIBUTE_ID_MY_NILLABLE: {
          return manipulator(&d_myNillable, ATTRIBUTE_INFO_ARRAY[ATTRIBUTE_INDEX_MY_NILLABLE]);
        }
        case ATTRIBUTE_ID_ATTRIBUTE2: {
          return manipulator(&d_attribute2, ATTRIBUTE_INFO_ARRAY[ATTRIBUTE_INDEX_ATTRIBUTE2]);
        }
        default:
          return NOT_FOUND;
      }
  }
  
  template <class MANIPULATOR>
  int MySequenceWithNillable::manipulateAttribute(
          MANIPULATOR&  manipulator,
          const char   *name,
          int           nameLength)
  {
      enum { NOT_FOUND = -1 };
  
      const bdlat_AttributeInfo *attributeInfo =
                                           lookupAttributeInfo(name, nameLength);
      if (0 == attributeInfo) {
          return NOT_FOUND;
      }
  
      return manipulateAttribute(manipulator, attributeInfo->d_id);
  }
  
  inline
  int& MySequenceWithNillable::attribute1()
  {
      return d_attribute1;
  }
  
  inline
  bdlb::NullableValue<bsl::string>& MySequenceWithNillable::myNillable()
  {
      return d_myNillable;
  }
  
  inline
  bsl::string& MySequenceWithNillable::attribute2()
  {
      return d_attribute2;
  }
  
  // ACCESSORS
  template <class ACCESSOR>
  int MySequenceWithNillable::accessAttributes(ACCESSOR& accessor) const
  {
      int ret;
  
      ret = accessor(d_attribute1, ATTRIBUTE_INFO_ARRAY[ATTRIBUTE_INDEX_ATTRIBUTE1]);
      if (ret) {
          return ret;
      }
  
      ret = accessor(d_myNillable, ATTRIBUTE_INFO_ARRAY[ATTRIBUTE_INDEX_MY_NILLABLE]);
      if (ret) {
          return ret;
      }
  
      ret = accessor(d_attribute2, ATTRIBUTE_INFO_ARRAY[ATTRIBUTE_INDEX_ATTRIBUTE2]);
      if (ret) {
          return ret;
      }
  
      return 0;
  }
  
  template <class ACCESSOR>
  int MySequenceWithNillable::accessAttribute(ACCESSOR& accessor, int id) const
  {
      enum { NOT_FOUND = -1 };
  
      switch (id) {
        case ATTRIBUTE_ID_ATTRIBUTE1: {
          return accessor(d_attribute1, ATTRIBUTE_INFO_ARRAY[ATTRIBUTE_INDEX_ATTRIBUTE1]);
        }
        case ATTRIBUTE_ID_MY_NILLABLE: {
          return accessor(d_myNillable, ATTRIBUTE_INFO_ARRAY[ATTRIBUTE_INDEX_MY_NILLABLE]);
        }
        case ATTRIBUTE_ID_ATTRIBUTE2: {
          return accessor(d_attribute2, ATTRIBUTE_INFO_ARRAY[ATTRIBUTE_INDEX_ATTRIBUTE2]);
        }
        default:
          return NOT_FOUND;
      }
  }
  
  template <class ACCESSOR>
  int MySequenceWithNillable::accessAttribute(
          ACCESSOR&   accessor,
          const char *name,
          int         nameLength) const
  {
      enum { NOT_FOUND = -1 };
  
      const bdlat_AttributeInfo *attributeInfo =
            lookupAttributeInfo(name, nameLength);
      if (0 == attributeInfo) {
         return NOT_FOUND;
      }
  
      return accessAttribute(accessor, attributeInfo->d_id);
  }
  
  inline
  int MySequenceWithNillable::attribute1() const
  {
      return d_attribute1;
  }
  
  inline
  const bdlb::NullableValue<bsl::string>& MySequenceWithNillable::myNillable() const
  {
      return d_myNillable;
  }
  
  inline
  const bsl::string& MySequenceWithNillable::attribute2() const
  {
      return d_attribute2;
  }
  
  
  
                    // ----------------------------------------
                    // class MySequenceWithNillableBase64Binary
                    // ----------------------------------------
  
  // CLASS METHODS
  // MANIPULATORS
  template <class MANIPULATOR>
  int MySequenceWithNillableBase64Binary::manipulateAttributes(MANIPULATOR& manipulator)
  {
      int ret;
  
      ret = manipulator(&d_attribute1, ATTRIBUTE_INFO_ARRAY[ATTRIBUTE_INDEX_ATTRIBUTE1]);
      if (ret) {
          return ret;
      }
  
      return 0;
  }
  
  template <class MANIPULATOR>
  int MySequenceWithNillableBase64Binary::manipulateAttribute(MANIPULATOR& manipulator, int id)
  {
      enum { NOT_FOUND = -1 };
  
      switch (id) {
        case ATTRIBUTE_ID_ATTRIBUTE1: {
          return manipulator(&d_attribute1, ATTRIBUTE_INFO_ARRAY[ATTRIBUTE_INDEX_ATTRIBUTE1]);
        }
        default:
          return NOT_FOUND;
      }
  }
  
  template <class MANIPULATOR>
  int MySequenceWithNillableBase64Binary::manipulateAttribute(
          MANIPULATOR&  manipulator,
          const char   *name,
          int           nameLength)
  {
      enum { NOT_FOUND = -1 };
  
      const bdlat_AttributeInfo *attributeInfo =
                                           lookupAttributeInfo(name, nameLength);
      if (0 == attributeInfo) {
          return NOT_FOUND;
      }
  
      return manipulateAttribute(manipulator, attributeInfo->d_id);
  }
  
  inline
  bdlb::NullableValue<bsl::vector<char> >& MySequenceWithNillableBase64Binary::attribute1()
  {
      return d_attribute1;
  }
  
  // ACCESSORS
  template <class ACCESSOR>
  int MySequenceWithNillableBase64Binary::accessAttributes(ACCESSOR& accessor) const
  {
      int ret;
  
      ret = accessor(d_attribute1, ATTRIBUTE_INFO_ARRAY[ATTRIBUTE_INDEX_ATTRIBUTE1]);
      if (ret) {
          return ret;
      }
  
      return 0;
  }
  
  template <class ACCESSOR>
  int MySequenceWithNillableBase64Binary::accessAttribute(ACCESSOR& accessor, int id) const
  {
      enum { NOT_FOUND = -1 };
  
      switch (id) {
        case ATTRIBUTE_ID_ATTRIBUTE1: {
          return accessor(d_attribute1, ATTRIBUTE_INFO_ARRAY[ATTRIBUTE_INDEX_ATTRIBUTE1]);
        }
        default:
          return NOT_FOUND;
      }
  }
  
  template <class ACCESSOR>
  int MySequenceWithNillableBase64Binary::accessAttribute(
          ACCESSOR&   accessor,
          const char *name,
          int         nameLength) const
  {
      enum { NOT_FOUND = -1 };
  
      const bdlat_AttributeInfo *attributeInfo =
            lookupAttributeInfo(name, nameLength);
      if (0 == attributeInfo) {
         return NOT_FOUND;
      }
  
      return accessAttribute(accessor, attributeInfo->d_id);
  }
  
  inline
  const bdlb::NullableValue<bsl::vector<char> >& MySequenceWithNillableBase64Binary::attribute1() const
  {
      return d_attribute1;
  }
  
  
  
                     // -------------------------------------
                     // class MySequenceWithNillableHexBinary
                     // -------------------------------------
  
  // CLASS METHODS
  // MANIPULATORS
  template <class MANIPULATOR>
  int MySequenceWithNillableHexBinary::manipulateAttributes(MANIPULATOR& manipulator)
  {
      int ret;
  
      ret = manipulator(&d_attribute1, ATTRIBUTE_INFO_ARRAY[ATTRIBUTE_INDEX_ATTRIBUTE1]);
      if (ret) {
          return ret;
      }
  
      return 0;
  }
  
  template <class MANIPULATOR>
  int MySequenceWithNillableHexBinary::manipulateAttribute(MANIPULATOR& manipulator, int id)
  {
      enum { NOT_FOUND = -1 };
  
      switch (id) {
        case ATTRIBUTE_ID_ATTRIBUTE1: {
          return manipulator(&d_attribute1, ATTRIBUTE_INFO_ARRAY[ATTRIBUTE_INDEX_ATTRIBUTE1]);
        }
        default:
          return NOT_FOUND;
      }
  }
  
  template <class MANIPULATOR>
  int MySequenceWithNillableHexBinary::manipulateAttribute(
          MANIPULATOR&  manipulator,
          const char   *name,
          int           nameLength)
  {
      enum { NOT_FOUND = -1 };
  
      const bdlat_AttributeInfo *attributeInfo =
                                           lookupAttributeInfo(name, nameLength);
      if (0 == attributeInfo) {
          return NOT_FOUND;
      }
  
      return manipulateAttribute(manipulator, attributeInfo->d_id);
  }
  
  inline
  bdlb::NullableValue<bsl::vector<char> >& MySequenceWithNillableHexBinary::attribute1()
  {
      return d_attribute1;
  }
  
  // ACCESSORS
  template <class ACCESSOR>
  int MySequenceWithNillableHexBinary::accessAttributes(ACCESSOR& accessor) const
  {
      int ret;
  
      ret = accessor(d_attribute1, ATTRIBUTE_INFO_ARRAY[ATTRIBUTE_INDEX_ATTRIBUTE1]);
      if (ret) {
          return ret;
      }
  
      return 0;
  }
  
  template <class ACCESSOR>
  int MySequenceWithNillableHexBinary::accessAttribute(ACCESSOR& accessor, int id) const
  {
      enum { NOT_FOUND = -1 };
  
      switch (id) {
        case ATTRIBUTE_ID_ATTRIBUTE1: {
          return accessor(d_attribute1, ATTRIBUTE_INFO_ARRAY[ATTRIBUTE_INDEX_ATTRIBUTE1]);
        }
        default:
          return NOT_FOUND;
      }
  }
  
  template <class ACCESSOR>
  int MySequenceWithNillableHexBinary::accessAttribute(
          ACCESSOR&   accessor,
          const char *name,
          int         nameLength) const
  {
      enum { NOT_FOUND = -1 };
  
      const bdlat_AttributeInfo *attributeInfo =
            lookupAttributeInfo(name, nameLength);
      if (0 == attributeInfo) {
         return NOT_FOUND;
      }
  
      return accessAttribute(accessor, attributeInfo->d_id);
  }
  
  inline
  const bdlb::NullableValue<bsl::vector<char> >& MySequenceWithNillableHexBinary::attribute1() const
  {
      return d_attribute1;
  }
  
  
  
                      // ------------------------------------
                      // class MySequenceWithNillableIntArray
                      // ------------------------------------
  
  // CLASS METHODS
  // MANIPULATORS
  template <class MANIPULATOR>
  int MySequenceWithNillableIntArray::manipulateAttributes(MANIPULATOR& manipulator)
  {
      int ret;
  
      ret = manipulator(&d_attribute1, ATTRIBUTE_INFO_ARRAY[ATTRIBUTE_INDEX_ATTRIBUTE1]);
      if (ret) {
          return ret;
      }
  
      return 0;
  }
  
  template <class MANIPULATOR>
  int MySequenceWithNillableIntArray::manipulateAttribute(MANIPULATOR& manipulator, int id)
  {
      enum { NOT_FOUND = -1 };
  
      switch (id) {
        case ATTRIBUTE_ID_ATTRIBUTE1: {
          return manipulator(&d_attribute1, ATTRIBUTE_INFO_ARRAY[ATTRIBUTE_INDEX_ATTRIBUTE1]);
        }
        default:
          return NOT_FOUND;
      }
  }
  
  template <class MANIPULATOR>
  int MySequenceWithNillableIntArray::manipulateAttribute(
          MANIPULATOR&  manipulator,
          const char   *name,
          int           nameLength)
  {
      enum { NOT_FOUND = -1 };
  
      const bdlat_AttributeInfo *attributeInfo =
                                           lookupAttributeInfo(name, nameLength);
      if (0 == attributeInfo) {
          return NOT_FOUND;
      }
  
      return manipulateAttribute(manipulator, attributeInfo->d_id);
  }
  
  inline
  bsl::vector<bdlb::NullableValue<int> >& MySequenceWithNillableIntArray::attribute1()
  {
      return d_attribute1;
  }
  
  // ACCESSORS
  template <class ACCESSOR>
  int MySequenceWithNillableIntArray::accessAttributes(ACCESSOR& accessor) const
  {
      int ret;
  
      ret = accessor(d_attribute1, ATTRIBUTE_INFO_ARRAY[ATTRIBUTE_INDEX_ATTRIBUTE1]);
      if (ret) {
          return ret;
      }
  
      return 0;
  }
  
  template <class ACCESSOR>
  int MySequenceWithNillableIntArray::accessAttribute(ACCESSOR& accessor, int id) const
  {
      enum { NOT_FOUND = -1 };
  
      switch (id) {
        case ATTRIBUTE_ID_ATTRIBUTE1: {
          return accessor(d_attribute1, ATTRIBUTE_INFO_ARRAY[ATTRIBUTE_INDEX_ATTRIBUTE1]);
        }
        default:
          return NOT_FOUND;
      }
  }
  
  template <class ACCESSOR>
  int MySequenceWithNillableIntArray::accessAttribute(
          ACCESSOR&   accessor,
          const char *name,
          int         nameLength) const
  {
      enum { NOT_FOUND = -1 };
  
      const bdlat_AttributeInfo *attributeInfo =
            lookupAttributeInfo(name, nameLength);
      if (0 == attributeInfo) {
         return NOT_FOUND;
      }
  
      return accessAttribute(accessor, attributeInfo->d_id);
  }
  
  inline
  const bsl::vector<bdlb::NullableValue<int> >& MySequenceWithNillableIntArray::attribute1() const
  {
      return d_attribute1;
  }
  
  
  
              // ----------------------------------------------------
              // class MySequenceWithNillableIntSequenceArraySequence
              // ----------------------------------------------------
  
  // CLASS METHODS
  // MANIPULATORS
  template <class MANIPULATOR>
  int MySequenceWithNillableIntSequenceArraySequence::manipulateAttributes(MANIPULATOR& manipulator)
  {
      int ret;
  
      ret = manipulator(&d_attribute1, ATTRIBUTE_INFO_ARRAY[ATTRIBUTE_INDEX_ATTRIBUTE1]);
      if (ret) {
          return ret;
      }
  
      return 0;
  }
  
  template <class MANIPULATOR>
  int MySequenceWithNillableIntSequenceArraySequence::manipulateAttribute(MANIPULATOR& manipulator, int id)
  {
      enum { NOT_FOUND = -1 };
  
      switch (id) {
        case ATTRIBUTE_ID_ATTRIBUTE1: {
          return manipulator(&d_attribute1, ATTRIBUTE_INFO_ARRAY[ATTRIBUTE_INDEX_ATTRIBUTE1]);
        }
        default:
          return NOT_FOUND;
      }
  }
  
  template <class MANIPULATOR>
  int MySequenceWithNillableIntSequenceArraySequence::manipulateAttribute(
          MANIPULATOR&  manipulator,
          const char   *name,
          int           nameLength)
  {
      enum { NOT_FOUND = -1 };
  
      const bdlat_AttributeInfo *attributeInfo =
                                           lookupAttributeInfo(name, nameLength);
      if (0 == attributeInfo) {
          return NOT_FOUND;
      }
  
      return manipulateAttribute(manipulator, attributeInfo->d_id);
  }
  
  inline
  int& MySequenceWithNillableIntSequenceArraySequence::attribute1()
  {
      return d_attribute1;
  }
  
  // ACCESSORS
  template <class ACCESSOR>
  int MySequenceWithNillableIntSequenceArraySequence::accessAttributes(ACCESSOR& accessor) const
  {
      int ret;
  
      ret = accessor(d_attribute1, ATTRIBUTE_INFO_ARRAY[ATTRIBUTE_INDEX_ATTRIBUTE1]);
      if (ret) {
          return ret;
      }
  
      return 0;
  }
  
  template <class ACCESSOR>
  int MySequenceWithNillableIntSequenceArraySequence::accessAttribute(ACCESSOR& accessor, int id) const
  {
      enum { NOT_FOUND = -1 };
  
      switch (id) {
        case ATTRIBUTE_ID_ATTRIBUTE1: {
          return accessor(d_attribute1, ATTRIBUTE_INFO_ARRAY[ATTRIBUTE_INDEX_ATTRIBUTE1]);
        }
        default:
          return NOT_FOUND;
      }
  }
  
  template <class ACCESSOR>
  int MySequenceWithNillableIntSequenceArraySequence::accessAttribute(
          ACCESSOR&   accessor,
          const char *name,
          int         nameLength) const
  {
      enum { NOT_FOUND = -1 };
  
      const bdlat_AttributeInfo *attributeInfo =
            lookupAttributeInfo(name, nameLength);
      if (0 == attributeInfo) {
         return NOT_FOUND;
      }
  
      return accessAttribute(accessor, attributeInfo->d_id);
  }
  
  inline
  int MySequenceWithNillableIntSequenceArraySequence::attribute1() const
  {
      return d_attribute1;
  }
  
  
  
                    // ---------------------------------------
                    // class MySequenceWithNillableStringArray
                    // ---------------------------------------
  
  // CLASS METHODS
  // MANIPULATORS
  template <class MANIPULATOR>
  int MySequenceWithNillableStringArray::manipulateAttributes(MANIPULATOR& manipulator)
  {
      int ret;
  
      ret = manipulator(&d_attribute1, ATTRIBUTE_INFO_ARRAY[ATTRIBUTE_INDEX_ATTRIBUTE1]);
      if (ret) {
          return ret;
      }
  
      return 0;
  }
  
  template <class MANIPULATOR>
  int MySequenceWithNillableStringArray::manipulateAttribute(MANIPULATOR& manipulator, int id)
  {
      enum { NOT_FOUND = -1 };
  
      switch (id) {
        case ATTRIBUTE_ID_ATTRIBUTE1: {
          return manipulator(&d_attribute1, ATTRIBUTE_INFO_ARRAY[ATTRIBUTE_INDEX_ATTRIBUTE1]);
        }
        default:
          return NOT_FOUND;
      }
  }
  
  template <class MANIPULATOR>
  int MySequenceWithNillableStringArray::manipulateAttribute(
          MANIPULATOR&  manipulator,
          const char   *name,
          int           nameLength)
  {
      enum { NOT_FOUND = -1 };
  
      const bdlat_AttributeInfo *attributeInfo =
                                           lookupAttributeInfo(name, nameLength);
      if (0 == attributeInfo) {
          return NOT_FOUND;
      }
  
      return manipulateAttribute(manipulator, attributeInfo->d_id);
  }
  
  inline
  bsl::vector<bdlb::NullableValue<bsl::string> >& MySequenceWithNillableStringArray::attribute1()
  {
      return d_attribute1;
  }
  
  // ACCESSORS
  template <class ACCESSOR>
  int MySequenceWithNillableStringArray::accessAttributes(ACCESSOR& accessor) const
  {
      int ret;
  
      ret = accessor(d_attribute1, ATTRIBUTE_INFO_ARRAY[ATTRIBUTE_INDEX_ATTRIBUTE1]);
      if (ret) {
          return ret;
      }
  
      return 0;
  }
  
  template <class ACCESSOR>
  int MySequenceWithNillableStringArray::accessAttribute(ACCESSOR& accessor, int id) const
  {
      enum { NOT_FOUND = -1 };
  
      switch (id) {
        case ATTRIBUTE_ID_ATTRIBUTE1: {
          return accessor(d_attribute1, ATTRIBUTE_INFO_ARRAY[ATTRIBUTE_INDEX_ATTRIBUTE1]);
        }
        default:
          return NOT_FOUND;
      }
  }
  
  template <class ACCESSOR>
  int MySequenceWithNillableStringArray::accessAttribute(
          ACCESSOR&   accessor,
          const char *name,
          int         nameLength) const
  {
      enum { NOT_FOUND = -1 };
  
      const bdlat_AttributeInfo *attributeInfo =
            lookupAttributeInfo(name, nameLength);
      if (0 == attributeInfo) {
         return NOT_FOUND;
      }
  
      return accessAttribute(accessor, attributeInfo->d_id);
  }
  
  inline
  const bsl::vector<bdlb::NullableValue<bsl::string> >& MySequenceWithNillableStringArray::attribute1() const
  {
      return d_attribute1;
  }
  
  
  
            // -------------------------------------------------------
            // class MySequenceWithNillableStringSequenceArraySequence
            // -------------------------------------------------------
  
  // CLASS METHODS
  // MANIPULATORS
  template <class MANIPULATOR>
  int MySequenceWithNillableStringSequenceArraySequence::manipulateAttributes(MANIPULATOR& manipulator)
  {
      int ret;
  
      ret = manipulator(&d_attribute1, ATTRIBUTE_INFO_ARRAY[ATTRIBUTE_INDEX_ATTRIBUTE1]);
      if (ret) {
          return ret;
      }
  
      return 0;
  }
  
  template <class MANIPULATOR>
  int MySequenceWithNillableStringSequenceArraySequence::manipulateAttribute(MANIPULATOR& manipulator, int id)
  {
      enum { NOT_FOUND = -1 };
  
      switch (id) {
        case ATTRIBUTE_ID_ATTRIBUTE1: {
          return manipulator(&d_attribute1, ATTRIBUTE_INFO_ARRAY[ATTRIBUTE_INDEX_ATTRIBUTE1]);
        }
        default:
          return NOT_FOUND;
      }
  }
  
  template <class MANIPULATOR>
  int MySequenceWithNillableStringSequenceArraySequence::manipulateAttribute(
          MANIPULATOR&  manipulator,
          const char   *name,
          int           nameLength)
  {
      enum { NOT_FOUND = -1 };
  
      const bdlat_AttributeInfo *attributeInfo =
                                           lookupAttributeInfo(name, nameLength);
      if (0 == attributeInfo) {
          return NOT_FOUND;
      }
  
      return manipulateAttribute(manipulator, attributeInfo->d_id);
  }
  
  inline
  bsl::string& MySequenceWithNillableStringSequenceArraySequence::attribute1()
  {
      return d_attribute1;
  }
  
  // ACCESSORS
  template <class ACCESSOR>
  int MySequenceWithNillableStringSequenceArraySequence::accessAttributes(ACCESSOR& accessor) const
  {
      int ret;
  
      ret = accessor(d_attribute1, ATTRIBUTE_INFO_ARRAY[ATTRIBUTE_INDEX_ATTRIBUTE1]);
      if (ret) {
          return ret;
      }
  
      return 0;
  }
  
  template <class ACCESSOR>
  int MySequenceWithNillableStringSequenceArraySequence::accessAttribute(ACCESSOR& accessor, int id) const
  {
      enum { NOT_FOUND = -1 };
  
      switch (id) {
        case ATTRIBUTE_ID_ATTRIBUTE1: {
          return accessor(d_attribute1, ATTRIBUTE_INFO_ARRAY[ATTRIBUTE_INDEX_ATTRIBUTE1]);
        }
        default:
          return NOT_FOUND;
      }
  }
  
  template <class ACCESSOR>
  int MySequenceWithNillableStringSequenceArraySequence::accessAttribute(
          ACCESSOR&   accessor,
          const char *name,
          int         nameLength) const
  {
      enum { NOT_FOUND = -1 };
  
      const bdlat_AttributeInfo *attributeInfo =
            lookupAttributeInfo(name, nameLength);
      if (0 == attributeInfo) {
         return NOT_FOUND;
      }
  
      return accessAttribute(accessor, attributeInfo->d_id);
  }
  
  inline
  const bsl::string& MySequenceWithNillableStringSequenceArraySequence::attribute1() const
  {
      return d_attribute1;
  }
  
  
  
                      // -----------------------------------
                      // class MySequenceWithNillableIntList
                      // -----------------------------------
  
  // CLASS METHODS
  // MANIPULATORS
  template <class MANIPULATOR>
  int MySequenceWithNillableIntList::manipulateAttributes(MANIPULATOR& manipulator)
  {
      int ret;
  
      ret = manipulator(&d_attribute1, ATTRIBUTE_INFO_ARRAY[ATTRIBUTE_INDEX_ATTRIBUTE1]);
      if (ret) {
          return ret;
      }
  
      return 0;
  }
  
  template <class MANIPULATOR>
  int MySequenceWithNillableIntList::manipulateAttribute(MANIPULATOR& manipulator, int id)
  {
      enum { NOT_FOUND = -1 };
  
      switch (id) {
        case ATTRIBUTE_ID_ATTRIBUTE1: {
          return manipulator(&d_attribute1, ATTRIBUTE_INFO_ARRAY[ATTRIBUTE_INDEX_ATTRIBUTE1]);
        }
        default:
          return NOT_FOUND;
      }
  }
  
  template <class MANIPULATOR>
  int MySequenceWithNillableIntList::manipulateAttribute(
          MANIPULATOR&  manipulator,
          const char   *name,
          int           nameLength)
  {
      enum { NOT_FOUND = -1 };
  
      const bdlat_AttributeInfo *attributeInfo =
                                           lookupAttributeInfo(name, nameLength);
      if (0 == attributeInfo) {
          return NOT_FOUND;
      }
  
      return manipulateAttribute(manipulator, attributeInfo->d_id);
  }
  
  inline
  bsl::vector<bdlb::NullableValue<int> >& MySequenceWithNillableIntList::attribute1()
  {
      return d_attribute1;
  }
  
  // ACCESSORS
  template <class ACCESSOR>
  int MySequenceWithNillableIntList::accessAttributes(ACCESSOR& accessor) const
  {
      int ret;
  
      ret = accessor(d_attribute1, ATTRIBUTE_INFO_ARRAY[ATTRIBUTE_INDEX_ATTRIBUTE1]);
      if (ret) {
          return ret;
      }
  
      return 0;
  }
  
  template <class ACCESSOR>
  int MySequenceWithNillableIntList::accessAttribute(ACCESSOR& accessor, int id) const
  {
      enum { NOT_FOUND = -1 };
  
      switch (id) {
        case ATTRIBUTE_ID_ATTRIBUTE1: {
          return accessor(d_attribute1, ATTRIBUTE_INFO_ARRAY[ATTRIBUTE_INDEX_ATTRIBUTE1]);
        }
        default:
          return NOT_FOUND;
      }
  }
  
  template <class ACCESSOR>
  int MySequenceWithNillableIntList::accessAttribute(
          ACCESSOR&   accessor,
          const char *name,
          int         nameLength) const
  {
      enum { NOT_FOUND = -1 };
  
      const bdlat_AttributeInfo *attributeInfo =
            lookupAttributeInfo(name, nameLength);
      if (0 == attributeInfo) {
         return NOT_FOUND;
      }
  
      return accessAttribute(accessor, attributeInfo->d_id);
  }
  
  inline
  const bsl::vector<bdlb::NullableValue<int> >& MySequenceWithNillableIntList::attribute1() const
  {
      return d_attribute1;
  }
  
  
  
                  // --------------------------------------------
                  // class MySequenceWithNillableIntSequenceArray
                  // --------------------------------------------
  
  // CLASS METHODS
  // MANIPULATORS
  template <class MANIPULATOR>
  int MySequenceWithNillableIntSequenceArray::manipulateAttributes(MANIPULATOR& manipulator)
  {
      int ret;
  
      ret = manipulator(&d_attribute1, ATTRIBUTE_INFO_ARRAY[ATTRIBUTE_INDEX_ATTRIBUTE1]);
      if (ret) {
          return ret;
      }
  
      return 0;
  }
  
  template <class MANIPULATOR>
  int MySequenceWithNillableIntSequenceArray::manipulateAttribute(MANIPULATOR& manipulator, int id)
  {
      enum { NOT_FOUND = -1 };
  
      switch (id) {
        case ATTRIBUTE_ID_ATTRIBUTE1: {
          return manipulator(&d_attribute1, ATTRIBUTE_INFO_ARRAY[ATTRIBUTE_INDEX_ATTRIBUTE1]);
        }
        default:
          return NOT_FOUND;
      }
  }
  
  template <class MANIPULATOR>
  int MySequenceWithNillableIntSequenceArray::manipulateAttribute(
          MANIPULATOR&  manipulator,
          const char   *name,
          int           nameLength)
  {
      enum { NOT_FOUND = -1 };
  
      const bdlat_AttributeInfo *attributeInfo =
                                           lookupAttributeInfo(name, nameLength);
      if (0 == attributeInfo) {
          return NOT_FOUND;
      }
  
      return manipulateAttribute(manipulator, attributeInfo->d_id);
  }
  
  inline
  bsl::vector<bdlb::NullableValue<MySequenceWithNillableIntSequenceArraySequence> >& MySequenceWithNillableIntSequenceArray::attribute1()
  {
      return d_attribute1;
  }
  
  // ACCESSORS
  template <class ACCESSOR>
  int MySequenceWithNillableIntSequenceArray::accessAttributes(ACCESSOR& accessor) const
  {
      int ret;
  
      ret = accessor(d_attribute1, ATTRIBUTE_INFO_ARRAY[ATTRIBUTE_INDEX_ATTRIBUTE1]);
      if (ret) {
          return ret;
      }
  
      return 0;
  }
  
  template <class ACCESSOR>
  int MySequenceWithNillableIntSequenceArray::accessAttribute(ACCESSOR& accessor, int id) const
  {
      enum { NOT_FOUND = -1 };
  
      switch (id) {
        case ATTRIBUTE_ID_ATTRIBUTE1: {
          return accessor(d_attribute1, ATTRIBUTE_INFO_ARRAY[ATTRIBUTE_INDEX_ATTRIBUTE1]);
        }
        default:
          return NOT_FOUND;
      }
  }
  
  template <class ACCESSOR>
  int MySequenceWithNillableIntSequenceArray::accessAttribute(
          ACCESSOR&   accessor,
          const char *name,
          int         nameLength) const
  {
      enum { NOT_FOUND = -1 };
  
      const bdlat_AttributeInfo *attributeInfo =
            lookupAttributeInfo(name, nameLength);
      if (0 == attributeInfo) {
         return NOT_FOUND;
      }
  
      return accessAttribute(accessor, attributeInfo->d_id);
  }
  
  inline
  const bsl::vector<bdlb::NullableValue<MySequenceWithNillableIntSequenceArraySequence> >& MySequenceWithNillableIntSequenceArray::attribute1() const
  {
      return d_attribute1;
  }
  
  
  
                     // --------------------------------------
                     // class MySequenceWithNillableStringList
                     // --------------------------------------
  
  // CLASS METHODS
  // MANIPULATORS
  template <class MANIPULATOR>
  int MySequenceWithNillableStringList::manipulateAttributes(MANIPULATOR& manipulator)
  {
      int ret;
  
      ret = manipulator(&d_attribute1, ATTRIBUTE_INFO_ARRAY[ATTRIBUTE_INDEX_ATTRIBUTE1]);
      if (ret) {
          return ret;
      }
  
      return 0;
  }
  
  template <class MANIPULATOR>
  int MySequenceWithNillableStringList::manipulateAttribute(MANIPULATOR& manipulator, int id)
  {
      enum { NOT_FOUND = -1 };
  
      switch (id) {
        case ATTRIBUTE_ID_ATTRIBUTE1: {
          return manipulator(&d_attribute1, ATTRIBUTE_INFO_ARRAY[ATTRIBUTE_INDEX_ATTRIBUTE1]);
        }
        default:
          return NOT_FOUND;
      }
  }
  
  template <class MANIPULATOR>
  int MySequenceWithNillableStringList::manipulateAttribute(
          MANIPULATOR&  manipulator,
          const char   *name,
          int           nameLength)
  {
      enum { NOT_FOUND = -1 };
  
      const bdlat_AttributeInfo *attributeInfo =
                                           lookupAttributeInfo(name, nameLength);
      if (0 == attributeInfo) {
          return NOT_FOUND;
      }
  
      return manipulateAttribute(manipulator, attributeInfo->d_id);
  }
  
  inline
  bsl::vector<bdlb::NullableValue<bsl::string> >& MySequenceWithNillableStringList::attribute1()
  {
      return d_attribute1;
  }
  
  // ACCESSORS
  template <class ACCESSOR>
  int MySequenceWithNillableStringList::accessAttributes(ACCESSOR& accessor) const
  {
      int ret;
  
      ret = accessor(d_attribute1, ATTRIBUTE_INFO_ARRAY[ATTRIBUTE_INDEX_ATTRIBUTE1]);
      if (ret) {
          return ret;
      }
  
      return 0;
  }
  
  template <class ACCESSOR>
  int MySequenceWithNillableStringList::accessAttribute(ACCESSOR& accessor, int id) const
  {
      enum { NOT_FOUND = -1 };
  
      switch (id) {
        case ATTRIBUTE_ID_ATTRIBUTE1: {
          return accessor(d_attribute1, ATTRIBUTE_INFO_ARRAY[ATTRIBUTE_INDEX_ATTRIBUTE1]);
        }
        default:
          return NOT_FOUND;
      }
  }
  
  template <class ACCESSOR>
  int MySequenceWithNillableStringList::accessAttribute(
          ACCESSOR&   accessor,
          const char *name,
          int         nameLength) const
  {
      enum { NOT_FOUND = -1 };
  
      const bdlat_AttributeInfo *attributeInfo =
            lookupAttributeInfo(name, nameLength);
      if (0 == attributeInfo) {
         return NOT_FOUND;
      }
  
      return accessAttribute(accessor, attributeInfo->d_id);
  }
  
  inline
  const bsl::vector<bdlb::NullableValue<bsl::string> >& MySequenceWithNillableStringList::attribute1() const
  {
      return d_attribute1;
  }
  
  
  
                // -----------------------------------------------
                // class MySequenceWithNillableStringSequenceArray
                // -----------------------------------------------
  
  // CLASS METHODS
  // MANIPULATORS
  template <class MANIPULATOR>
  int MySequenceWithNillableStringSequenceArray::manipulateAttributes(MANIPULATOR& manipulator)
  {
      int ret;
  
      ret = manipulator(&d_attribute1, ATTRIBUTE_INFO_ARRAY[ATTRIBUTE_INDEX_ATTRIBUTE1]);
      if (ret) {
          return ret;
      }
  
      return 0;
  }
  
  template <class MANIPULATOR>
  int MySequenceWithNillableStringSequenceArray::manipulateAttribute(MANIPULATOR& manipulator, int id)
  {
      enum { NOT_FOUND = -1 };
  
      switch (id) {
        case ATTRIBUTE_ID_ATTRIBUTE1: {
          return manipulator(&d_attribute1, ATTRIBUTE_INFO_ARRAY[ATTRIBUTE_INDEX_ATTRIBUTE1]);
        }
        default:
          return NOT_FOUND;
      }
  }
  
  template <class MANIPULATOR>
  int MySequenceWithNillableStringSequenceArray::manipulateAttribute(
          MANIPULATOR&  manipulator,
          const char   *name,
          int           nameLength)
  {
      enum { NOT_FOUND = -1 };
  
      const bdlat_AttributeInfo *attributeInfo =
                                           lookupAttributeInfo(name, nameLength);
      if (0 == attributeInfo) {
          return NOT_FOUND;
      }
  
      return manipulateAttribute(manipulator, attributeInfo->d_id);
  }
  
  inline
  bsl::vector<bdlb::NullableValue<MySequenceWithNillableStringSequenceArraySequence> >& MySequenceWithNillableStringSequenceArray::attribute1()
  {
      return d_attribute1;
  }
  
  // ACCESSORS
  template <class ACCESSOR>
  int MySequenceWithNillableStringSequenceArray::accessAttributes(ACCESSOR& accessor) const
  {
      int ret;
  
      ret = accessor(d_attribute1, ATTRIBUTE_INFO_ARRAY[ATTRIBUTE_INDEX_ATTRIBUTE1]);
      if (ret) {
          return ret;
      }
  
      return 0;
  }
  
  template <class ACCESSOR>
  int MySequenceWithNillableStringSequenceArray::accessAttribute(ACCESSOR& accessor, int id) const
  {
      enum { NOT_FOUND = -1 };
  
      switch (id) {
        case ATTRIBUTE_ID_ATTRIBUTE1: {
          return accessor(d_attribute1, ATTRIBUTE_INFO_ARRAY[ATTRIBUTE_INDEX_ATTRIBUTE1]);
        }
        default:
          return NOT_FOUND;
      }
  }
  
  template <class ACCESSOR>
  int MySequenceWithNillableStringSequenceArray::accessAttribute(
          ACCESSOR&   accessor,
          const char *name,
          int         nameLength) const
  {
      enum { NOT_FOUND = -1 };
  
      const bdlat_AttributeInfo *attributeInfo =
            lookupAttributeInfo(name, nameLength);
      if (0 == attributeInfo) {
         return NOT_FOUND;
      }
  
      return accessAttribute(accessor, attributeInfo->d_id);
  }
  
  inline
  const bsl::vector<bdlb::NullableValue<MySequenceWithNillableStringSequenceArraySequence> >& MySequenceWithNillableStringSequenceArray::attribute1() const
  {
      return d_attribute1;
  }
  
  }  // close package namespace
  
  // FREE FUNCTIONS
  
  inline
  bool s_baltst::operator==(
          const s_baltst::MySequenceWithNillable& lhs,
          const s_baltst::MySequenceWithNillable& rhs)
  {
      return  lhs.attribute1() == rhs.attribute1()
           && lhs.myNillable() == rhs.myNillable()
           && lhs.attribute2() == rhs.attribute2();
  }
  
  inline
  bool s_baltst::operator!=(
          const s_baltst::MySequenceWithNillable& lhs,
          const s_baltst::MySequenceWithNillable& rhs)
  {
      return !(lhs == rhs);
  }
  
  inline
  bsl::ostream& s_baltst::operator<<(
          bsl::ostream& stream,
          const s_baltst::MySequenceWithNillable& rhs)
  {
      return rhs.print(stream, 0, -1);
  }
  
  
  inline
  bool s_baltst::operator==(
          const s_baltst::MySequenceWithNillableBase64Binary& lhs,
          const s_baltst::MySequenceWithNillableBase64Binary& rhs)
  {
      return  lhs.attribute1() == rhs.attribute1();
  }
  
  inline
  bool s_baltst::operator!=(
          const s_baltst::MySequenceWithNillableBase64Binary& lhs,
          const s_baltst::MySequenceWithNillableBase64Binary& rhs)
  {
      return !(lhs == rhs);
  }
  
  inline
  bsl::ostream& s_baltst::operator<<(
          bsl::ostream& stream,
          const s_baltst::MySequenceWithNillableBase64Binary& rhs)
  {
      return rhs.print(stream, 0, -1);
  }
  
  
  inline
  bool s_baltst::operator==(
          const s_baltst::MySequenceWithNillableHexBinary& lhs,
          const s_baltst::MySequenceWithNillableHexBinary& rhs)
  {
      return  lhs.attribute1() == rhs.attribute1();
  }
  
  inline
  bool s_baltst::operator!=(
          const s_baltst::MySequenceWithNillableHexBinary& lhs,
          const s_baltst::MySequenceWithNillableHexBinary& rhs)
  {
      return !(lhs == rhs);
  }
  
  inline
  bsl::ostream& s_baltst::operator<<(
          bsl::ostream& stream,
          const s_baltst::MySequenceWithNillableHexBinary& rhs)
  {
      return rhs.print(stream, 0, -1);
  }
  
  
  inline
  bool s_baltst::operator==(
          const s_baltst::MySequenceWithNillableIntArray& lhs,
          const s_baltst::MySequenceWithNillableIntArray& rhs)
  {
      return  lhs.attribute1() == rhs.attribute1();
  }
  
  inline
  bool s_baltst::operator!=(
          const s_baltst::MySequenceWithNillableIntArray& lhs,
          const s_baltst::MySequenceWithNillableIntArray& rhs)
  {
      return !(lhs == rhs);
  }
  
  inline
  bsl::ostream& s_baltst::operator<<(
          bsl::ostream& stream,
          const s_baltst::MySequenceWithNillableIntArray& rhs)
  {
      return rhs.print(stream, 0, -1);
  }
  
  
  inline
  bool s_baltst::operator==(
          const s_baltst::MySequenceWithNillableIntSequenceArraySequence& lhs,
          const s_baltst::MySequenceWithNillableIntSequenceArraySequence& rhs)
  {
      return  lhs.attribute1() == rhs.attribute1();
  }
  
  inline
  bool s_baltst::operator!=(
          const s_baltst::MySequenceWithNillableIntSequenceArraySequence& lhs,
          const s_baltst::MySequenceWithNillableIntSequenceArraySequence& rhs)
  {
      return !(lhs == rhs);
  }
  
  inline
  bsl::ostream& s_baltst::operator<<(
          bsl::ostream& stream,
          const s_baltst::MySequenceWithNillableIntSequenceArraySequence& rhs)
  {
      return rhs.print(stream, 0, -1);
  }
  
  
  inline
  bool s_baltst::operator==(
          const s_baltst::MySequenceWithNillableStringArray& lhs,
          const s_baltst::MySequenceWithNillableStringArray& rhs)
  {
      return  lhs.attribute1() == rhs.attribute1();
  }
  
  inline
  bool s_baltst::operator!=(
          const s_baltst::MySequenceWithNillableStringArray& lhs,
          const s_baltst::MySequenceWithNillableStringArray& rhs)
  {
      return !(lhs == rhs);
  }
  
  inline
  bsl::ostream& s_baltst::operator<<(
          bsl::ostream& stream,
          const s_baltst::MySequenceWithNillableStringArray& rhs)
  {
      return rhs.print(stream, 0, -1);
  }
  
  
  inline
  bool s_baltst::operator==(
          const s_baltst::MySequenceWithNillableStringSequenceArraySequence& lhs,
          const s_baltst::MySequenceWithNillableStringSequenceArraySequence& rhs)
  {
      return  lhs.attribute1() == rhs.attribute1();
  }
  
  inline
  bool s_baltst::operator!=(
          const s_baltst::MySequenceWithNillableStringSequenceArraySequence& lhs,
          const s_baltst::MySequenceWithNillableStringSequenceArraySequence& rhs)
  {
      return !(lhs == rhs);
  }
  
  inline
  bsl::ostream& s_baltst::operator<<(
          bsl::ostream& stream,
          const s_baltst::MySequenceWithNillableStringSequenceArraySequence& rhs)
  {
      return rhs.print(stream, 0, -1);
  }
  
  
  inline
  bool s_baltst::operator==(
          const s_baltst::MySequenceWithNillableIntList& lhs,
          const s_baltst::MySequenceWithNillableIntList& rhs)
  {
      return  lhs.attribute1() == rhs.attribute1();
  }
  
  inline
  bool s_baltst::operator!=(
          const s_baltst::MySequenceWithNillableIntList& lhs,
          const s_baltst::MySequenceWithNillableIntList& rhs)
  {
      return !(lhs == rhs);
  }
  
  inline
  bsl::ostream& s_baltst::operator<<(
          bsl::ostream& stream,
          const s_baltst::MySequenceWithNillableIntList& rhs)
  {
      return rhs.print(stream, 0, -1);
  }
  
  
  inline
  bool s_baltst::operator==(
          const s_baltst::MySequenceWithNillableIntSequenceArray& lhs,
          const s_baltst::MySequenceWithNillableIntSequenceArray& rhs)
  {
      return  lhs.attribute1() == rhs.attribute1();
  }
  
  inline
  bool s_baltst::operator!=(
          const s_baltst::MySequenceWithNillableIntSequenceArray& lhs,
          const s_baltst::MySequenceWithNillableIntSequenceArray& rhs)
  {
      return !(lhs == rhs);
  }
  
  inline
  bsl::ostream& s_baltst::operator<<(
          bsl::ostream& stream,
          const s_baltst::MySequenceWithNillableIntSequenceArray& rhs)
  {
      return rhs.print(stream, 0, -1);
  }
  
  
  inline
  bool s_baltst::operator==(
          const s_baltst::MySequenceWithNillableStringList& lhs,
          const s_baltst::MySequenceWithNillableStringList& rhs)
  {
      return  lhs.attribute1() == rhs.attribute1();
  }
  
  inline
  bool s_baltst::operator!=(
          const s_baltst::MySequenceWithNillableStringList& lhs,
          const s_baltst::MySequenceWithNillableStringList& rhs)
  {
      return !(lhs == rhs);
  }
  
  inline
  bsl::ostream& s_baltst::operator<<(
          bsl::ostream& stream,
          const s_baltst::MySequenceWithNillableStringList& rhs)
  {
      return rhs.print(stream, 0, -1);
  }
  
  
  inline
  bool s_baltst::operator==(
          const s_baltst::MySequenceWithNillableStringSequenceArray& lhs,
          const s_baltst::MySequenceWithNillableStringSequenceArray& rhs)
  {
      return  lhs.attribute1() == rhs.attribute1();
  }
  
  inline
  bool s_baltst::operator!=(
          const s_baltst::MySequenceWithNillableStringSequenceArray& lhs,
          const s_baltst::MySequenceWithNillableStringSequenceArray& rhs)
  {
      return !(lhs == rhs);
  }
  
  inline
  bsl::ostream& s_baltst::operator<<(
          bsl::ostream& stream,
          const s_baltst::MySequenceWithNillableStringSequenceArray& rhs)
  {
      return rhs.print(stream, 0, -1);
  }
  
  }  // close enterprise namespace
  #endif
  
  // GENERATED BY @BLP_BAS_CODEGEN_VERSION@
  // USING bas_codegen.pl s_baltst_mysequencewithnillable.xsd --mode msg --includedir . --msgComponent mysequencewithnillable --noRecurse --noExternalization --noHashSupport --noAggregateConversion
  // ----------------------------------------------------------------------------
  // NOTICE:
  //      Copyright 2021 Bloomberg Finance L.P. All rights reserved.
  //      Property of Bloomberg Finance L.P. (BFLP)
  //      This software is made available solely pursuant to the
  //      terms of a BFLP license agreement which governs its use.
  // ------------------------------- END-OF-FILE --------------------------------
  