text: // s_baltst_basicrecord.cpp        *DO NOT EDIT*         @generated -*-C++-*-
  
  #include <bsls_ident.h>
  BSLS_IDENT_RCSID(s_baltst_basicrecord_cpp,"$Id$ $CSID$")
  
  #include <s_baltst_basicrecord.h>
  
  #include <bdlat_formattingmode.h>
  #include <bdlat_valuetypefunctions.h>
  #include <bdlb_print.h>
  #include <bdlb_printmethods.h>
  #include <bdlb_string.h>
  
  #include <bdlt_datetimetz.h>
  #include <bsl_string.h>
  #include <s_baltst_address.h>
  #include <bslim_printer.h>
  #include <bsls_assert.h>
  
  #include <bsl_iomanip.h>
  #include <bsl_limits.h>
  #include <bsl_ostream.h>
  
  namespace BloombergLP {
  namespace s_baltst {
  
                               // -----------------
                               // class BasicRecord
                               // -----------------
  
  // CONSTANTS
  
  const char BasicRecord::CLASS_NAME[] = "BasicRecord";
  
  const bdlat_AttributeInfo BasicRecord::ATTRIBUTE_INFO_ARRAY[] = {
      {
          ATTRIBUTE_ID_I1,
          "i1",
          sizeof("i1") - 1,
          "",
          bdlat_FormattingMode::e_DEC
      },
      {
          ATTRIBUTE_ID_I2,
          "i2",
          sizeof("i2") - 1,
          "",
          bdlat_FormattingMode::e_DEC
      },
      {
          ATTRIBUTE_ID_DT,
          "dt",
          sizeof("dt") - 1,
          "",
          bdlat_FormattingMode::e_DEFAULT
      },
      {
          ATTRIBUTE_ID_S,
          "s",
          sizeof("s") - 1,
          "",
          bdlat_FormattingMode::e_TEXT
      }
  };
  
  // CLASS METHODS
  
  const bdlat_AttributeInfo *BasicRecord::lookupAttributeInfo(
          const char *name,
          int         nameLength)
  {
      for (int i = 0; i < 4; ++i) {
          const bdlat_AttributeInfo& attributeInfo =
                      BasicRecord::ATTRIBUTE_INFO_ARRAY[i];
  
          if (nameLength == attributeInfo.d_nameLength
          &&  0 == bsl::memcmp(attributeInfo.d_name_p, name, nameLength))
          {
              return &attributeInfo;
          }
      }
  
      return 0;
  }
  
  const bdlat_AttributeInfo *BasicRecord::lookupAttributeInfo(int id)
  {
      switch (id) {
        case ATTRIBUTE_ID_I1:
          return &ATTRIBUTE_INFO_ARRAY[ATTRIBUTE_INDEX_I1];
        case ATTRIBUTE_ID_I2:
          return &ATTRIBUTE_INFO_ARRAY[ATTRIBUTE_INDEX_I2];
        case ATTRIBUTE_ID_DT:
          return &ATTRIBUTE_INFO_ARRAY[ATTRIBUTE_INDEX_DT];
        case ATTRIBUTE_ID_S:
          return &ATTRIBUTE_INFO_ARRAY[ATTRIBUTE_INDEX_S];
        default:
          return 0;
      }
  }
  
  // CREATORS
  
  BasicRecord::BasicRecord(bslma::Allocator *basicAllocator)
  : d_s(basicAllocator)
  , d_dt()
  , d_i1()
  , d_i2()
  {
  }
  
  BasicRecord::BasicRecord(const BasicRecord& original,
                           bslma::Allocator *basicAllocator)
  : d_s(original.d_s, basicAllocator)
  , d_dt(original.d_dt)
  , d_i1(original.d_i1)
  , d_i2(original.d_i2)
  {
  }
  
  #if defined(BSLS_COMPILERFEATURES_SUPPORT_RVALUE_REFERENCES) \
   && defined(BSLS_COMPILERFEATURES_SUPPORT_NOEXCEPT)
  BasicRecord::BasicRecord(BasicRecord&& original) noexcept
  : d_s(bsl::move(original.d_s))
  , d_dt(bsl::move(original.d_dt))
  , d_i1(bsl::move(original.d_i1))
  , d_i2(bsl::move(original.d_i2))
  {
  }
  
  BasicRecord::BasicRecord(BasicRecord&& original,
                           bslma::Allocator *basicAllocator)
  : d_s(bsl::move(original.d_s), basicAllocator)
  , d_dt(bsl::move(original.d_dt))
  , d_i1(bsl::move(original.d_i1))
  , d_i2(bsl::move(original.d_i2))
  {
  }
  #endif
  
  BasicRecord::~BasicRecord()
  {
  }
  
  // MANIPULATORS
  
  BasicRecord&
  BasicRecord::operator=(const BasicRecord& rhs)
  {
      if (this != &rhs) {
          d_i1 = rhs.d_i1;
          d_i2 = rhs.d_i2;
          d_dt = rhs.d_dt;
          d_s = rhs.d_s;
      }
  
      return *this;
  }
  
  #if defined(BSLS_COMPILERFEATURES_SUPPORT_RVALUE_REFERENCES) \
   && defined(BSLS_COMPILERFEATURES_SUPPORT_NOEXCEPT)
  BasicRecord&
  BasicRecord::operator=(BasicRecord&& rhs)
  {
      if (this != &rhs) {
          d_i1 = bsl::move(rhs.d_i1);
          d_i2 = bsl::move(rhs.d_i2);
          d_dt = bsl::move(rhs.d_dt);
          d_s = bsl::move(rhs.d_s);
      }
  
      return *this;
  }
  #endif
  
  void BasicRecord::reset()
  {
      bdlat_ValueTypeFunctions::reset(&d_i1);
      bdlat_ValueTypeFunctions::reset(&d_i2);
      bdlat_ValueTypeFunctions::reset(&d_dt);
      bdlat_ValueTypeFunctions::reset(&d_s);
  }
  
  // ACCESSORS
  
  bsl::ostream& BasicRecord::print(
          bsl::ostream& stream,
          int           level,
          int           spacesPerLevel) const
  {
      bslim::Printer printer(&stream, level, spacesPerLevel);
      printer.start();
      printer.printAttribute("i1", d_i1);
      printer.printAttribute("i2", d_i2);
      printer.printAttribute("dt", d_dt);
      printer.printAttribute("s", d_s);
      printer.end();
      return stream;
  }
  
  
  }  // close package namespace
  }  // close enterprise namespace
  
  // GENERATED BY BLP_BAS_CODEGEN_2020.03.30
  // USING bas_codegen.pl s_baltst.xsd -m msg -p s_baltst -C tmp_singles --msgSplit 1 --noExternalization --noHashSupport --noAggregateConversion
  // ----------------------------------------------------------------------------
  // NOTICE:
  //      Copyright 2020 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 --------------------------------
  