text: // bslstl_priorityqueue_cpp03.h                                       -*-C++-*-
  
  // Automatically generated file.  **DO NOT EDIT**
  
  #ifndef INCLUDED_BSLSTL_PRIORITYQUEUE_CPP03
  #define INCLUDED_BSLSTL_PRIORITYQUEUE_CPP03
  
  //@PURPOSE: Provide C++03 implementation for bslstl_priorityqueue.h
  //
  //@CLASSES: See bslstl_priorityqueue.h for list of classes
  //
  //@SEE_ALSO: bslstl_priorityqueue
  //
  //@DESCRIPTION:  This component is the C++03 translation of a C++11 component,
  // generated by the 'sim_cpp11_features.pl' program.  If the original header
  // contains any specially delimited regions of C++11 code, then this generated
  // file contains the C++03 equivalent, i.e., with variadic templates expanded
  // and rvalue-references replaced by 'bslmf::MovableRef' objects.  The header
  // code in this file is designed to be '#include'd into the original header
  // when compiling with a C++03 compiler.  If there are no specially delimited
  // regions of C++11 code, then this header contains no code and is not
  // '#include'd in the original header.
  //
  // Generated on Thu Oct 21 10:11:37 2021
  // Command line: sim_cpp11_features.pl bslstl_priorityqueue.h
  
  #ifdef COMPILING_BSLSTL_PRIORITYQUEUE_H
  
  namespace bsl {
  
                           // ====================
                           // class priority_queue
                           // ====================
  
  template <class VALUE,
            class CONTAINER  = vector<VALUE>,
            class COMPARATOR = native_std::less<typename CONTAINER::value_type> >
  class priority_queue {
      // This class is a value-semantic class template, adapting a container of
      // the (template parameter) type 'CONTAINER', that holds elements of the
      // (template parameter) type 'VALUE', to provide a highest-priority-first
      // priority queue data structure, where the priorities of elements are
      // compared by a comparator of the template parameter type, 'COMPARATOR'.
      // The container object held by a 'priority_queue' class object is
      // referenced as 'c' in the following documentation.
  
    private:
      // PRIVATE TYPES
      typedef BloombergLP::bslmf::MovableRefUtil MoveUtil;
          // This 'typedef' is a convenient alias for the utility associated with
          // movable references.
  
    public:
      // PUBLIC TYPES
      typedef          CONTAINER                  container_type;
      typedef          COMPARATOR                 value_compare;
      typedef typename CONTAINER::value_type      value_type;
      typedef typename CONTAINER::reference       reference;
      typedef typename CONTAINER::const_reference const_reference;
      typedef typename CONTAINER::size_type       size_type;
  
    protected:
      // PROTECTED DATA
      CONTAINER  c;     // container for elements in the 'priority_queue'.  This
                        // data member exactly matches its definition in the
                        // C++11 standard [23.6.4].
  
      COMPARATOR comp;  // comparator that defines the priority order of elements
                        // in the 'priority_queue'.  This data member exactly
                        // matches its definition in the C++11 standard [23.6.4].
  
    public:
      // TRAITS
      BSLMF_NESTED_TRAIT_DECLARATION_IF(
          priority_queue,
          BloombergLP::bslma::UsesBslmaAllocator,
          BloombergLP::bslma::UsesBslmaAllocator<container_type>::value);
  
      // CREATORS
      priority_queue();
          // Create an empty priority queue, adapting a default-constructed
          // container of the (template parameter) type 'CONTAINER'.  Use a
          // default-constructed comparator of the (template parameter) type
          // 'COMPARATOR' to order elements in the priority queue.
  
      explicit priority_queue(const COMPARATOR& comparator);
          // Create an empty priority queue, adapting a default-constructed
          // container of the (template parameter) type 'CONTAINER', and having
          // the specified 'comparator' of the (template parameter) type
          // 'COMPARATOR' to order elements in the priority queue.
  
      priority_queue(const COMPARATOR& comparator, const CONTAINER& container);
          // Create a priority queue, adapting the specified 'container' of the
          // (template parameter) type 'CONTAINER', and having the specified
          // 'comparator' of the (template parameter) type 'COMPARATOR' to order
          // elements in the priority queue.
  
      explicit priority_queue(
             const COMPARATOR&                         comparator,
             BloombergLP::bslmf::MovableRef<CONTAINER> container);
          // Create a priority queue, adapting the specified 'container' of the
          // (template parameter) type 'CONTAINER', and having the specified
          // 'comparator' of the (template parameter) type 'COMPARATOR' to order
          // elements in the priority queue.
  
  
      template <class INPUT_ITERATOR>
      priority_queue(INPUT_ITERATOR first, INPUT_ITERATOR last);
          // Create a priority queue, adapting a default-constructed container of
          // the (template parameter) type 'CONTAINER', and inserting into the
          // container a sequence of 'value_type' elements that starts at the
          // specified 'first' and ends immediately before the specified 'last'.
          // Use a default-constructed comparator of the (template parameter)
          // type 'COMPARATOR' to order elements in the priority queue.
  
      template <class INPUT_ITERATOR>
      priority_queue(INPUT_ITERATOR    first,
                     INPUT_ITERATOR    last,
                     const COMPARATOR& comparator,
                     const CONTAINER&  container);
          // Create a priority queue, adapting the specified 'container', having
          // the specified 'comparator' to order the priorities of elements,
          // including those originally existed in 'container', and those
          // inserted into the 'container' from a sequence of 'value_type'
          // elements starting at the specified 'first', and ending immediately
          // before the specified 'last'.
  
      template <class INPUT_ITERATOR>
      priority_queue(
             INPUT_ITERATOR                            first,
             INPUT_ITERATOR                            last,
             const COMPARATOR&                         comparator,
             BloombergLP::bslmf::MovableRef<CONTAINER> container);
          // Create a priority queue, adapting the specified 'container', having
          // the specified 'comparator' to order elements in the priority queue,
          // including those originally existed in 'container', and those
          // inserted into the 'container' from a sequence of 'value_type'
          // elements starting at the specified 'first', and ending immediately
          // before the specified 'last'.
  
      priority_queue(const priority_queue& original);
          // Create a priority queue having the same value as the specified
          // 'original' object.  Use a copy of the comparator from 'original' to
          // order elements in the priority queue.
  
      priority_queue(BloombergLP::bslmf::MovableRef<priority_queue> original);
          // Create a priority queue having the same value as the specified
          // 'original' object.  Use a copy of the comparator from 'original' to
          // order elements in the priority queue.
  
      template <class ALLOCATOR>
      explicit
      priority_queue(const ALLOCATOR& basicAllocator,
                     typename enable_if<
                                bsl::uses_allocator<CONTAINER, ALLOCATOR>::value,
                                ALLOCATOR>::type * = 0);
          // Create an empty priority queue, adapting a default-constructed
          // container of the (template parameter) type 'CONTAINER' that uses the
          // specified 'basicAllocator' to supply memory.  Use a
          // default-constructed object of the (template parameter) type
          // 'COMPARATOR' to order elements in the priority queue.  Note that
          // this constructor is only defined if the underlying container uses
          // allocator.  Otherwise this constructor is disabled.
  
      template <class ALLOCATOR>
      priority_queue(const COMPARATOR& comparator,
                     const ALLOCATOR&  basicAllocator,
                     typename enable_if<
                                bsl::uses_allocator<CONTAINER, ALLOCATOR>::value,
                                ALLOCATOR>::type * = 0);
          // Create an empty priority queue, adapting a default-constructed
          // container of the (template parameter) type 'CONTAINER' that uses the
          // specified 'basicAllocator' to supply memory, and the specified
          // 'comparator' to order elements in the priority queue.  Note that
          // this constructor is only defined if the underlying container uses
          // allocator.  Otherwise this constructor is disabled.
  
      template <class ALLOCATOR>
      priority_queue(const COMPARATOR& comparator,
                     const CONTAINER&  container,
                     const ALLOCATOR&  basicAllocator,
                     typename enable_if<
                                bsl::uses_allocator<CONTAINER, ALLOCATOR>::value,
                                ALLOCATOR>::type * = 0);
          // Create a priority queue, adapting the specified 'container' that
          // uses the specified 'basicAllocator' to supply memory, and the
          // specified 'comparator' to order elements in the priority queue.
          // Note that this constructor is only defined if the underlying
          // container uses allocator.  Otherwise this constructor is disabled.
  
      template <class ALLOCATOR>
      priority_queue(const COMPARATOR&                         comparator,
                     BloombergLP::bslmf::MovableRef<CONTAINER> container,
                     const ALLOCATOR&                          basicAllocator,
                     typename enable_if<
                                bsl::uses_allocator<CONTAINER, ALLOCATOR>::value,
                                ALLOCATOR>::type * = 0);
          // Create a priority queue, adapting the specified 'container' that
          // uses the specified 'basicAllocator' to supply memory, and the
          // specified 'comparator' to order elements in the priority queue.
          // Note that this constructor is only defined if the underlying
          // container uses allocator.  Otherwise this constructor is disabled.
  
      template <class ALLOCATOR>
      priority_queue(const priority_queue& original,
                     const ALLOCATOR&      basicAllocator,
                     typename enable_if<
                                bsl::uses_allocator<CONTAINER, ALLOCATOR>::value,
                                ALLOCATOR>::type * = 0);
          // Create a priority queue having the same value as the specified
          // 'original' object and using the specified 'basicAllocator' to supply
          // memory.  Use a copy of the comparator from 'original' to order
          // elements in the priority queue.  Note that this constructor is only
          // defined if the underlying container uses allocator.  Otherwise this
          // constructor is disabled.
  
      template <class ALLOCATOR>
      priority_queue(
                   BloombergLP::bslmf::MovableRef<priority_queue> original,
                   const ALLOCATOR&                               basicAllocator,
                   typename enable_if<
                                bsl::uses_allocator<CONTAINER, ALLOCATOR>::value,
                                ALLOCATOR>::type * = 0);
          // Create a priority queue having the same value as the specified
          // 'original' object and using the specified 'basicAllocator' to supply
          // memory.  Use a copy of the comparator from 'original' to order
          // elements in the priority queue.  Note that this constructor is only
          // defined if the underlying container uses allocator.  Otherwise this
          // constructor is disabled.
  
      // MANIPULATORS
      priority_queue& operator=(const priority_queue& rhs);
          // Assign to this object the value and comparator of the specified
          // 'rhs' object and return a reference providing modifiable access to
          // this object.
  
      priority_queue& operator=(
                              BloombergLP::bslmf::MovableRef<priority_queue> rhs)
                                      BSLS_KEYWORD_NOEXCEPT_SPECIFICATION(false);
          // Assign to this object the value and comparator of the specified
          // 'rhs' object and return a reference providing modifiable access to
          // this object.  'rhs' is left in a valid but unspecified state.
  
      void push(const value_type& value);
          // Insert the specified 'value' into this priority queue.  In effect,
          // performs 'c.push_back(value);'.
  
      void push(BloombergLP::bslmf::MovableRef<value_type> value);
          // Insert the specified 'value' into this priority queue.  In effect,
          // performs 'c.push_back(value);'.
  
  #if BSLS_COMPILERFEATURES_SIMULATE_VARIADIC_TEMPLATES
  // {{{ BEGIN GENERATED CODE
  // Command line: sim_cpp11_features.pl bslstl_priorityqueue.h
  #ifndef BSLSTL_PRIORITYQUEUE_VARIADIC_LIMIT
  #define BSLSTL_PRIORITYQUEUE_VARIADIC_LIMIT 10
  #endif
  #ifndef BSLSTL_PRIORITYQUEUE_VARIADIC_LIMIT_A
  #define BSLSTL_PRIORITYQUEUE_VARIADIC_LIMIT_A BSLSTL_PRIORITYQUEUE_VARIADIC_LIMIT
  #endif
  #if BSLSTL_PRIORITYQUEUE_VARIADIC_LIMIT_A >= 0
      void emplace();
  #endif  // BSLSTL_PRIORITYQUEUE_VARIADIC_LIMIT_A >= 0
  
  #if BSLSTL_PRIORITYQUEUE_VARIADIC_LIMIT_A >= 1
      template <class Args_01>
      void emplace(BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) args_01);
  #endif  // BSLSTL_PRIORITYQUEUE_VARIADIC_LIMIT_A >= 1
  
  #if BSLSTL_PRIORITYQUEUE_VARIADIC_LIMIT_A >= 2
      template <class Args_01,
                class Args_02>
      void emplace(BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) args_01,
                   BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) args_02);
  #endif  // BSLSTL_PRIORITYQUEUE_VARIADIC_LIMIT_A >= 2
  
  #if BSLSTL_PRIORITYQUEUE_VARIADIC_LIMIT_A >= 3
      template <class Args_01,
                class Args_02,
                class Args_03>
      void emplace(BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) args_01,
                   BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) args_02,
                   BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) args_03);
  #endif  // BSLSTL_PRIORITYQUEUE_VARIADIC_LIMIT_A >= 3
  
  #if BSLSTL_PRIORITYQUEUE_VARIADIC_LIMIT_A >= 4
      template <class Args_01,
                class Args_02,
                class Args_03,
                class Args_04>
      void emplace(BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) args_01,
                   BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) args_02,
                   BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) args_03,
                   BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) args_04);
  #endif  // BSLSTL_PRIORITYQUEUE_VARIADIC_LIMIT_A >= 4
  
  #if BSLSTL_PRIORITYQUEUE_VARIADIC_LIMIT_A >= 5
      template <class Args_01,
                class Args_02,
                class Args_03,
                class Args_04,
                class Args_05>
      void emplace(BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) args_01,
                   BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) args_02,
                   BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) args_03,
                   BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) args_04,
                   BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) args_05);
  #endif  // BSLSTL_PRIORITYQUEUE_VARIADIC_LIMIT_A >= 5
  
  #if BSLSTL_PRIORITYQUEUE_VARIADIC_LIMIT_A >= 6
      template <class Args_01,
                class Args_02,
                class Args_03,
                class Args_04,
                class Args_05,
                class Args_06>
      void emplace(BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) args_01,
                   BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) args_02,
                   BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) args_03,
                   BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) args_04,
                   BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) args_05,
                   BSLS_COMPILERFEATURES_FORWARD_REF(Args_06) args_06);
  #endif  // BSLSTL_PRIORITYQUEUE_VARIADIC_LIMIT_A >= 6
  
  #if BSLSTL_PRIORITYQUEUE_VARIADIC_LIMIT_A >= 7
      template <class Args_01,
                class Args_02,
                class Args_03,
                class Args_04,
                class Args_05,
                class Args_06,
                class Args_07>
      void emplace(BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) args_01,
                   BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) args_02,
                   BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) args_03,
                   BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) args_04,
                   BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) args_05,
                   BSLS_COMPILERFEATURES_FORWARD_REF(Args_06) args_06,
                   BSLS_COMPILERFEATURES_FORWARD_REF(Args_07) args_07);
  #endif  // BSLSTL_PRIORITYQUEUE_VARIADIC_LIMIT_A >= 7
  
  #if BSLSTL_PRIORITYQUEUE_VARIADIC_LIMIT_A >= 8
      template <class Args_01,
                class Args_02,
                class Args_03,
                class Args_04,
                class Args_05,
                class Args_06,
                class Args_07,
                class Args_08>
      void emplace(BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) args_01,
                   BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) args_02,
                   BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) args_03,
                   BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) args_04,
                   BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) args_05,
                   BSLS_COMPILERFEATURES_FORWARD_REF(Args_06) args_06,
                   BSLS_COMPILERFEATURES_FORWARD_REF(Args_07) args_07,
                   BSLS_COMPILERFEATURES_FORWARD_REF(Args_08) args_08);
  #endif  // BSLSTL_PRIORITYQUEUE_VARIADIC_LIMIT_A >= 8
  
  #if BSLSTL_PRIORITYQUEUE_VARIADIC_LIMIT_A >= 9
      template <class Args_01,
                class Args_02,
                class Args_03,
                class Args_04,
                class Args_05,
                class Args_06,
                class Args_07,
                class Args_08,
                class Args_09>
      void emplace(BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) args_01,
                   BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) args_02,
                   BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) args_03,
                   BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) args_04,
                   BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) args_05,
                   BSLS_COMPILERFEATURES_FORWARD_REF(Args_06) args_06,
                   BSLS_COMPILERFEATURES_FORWARD_REF(Args_07) args_07,
                   BSLS_COMPILERFEATURES_FORWARD_REF(Args_08) args_08,
                   BSLS_COMPILERFEATURES_FORWARD_REF(Args_09) args_09);
  #endif  // BSLSTL_PRIORITYQUEUE_VARIADIC_LIMIT_A >= 9
  
  #if BSLSTL_PRIORITYQUEUE_VARIADIC_LIMIT_A >= 10
      template <class Args_01,
                class Args_02,
                class Args_03,
                class Args_04,
                class Args_05,
                class Args_06,
                class Args_07,
                class Args_08,
                class Args_09,
                class Args_10>
      void emplace(BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) args_01,
                   BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) args_02,
                   BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) args_03,
                   BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) args_04,
                   BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) args_05,
                   BSLS_COMPILERFEATURES_FORWARD_REF(Args_06) args_06,
                   BSLS_COMPILERFEATURES_FORWARD_REF(Args_07) args_07,
                   BSLS_COMPILERFEATURES_FORWARD_REF(Args_08) args_08,
                   BSLS_COMPILERFEATURES_FORWARD_REF(Args_09) args_09,
                   BSLS_COMPILERFEATURES_FORWARD_REF(Args_10) args_10);
  #endif  // BSLSTL_PRIORITYQUEUE_VARIADIC_LIMIT_A >= 10
  
  #else
  // The generated code below is a workaround for the absence of perfect
  // forwarding in some compilers.
      template <class... Args>
      void emplace(BSLS_COMPILERFEATURES_FORWARD_REF(Args)... args);
  // }}} END GENERATED CODE
  #endif
  
      void pop();
          // Remove the top element from this 'priority_queue' object that has
          // the highest priority.  In effect, performs 'c.pop_back();'.  The
          // behavior is undefined if there is currently no elements in this
          // object.
  
      void swap(priority_queue& other)
                                      BSLS_KEYWORD_NOEXCEPT_SPECIFICATION(false);
          // Efficiently exchange the value of this object with the value of the
          // specified 'other' object.  In effect, performs 'using bsl::swap;
          // swap(c, other.c);'.
  
      // ACCESSORS
      bool empty() const;
          // Return 'true' if this 'priority_queue' object contains no elements,
          // and 'false' otherwise.  In effect, performs 'return c.empty();'.
  
      size_type size() const;
          // Return the number of elements in this 'priority_queue' object.  In
          // effect, performs 'return c.size()'.
  
      const_reference top() const;
          // Return a reference providing non-modifiable access to the element
          // having the highest priority in this 'priority_queue' object.  In
          // effect, performs 'return c.front()'.  The behavior is undefined if
          // the priority queue is empty.
  };
  
  // FREE FUNCTIONS
  template <class VALUE, class CONTAINER, class COMPARATOR>
  void swap(priority_queue<VALUE, CONTAINER, COMPARATOR>& a,
            priority_queue<VALUE, CONTAINER, COMPARATOR>& b)
                                      BSLS_KEYWORD_NOEXCEPT_SPECIFICATION(false);
      // Exchange the container and comparator of the specified 'a' object with
      // the container and comparator of the specified 'b' object.
  
  // ============================================================================
  //                  TEMPLATE AND INLINE FUNCTION DEFINITIONS
  // ============================================================================
  
                           // --------------------
                           // class priority_queue
                           // --------------------
  
  // CREATORS
  template <class VALUE, class CONTAINER, class COMPARATOR>
  inline
  priority_queue<VALUE, CONTAINER, COMPARATOR>::priority_queue()
  {
  }
  
  template <class VALUE, class CONTAINER, class COMPARATOR>
  inline
  priority_queue<VALUE, CONTAINER, COMPARATOR>::priority_queue(
                                                    const COMPARATOR& comparator)
  : comp(comparator)
  {
  }
  
  template <class VALUE, class CONTAINER, class COMPARATOR>
  inline
  priority_queue<VALUE, CONTAINER, COMPARATOR>::priority_queue(
                                                    const COMPARATOR& comparator,
                                                    const CONTAINER&  container)
  : c(container)
  , comp(comparator)
  {
      native_std::make_heap(c.begin(), c.end(), comp);
  }
  
  template <class VALUE, class CONTAINER, class COMPARATOR>
  inline
  priority_queue<VALUE, CONTAINER, COMPARATOR>::priority_queue(
                            const COMPARATOR&                         comparator,
                            BloombergLP::bslmf::MovableRef<CONTAINER> container)
  : c(MoveUtil::move(container))
  , comp(comparator)
  {
      native_std::make_heap(c.begin(), c.end(), comp);
  }
  
  template <class VALUE, class CONTAINER, class COMPARATOR>
  template <class INPUT_ITERATOR>
  inline
  priority_queue<VALUE, CONTAINER, COMPARATOR>::priority_queue(
                                                         INPUT_ITERATOR    first,
                                                         INPUT_ITERATOR    last)
  {
      c.insert(c.end(), first, last);
      native_std::make_heap(c.begin(), c.end(), comp);
  }
  
  template <class VALUE, class CONTAINER, class COMPARATOR>
  template <class INPUT_ITERATOR>
  inline
  priority_queue<VALUE, CONTAINER, COMPARATOR>::priority_queue(
                                                    INPUT_ITERATOR    first,
                                                    INPUT_ITERATOR    last,
                                                    const COMPARATOR& comparator,
                                                    const CONTAINER&  container)
  : c(container)
  , comp(comparator)
  {
      c.insert(c.end(), first, last);
      native_std::make_heap(c.begin(), c.end(), comp);
  }
  
  template <class VALUE, class CONTAINER, class COMPARATOR>
  template <class INPUT_ITERATOR>
  inline
  priority_queue<VALUE, CONTAINER, COMPARATOR>::priority_queue(
                           INPUT_ITERATOR                             first,
                           INPUT_ITERATOR                             last,
                           const COMPARATOR&                          comparator,
                           BloombergLP::bslmf::MovableRef<CONTAINER>  container)
  : c(MoveUtil::move(container))
  , comp(comparator)
  {
      c.insert(c.end(), first, last);
      native_std::make_heap(c.begin(), c.end(), comp);
  }
  
  template <class VALUE, class CONTAINER, class COMPARATOR>
  inline
  priority_queue<VALUE, CONTAINER, COMPARATOR>::priority_queue(
                                                  const priority_queue& original)
  : c(original.c)
  , comp(original.comp)
  {
  }
  
  template <class VALUE, class CONTAINER, class COMPARATOR>
  inline
  priority_queue<VALUE, CONTAINER, COMPARATOR>::priority_queue(
                         BloombergLP::bslmf::MovableRef<priority_queue> original)
  : c(MoveUtil::move(MoveUtil::access(original).c))
  , comp(MoveUtil::access(original).comp)
  {
  }
  
  template <class VALUE, class CONTAINER, class COMPARATOR>
  template <class ALLOCATOR>
  inline
  priority_queue<VALUE, CONTAINER, COMPARATOR>::priority_queue(
                            const ALLOCATOR& basicAllocator,
                            typename enable_if<
                                bsl::uses_allocator<CONTAINER, ALLOCATOR>::value,
                                ALLOCATOR>::type *)
  : c(basicAllocator)
  , comp(COMPARATOR())
  {
  }
  
  template <class VALUE, class CONTAINER, class COMPARATOR>
  template <class ALLOCATOR>
  inline
  priority_queue<VALUE, CONTAINER, COMPARATOR>::priority_queue(
                            const COMPARATOR& comparator,
                            const ALLOCATOR&  basicAllocator,
                            typename enable_if<
                                bsl::uses_allocator<CONTAINER, ALLOCATOR>::value,
                                ALLOCATOR>::type *)
  : c(basicAllocator)
  , comp(comparator)
  {
  }
  
  template <class VALUE, class CONTAINER, class COMPARATOR>
  template <class ALLOCATOR>
  inline
  priority_queue<VALUE, CONTAINER, COMPARATOR>::priority_queue(
                            const COMPARATOR& comparator,
                            const CONTAINER&  container,
                            const ALLOCATOR&  basicAllocator,
                            typename enable_if<
                                bsl::uses_allocator<CONTAINER, ALLOCATOR>::value,
                                ALLOCATOR>::type *)
  : c(container, basicAllocator)
  , comp(comparator)
  {
      native_std::make_heap(c.begin(), c.end(), comp);
  }
  
  template <class VALUE, class CONTAINER, class COMPARATOR>
  template <class ALLOCATOR>
  inline
  priority_queue<VALUE, CONTAINER, COMPARATOR>::priority_queue(
                        const COMPARATOR&                         comparator,
                        BloombergLP::bslmf::MovableRef<CONTAINER> container,
                        const ALLOCATOR&                          basicAllocator,
                        typename enable_if<
                                bsl::uses_allocator<CONTAINER, ALLOCATOR>::value,
                                ALLOCATOR>::type *)
  : c(MoveUtil::move(container), basicAllocator)
  , comp(comparator)
  {
      native_std::make_heap(c.begin(), c.end(), comp);
  }
  
  template <class VALUE, class CONTAINER, class COMPARATOR>
  template <class ALLOCATOR>
  inline
  priority_queue<VALUE, CONTAINER, COMPARATOR>::priority_queue(
                            const priority_queue& original,
                            const ALLOCATOR&      basicAllocator,
                            typename enable_if<
                                bsl::uses_allocator<CONTAINER, ALLOCATOR>::value,
                                ALLOCATOR>::type *)
  : c(original.c, basicAllocator)
  , comp(original.comp)
  {
  }
  
  template <class VALUE, class CONTAINER, class COMPARATOR>
  template <class ALLOCATOR>
  inline
  priority_queue<VALUE, CONTAINER, COMPARATOR>::priority_queue(
                   BloombergLP::bslmf::MovableRef<priority_queue> original,
                   const ALLOCATOR&                               basicAllocator,
                   typename enable_if<
                                bsl::uses_allocator<CONTAINER, ALLOCATOR>::value,
                                ALLOCATOR>::type *)
  : c(MoveUtil::move(MoveUtil::access(original).c), basicAllocator)
  , comp(MoveUtil::access(original).comp)
  {
  }
  
  // MANIPULATORS
  template <class VALUE, class CONTAINER, class COMPARATOR>
  inline
  priority_queue<VALUE, CONTAINER, COMPARATOR>&
  priority_queue<VALUE, CONTAINER, COMPARATOR>::operator=(
                                                       const priority_queue& rhs)
  {
      c = rhs.c;
      comp = rhs.comp;
      return *this;
  }
  
  template <class VALUE, class CONTAINER, class COMPARATOR>
  inline
  priority_queue<VALUE, CONTAINER, COMPARATOR>&
  priority_queue<VALUE, CONTAINER, COMPARATOR>::operator=(
                              BloombergLP::bslmf::MovableRef<priority_queue> rhs)
                                       BSLS_KEYWORD_NOEXCEPT_SPECIFICATION(false)
  {
      c = MoveUtil::move(MoveUtil::access(rhs).c);
      comp = MoveUtil::access(rhs).comp;
      return *this;
  }
  
  template <class VALUE, class CONTAINER, class COMPARATOR>
  inline
  void priority_queue<VALUE, CONTAINER, COMPARATOR>::push(
                                                         const value_type& value)
  {
      c.push_back(value);
      native_std::push_heap(c.begin(), c.end(), comp);
  }
  
  template <class VALUE, class CONTAINER, class COMPARATOR>
  inline
  void priority_queue<VALUE, CONTAINER, COMPARATOR>::push(
                                BloombergLP::bslmf::MovableRef<value_type> value)
  {
      c.push_back(MoveUtil::move(value));
      native_std::push_heap(c.begin(), c.end(), comp);
  }
  
  #if BSLS_COMPILERFEATURES_SIMULATE_VARIADIC_TEMPLATES
  // {{{ BEGIN GENERATED CODE
  // Command line: sim_cpp11_features.pl bslstl_priorityqueue.h
  #ifndef BSLSTL_PRIORITYQUEUE_VARIADIC_LIMIT
  #define BSLSTL_PRIORITYQUEUE_VARIADIC_LIMIT 10
  #endif
  #ifndef BSLSTL_PRIORITYQUEUE_VARIADIC_LIMIT_B
  #define BSLSTL_PRIORITYQUEUE_VARIADIC_LIMIT_B BSLSTL_PRIORITYQUEUE_VARIADIC_LIMIT
  #endif
  #if BSLSTL_PRIORITYQUEUE_VARIADIC_LIMIT_B >= 0
  template <class VALUE, class CONTAINER, class COMPARATOR>
  inline
  void priority_queue<VALUE, CONTAINER, COMPARATOR>::emplace(
                                 )
  {
      c.emplace_back();
      native_std::push_heap(c.begin(), c.end(), comp);
  }
  #endif  // BSLSTL_PRIORITYQUEUE_VARIADIC_LIMIT_B >= 0
  
  #if BSLSTL_PRIORITYQUEUE_VARIADIC_LIMIT_B >= 1
  template <class VALUE, class CONTAINER, class COMPARATOR>
  template <class Args_01>
  inline
  void priority_queue<VALUE, CONTAINER, COMPARATOR>::emplace(
                              BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) args_01)
  {
      c.emplace_back(BSLS_COMPILERFEATURES_FORWARD(Args_01,args_01));
      native_std::push_heap(c.begin(), c.end(), comp);
  }
  #endif  // BSLSTL_PRIORITYQUEUE_VARIADIC_LIMIT_B >= 1
  
  #if BSLSTL_PRIORITYQUEUE_VARIADIC_LIMIT_B >= 2
  template <class VALUE, class CONTAINER, class COMPARATOR>
  template <class Args_01,
            class Args_02>
  inline
  void priority_queue<VALUE, CONTAINER, COMPARATOR>::emplace(
                              BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) args_01,
                              BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) args_02)
  {
      c.emplace_back(BSLS_COMPILERFEATURES_FORWARD(Args_01,args_01),
                     BSLS_COMPILERFEATURES_FORWARD(Args_02,args_02));
      native_std::push_heap(c.begin(), c.end(), comp);
  }
  #endif  // BSLSTL_PRIORITYQUEUE_VARIADIC_LIMIT_B >= 2
  
  #if BSLSTL_PRIORITYQUEUE_VARIADIC_LIMIT_B >= 3
  template <class VALUE, class CONTAINER, class COMPARATOR>
  template <class Args_01,
            class Args_02,
            class Args_03>
  inline
  void priority_queue<VALUE, CONTAINER, COMPARATOR>::emplace(
                              BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) args_01,
                              BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) args_02,
                              BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) args_03)
  {
      c.emplace_back(BSLS_COMPILERFEATURES_FORWARD(Args_01,args_01),
                     BSLS_COMPILERFEATURES_FORWARD(Args_02,args_02),
                     BSLS_COMPILERFEATURES_FORWARD(Args_03,args_03));
      native_std::push_heap(c.begin(), c.end(), comp);
  }
  #endif  // BSLSTL_PRIORITYQUEUE_VARIADIC_LIMIT_B >= 3
  
  #if BSLSTL_PRIORITYQUEUE_VARIADIC_LIMIT_B >= 4
  template <class VALUE, class CONTAINER, class COMPARATOR>
  template <class Args_01,
            class Args_02,
            class Args_03,
            class Args_04>
  inline
  void priority_queue<VALUE, CONTAINER, COMPARATOR>::emplace(
                              BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) args_01,
                              BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) args_02,
                              BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) args_03,
                              BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) args_04)
  {
      c.emplace_back(BSLS_COMPILERFEATURES_FORWARD(Args_01,args_01),
                     BSLS_COMPILERFEATURES_FORWARD(Args_02,args_02),
                     BSLS_COMPILERFEATURES_FORWARD(Args_03,args_03),
                     BSLS_COMPILERFEATURES_FORWARD(Args_04,args_04));
      native_std::push_heap(c.begin(), c.end(), comp);
  }
  #endif  // BSLSTL_PRIORITYQUEUE_VARIADIC_LIMIT_B >= 4
  
  #if BSLSTL_PRIORITYQUEUE_VARIADIC_LIMIT_B >= 5
  template <class VALUE, class CONTAINER, class COMPARATOR>
  template <class Args_01,
            class Args_02,
            class Args_03,
            class Args_04,
            class Args_05>
  inline
  void priority_queue<VALUE, CONTAINER, COMPARATOR>::emplace(
                              BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) args_01,
                              BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) args_02,
                              BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) args_03,
                              BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) args_04,
                              BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) args_05)
  {
      c.emplace_back(BSLS_COMPILERFEATURES_FORWARD(Args_01,args_01),
                     BSLS_COMPILERFEATURES_FORWARD(Args_02,args_02),
                     BSLS_COMPILERFEATURES_FORWARD(Args_03,args_03),
                     BSLS_COMPILERFEATURES_FORWARD(Args_04,args_04),
                     BSLS_COMPILERFEATURES_FORWARD(Args_05,args_05));
      native_std::push_heap(c.begin(), c.end(), comp);
  }
  #endif  // BSLSTL_PRIORITYQUEUE_VARIADIC_LIMIT_B >= 5
  
  #if BSLSTL_PRIORITYQUEUE_VARIADIC_LIMIT_B >= 6
  template <class VALUE, class CONTAINER, class COMPARATOR>
  template <class Args_01,
            class Args_02,
            class Args_03,
            class Args_04,
            class Args_05,
            class Args_06>
  inline
  void priority_queue<VALUE, CONTAINER, COMPARATOR>::emplace(
                              BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) args_01,
                              BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) args_02,
                              BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) args_03,
                              BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) args_04,
                              BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) args_05,
                              BSLS_COMPILERFEATURES_FORWARD_REF(Args_06) args_06)
  {
      c.emplace_back(BSLS_COMPILERFEATURES_FORWARD(Args_01,args_01),
                     BSLS_COMPILERFEATURES_FORWARD(Args_02,args_02),
                     BSLS_COMPILERFEATURES_FORWARD(Args_03,args_03),
                     BSLS_COMPILERFEATURES_FORWARD(Args_04,args_04),
                     BSLS_COMPILERFEATURES_FORWARD(Args_05,args_05),
                     BSLS_COMPILERFEATURES_FORWARD(Args_06,args_06));
      native_std::push_heap(c.begin(), c.end(), comp);
  }
  #endif  // BSLSTL_PRIORITYQUEUE_VARIADIC_LIMIT_B >= 6
  
  #if BSLSTL_PRIORITYQUEUE_VARIADIC_LIMIT_B >= 7
  template <class VALUE, class CONTAINER, class COMPARATOR>
  template <class Args_01,
            class Args_02,
            class Args_03,
            class Args_04,
            class Args_05,
            class Args_06,
            class Args_07>
  inline
  void priority_queue<VALUE, CONTAINER, COMPARATOR>::emplace(
                              BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) args_01,
                              BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) args_02,
                              BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) args_03,
                              BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) args_04,
                              BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) args_05,
                              BSLS_COMPILERFEATURES_FORWARD_REF(Args_06) args_06,
                              BSLS_COMPILERFEATURES_FORWARD_REF(Args_07) args_07)
  {
      c.emplace_back(BSLS_COMPILERFEATURES_FORWARD(Args_01,args_01),
                     BSLS_COMPILERFEATURES_FORWARD(Args_02,args_02),
                     BSLS_COMPILERFEATURES_FORWARD(Args_03,args_03),
                     BSLS_COMPILERFEATURES_FORWARD(Args_04,args_04),
                     BSLS_COMPILERFEATURES_FORWARD(Args_05,args_05),
                     BSLS_COMPILERFEATURES_FORWARD(Args_06,args_06),
                     BSLS_COMPILERFEATURES_FORWARD(Args_07,args_07));
      native_std::push_heap(c.begin(), c.end(), comp);
  }
  #endif  // BSLSTL_PRIORITYQUEUE_VARIADIC_LIMIT_B >= 7
  
  #if BSLSTL_PRIORITYQUEUE_VARIADIC_LIMIT_B >= 8
  template <class VALUE, class CONTAINER, class COMPARATOR>
  template <class Args_01,
            class Args_02,
            class Args_03,
            class Args_04,
            class Args_05,
            class Args_06,
            class Args_07,
            class Args_08>
  inline
  void priority_queue<VALUE, CONTAINER, COMPARATOR>::emplace(
                              BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) args_01,
                              BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) args_02,
                              BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) args_03,
                              BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) args_04,
                              BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) args_05,
                              BSLS_COMPILERFEATURES_FORWARD_REF(Args_06) args_06,
                              BSLS_COMPILERFEATURES_FORWARD_REF(Args_07) args_07,
                              BSLS_COMPILERFEATURES_FORWARD_REF(Args_08) args_08)
  {
      c.emplace_back(BSLS_COMPILERFEATURES_FORWARD(Args_01,args_01),
                     BSLS_COMPILERFEATURES_FORWARD(Args_02,args_02),
                     BSLS_COMPILERFEATURES_FORWARD(Args_03,args_03),
                     BSLS_COMPILERFEATURES_FORWARD(Args_04,args_04),
                     BSLS_COMPILERFEATURES_FORWARD(Args_05,args_05),
                     BSLS_COMPILERFEATURES_FORWARD(Args_06,args_06),
                     BSLS_COMPILERFEATURES_FORWARD(Args_07,args_07),
                     BSLS_COMPILERFEATURES_FORWARD(Args_08,args_08));
      native_std::push_heap(c.begin(), c.end(), comp);
  }
  #endif  // BSLSTL_PRIORITYQUEUE_VARIADIC_LIMIT_B >= 8
  
  #if BSLSTL_PRIORITYQUEUE_VARIADIC_LIMIT_B >= 9
  template <class VALUE, class CONTAINER, class COMPARATOR>
  template <class Args_01,
            class Args_02,
            class Args_03,
            class Args_04,
            class Args_05,
            class Args_06,
            class Args_07,
            class Args_08,
            class Args_09>
  inline
  void priority_queue<VALUE, CONTAINER, COMPARATOR>::emplace(
                              BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) args_01,
                              BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) args_02,
                              BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) args_03,
                              BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) args_04,
                              BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) args_05,
                              BSLS_COMPILERFEATURES_FORWARD_REF(Args_06) args_06,
                              BSLS_COMPILERFEATURES_FORWARD_REF(Args_07) args_07,
                              BSLS_COMPILERFEATURES_FORWARD_REF(Args_08) args_08,
                              BSLS_COMPILERFEATURES_FORWARD_REF(Args_09) args_09)
  {
      c.emplace_back(BSLS_COMPILERFEATURES_FORWARD(Args_01,args_01),
                     BSLS_COMPILERFEATURES_FORWARD(Args_02,args_02),
                     BSLS_COMPILERFEATURES_FORWARD(Args_03,args_03),
                     BSLS_COMPILERFEATURES_FORWARD(Args_04,args_04),
                     BSLS_COMPILERFEATURES_FORWARD(Args_05,args_05),
                     BSLS_COMPILERFEATURES_FORWARD(Args_06,args_06),
                     BSLS_COMPILERFEATURES_FORWARD(Args_07,args_07),
                     BSLS_COMPILERFEATURES_FORWARD(Args_08,args_08),
                     BSLS_COMPILERFEATURES_FORWARD(Args_09,args_09));
      native_std::push_heap(c.begin(), c.end(), comp);
  }
  #endif  // BSLSTL_PRIORITYQUEUE_VARIADIC_LIMIT_B >= 9
  
  #if BSLSTL_PRIORITYQUEUE_VARIADIC_LIMIT_B >= 10
  template <class VALUE, class CONTAINER, class COMPARATOR>
  template <class Args_01,
            class Args_02,
            class Args_03,
            class Args_04,
            class Args_05,
            class Args_06,
            class Args_07,
            class Args_08,
            class Args_09,
            class Args_10>
  inline
  void priority_queue<VALUE, CONTAINER, COMPARATOR>::emplace(
                              BSLS_COMPILERFEATURES_FORWARD_REF(Args_01) args_01,
                              BSLS_COMPILERFEATURES_FORWARD_REF(Args_02) args_02,
                              BSLS_COMPILERFEATURES_FORWARD_REF(Args_03) args_03,
                              BSLS_COMPILERFEATURES_FORWARD_REF(Args_04) args_04,
                              BSLS_COMPILERFEATURES_FORWARD_REF(Args_05) args_05,
                              BSLS_COMPILERFEATURES_FORWARD_REF(Args_06) args_06,
                              BSLS_COMPILERFEATURES_FORWARD_REF(Args_07) args_07,
                              BSLS_COMPILERFEATURES_FORWARD_REF(Args_08) args_08,
                              BSLS_COMPILERFEATURES_FORWARD_REF(Args_09) args_09,
                              BSLS_COMPILERFEATURES_FORWARD_REF(Args_10) args_10)
  {
      c.emplace_back(BSLS_COMPILERFEATURES_FORWARD(Args_01,args_01),
                     BSLS_COMPILERFEATURES_FORWARD(Args_02,args_02),
                     BSLS_COMPILERFEATURES_FORWARD(Args_03,args_03),
                     BSLS_COMPILERFEATURES_FORWARD(Args_04,args_04),
                     BSLS_COMPILERFEATURES_FORWARD(Args_05,args_05),
                     BSLS_COMPILERFEATURES_FORWARD(Args_06,args_06),
                     BSLS_COMPILERFEATURES_FORWARD(Args_07,args_07),
                     BSLS_COMPILERFEATURES_FORWARD(Args_08,args_08),
                     BSLS_COMPILERFEATURES_FORWARD(Args_09,args_09),
                     BSLS_COMPILERFEATURES_FORWARD(Args_10,args_10));
      native_std::push_heap(c.begin(), c.end(), comp);
  }
  #endif  // BSLSTL_PRIORITYQUEUE_VARIADIC_LIMIT_B >= 10
  
  #else
  // The generated code below is a workaround for the absence of perfect
  // forwarding in some compilers.
  template <class VALUE, class CONTAINER, class COMPARATOR>
  template <class... Args>
  inline
  void priority_queue<VALUE, CONTAINER, COMPARATOR>::emplace(
                                 BSLS_COMPILERFEATURES_FORWARD_REF(Args)... args)
  {
      c.emplace_back(BSLS_COMPILERFEATURES_FORWARD(Args,args)...);
      native_std::push_heap(c.begin(), c.end(), comp);
  }
  // }}} END GENERATED CODE
  #endif
  
  template <class VALUE, class CONTAINER, class COMPARATOR>
  inline
  void priority_queue<VALUE, CONTAINER, COMPARATOR>::pop()
  {
      native_std::pop_heap(c.begin(), c.end(), comp);
      c.pop_back();
  }
  
  template <class VALUE, class CONTAINER, class COMPARATOR>
  inline
  void priority_queue<VALUE, CONTAINER, COMPARATOR>::swap(priority_queue& other)
                                       BSLS_KEYWORD_NOEXCEPT_SPECIFICATION(false)
  {
      BloombergLP::bslalg::SwapUtil::swap(&c, &other.c);
      BloombergLP::bslalg::SwapUtil::swap(&comp, &other.comp);
  }
  
  // ACCESSORS
  template <class VALUE, class CONTAINER, class COMPARATOR>
  inline
  bool priority_queue<VALUE, CONTAINER, COMPARATOR>::empty() const
  {
      return c.empty();
  }
  
  template <class VALUE, class CONTAINER, class COMPARATOR>
  inline
  typename priority_queue<VALUE, CONTAINER, COMPARATOR>::size_type
  priority_queue<VALUE, CONTAINER, COMPARATOR>::size() const
  {
      return c.size();
  }
  
  template <class VALUE, class CONTAINER, class COMPARATOR>
  inline
  typename priority_queue<VALUE, CONTAINER, COMPARATOR>::const_reference
  priority_queue<VALUE, CONTAINER, COMPARATOR>::top() const
  {
      return c.front();
  }
  
  // FREE FUNCTIONS
  template <class VALUE, class CONTAINER, class COMPARATOR>
  void swap(priority_queue<VALUE, CONTAINER, COMPARATOR>& a,
            priority_queue<VALUE, CONTAINER, COMPARATOR>& b)
                                       BSLS_KEYWORD_NOEXCEPT_SPECIFICATION(false)
  {
      a.swap(b);
  }
  
  }  // close namespace bsl
  
  #else // if ! defined(DEFINED_BSLSTL_PRIORITYQUEUE_H)
  # error Not valid except when included from bslstl_priorityqueue.h
  #endif // ! defined(COMPILING_BSLSTL_PRIORITYQUEUE_H)
  
  #endif // ! defined(INCLUDED_BSLSTL_PRIORITYQUEUE_CPP03)
  
  // ----------------------------------------------------------------------------
  // Copyright 2021 Bloomberg Finance L.P.
  //
  // Licensed under the Apache License, Version 2.0 (the "License");
  // you may not use this file except in compliance with the License.
  // You may obtain a copy of the License at
  //
  //     http://www.apache.org/licenses/LICENSE-2.0
  //
  // Unless required by applicable law or agreed to in writing, software
  // distributed under the License is distributed on an "AS IS" BASIS,
  // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  // See the License for the specific language governing permissions and
  // limitations under the License.
  // ----------------------------- END-OF-FILE ----------------------------------
  