remove changes to broadcast_array

Author: SteveBronder

stan/math/prim/meta/broadcast_array.hpp

@@ -1,10 +1,10 @@
 #ifndef STAN_MATH_PRIM_META_BROADCAST_ARRAY_HPP
 #define STAN_MATH_PRIM_META_BROADCAST_ARRAY_HPP
 
-#include <stan/math/prim/fun/Eigen.hpp>
 #include <stan/math/prim/meta/require_generics.hpp>
 #include <stan/math/prim/meta/promote_scalar_type.hpp>
-#include <type_traits>
+#include <stan/math/prim/fun/Eigen.hpp>
+#include <stdexcept>
 
 namespace stan {
 namespace math {
@@ -13,16 +13,14 @@ namespace internal {
 template <typename T>
 class broadcast_array {
  private:
-  using T_decay = std::decay_t<T>;
-  T_decay& prim_;
+  T& prim_;
 
  public:
   explicit broadcast_array(T& prim) : prim_(prim) {}
 
-  auto& operator[](int /*i*/) { return prim_; }
-  const auto& operator[](int /*i*/) const { return prim_; }
+  T& operator[](int /*i*/) { return prim_; }
 
-  /**
+  /** \ingroup type_trait
    * We can assign any right hand side which allows for indexing to a
    * broadcast_array. The idea is that the entry for the first index is what
    * gets assigned. The most common use-case should be where the rhs is some
@@ -32,34 +30,22 @@ class broadcast_array {
   void operator=(const Y& m) {
     prim_ = m[0];
   }
-  explicit broadcast_array(const broadcast_array<T>& other) = default;
-  explicit broadcast_array(broadcast_array<T>&& other) = default;
-  broadcast_array& operator=(const broadcast_array& other) = default;
-  broadcast_array& operator=(broadcast_array&& other) = default;
 };
 
 template <typename T, typename S, typename Enable = void>
 class empty_broadcast_array {
  public:
-  using T_decay = std::decay_t<T>;
   empty_broadcast_array() {}
-  /**
+  /** \ingroup type_trait
    * Not implemented so cannot be called.
    */
-  T_decay& operator[](int /*i*/);
-  T_decay& operator[](int /*i*/) const;
+  T& operator[](int /*i*/);
 
-  /**
+  /** \ingroup type_trait
    * Not implemented so cannot be called.
    */
   template <typename Y>
   void operator=(const Y& /*A*/);
-
-  /**
-   * Not implemented so cannot be called.
-   */
-  template <typename R>
-  void operator+=(R);
 };
 
 template <typename ViewElt, typename T>
@@ -69,31 +55,31 @@ class empty_broadcast_array<ViewElt, T, require_eigen_t<T>> {
 
  public:
   empty_broadcast_array() {}
-  /**
+  /** \ingroup type_trait
    * Not implemented so cannot be called.
    */
   ViewElt& operator[](int /*i*/);
-  /**
+  /** \ingroup type_trait
    * Not implemented so cannot be called.
    */
   ViewElt& operator()(int /*i*/);
-  /**
+  /** \ingroup type_trait
    * Not implemented so cannot be called.
    */
   void operator=(const T_arg& /*A*/);
-  /**
+  /** \ingroup type_trait
    * Not implemented so cannot be called.
    */
   void operator+=(T_arg /*A*/);
-  /**
+  /** \ingroup type_trait
    * Not implemented so cannot be called.
    */
   void operator-=(T_arg /*A*/);
-  /**
+  /** \ingroup type_trait
    * Not implemented so cannot be called.
    */
   T& row(int /*i*/);
-  /**
+  /** \ingroup type_trait
    * Not implemented so cannot be called.
    */
   T& col(int /*i*/);