Remove wpi::ArrayRef std::initializer_list constructor (#1745)

This can be dangerous as it refers to a temporary, and GCC 9.0 warns about
its use.  Instead add std::initializer_list overloads to common places it
was used in an initializer_list sense.

wpiutil/src/main/native/include/wpi/ArrayRef.h

@@ -98,11 +98,6 @@ namespace wpi {
     template <size_t N>
     /*implicit*/ constexpr ArrayRef(const T (&Arr)[N]) : Data(Arr), Length(N) {}
 
-    /// Construct an ArrayRef from a std::initializer_list.
-    /*implicit*/ ArrayRef(const std::initializer_list<T> &Vec)
-    : Data(Vec.begin() == Vec.end() ? (T*)nullptr : Vec.begin()),
-      Length(Vec.size()) {}
-
     /// Construct an ArrayRef<const T*> from ArrayRef<T*>. This uses SFINAE to
     /// ensure that only ArrayRefs of pointers can be converted.
     template <typename U>

wpiutil/src/main/native/include/wpi/WebSocket.h

@@ -11,6 +11,7 @@
 #include <stdint.h>
 
 #include <functional>
+#include <initializer_list>
 #include <memory>
 #include <string>
 #include <utility>
@@ -99,6 +100,25 @@ class WebSocket : public std::enable_shared_from_this<WebSocket> {
       ArrayRef<StringRef> protocols = ArrayRef<StringRef>{},
       const ClientOptions& options = ClientOptions{});
 
+  /**
+   * Starts a client connection by performing the initial client handshake.
+   * An open event is emitted when the handshake completes.
+   * This sets the stream user data to the websocket.
+   * @param stream Connection stream
+   * @param uri The Request-URI to send
+   * @param host The host or host:port to send
+   * @param protocols The list of subprotocols
+   * @param options Handshake options
+   */
+  static std::shared_ptr<WebSocket> CreateClient(
+      uv::Stream& stream, const Twine& uri, const Twine& host,
+      std::initializer_list<StringRef> protocols,
+      const ClientOptions& options = ClientOptions{}) {
+    return CreateClient(stream, uri, host,
+                        makeArrayRef(protocols.begin(), protocols.end()),
+                        options);
+  }
+
   /**
    * Starts a server connection by performing the initial server side handshake.
    * This should be called after the HTTP headers have been received.

wpiutil/src/main/native/include/wpi/WebSocketServer.h

@@ -1,5 +1,5 @@
 /*----------------------------------------------------------------------------*/
-/* Copyright (c) 2018 FIRST. All Rights Reserved.                             */
+/* Copyright (c) 2018-2019 FIRST. All Rights Reserved.                        */
 /* Open Source Software - may be modified and shared by FRC teams. The code   */
 /* must be accompanied by the FIRST BSD license file in the root directory of */
 /* the project.                                                               */
@@ -9,6 +9,7 @@
 #define WPIUTIL_WPI_WEBSOCKETSERVER_H_
 
 #include <functional>
+#include <initializer_list>
 #include <memory>
 #include <string>
 #include <utility>
@@ -56,6 +57,20 @@ class WebSocketServerHelper {
    */
   std::pair<bool, StringRef> MatchProtocol(ArrayRef<StringRef> protocols);
 
+  /**
+   * Try to find a match to the list of sub-protocols provided by the client.
+   * The list is priority ordered, so the first match wins.
+   * Only valid during and after the upgrade event.
+   * @param protocols Acceptable protocols
+   * @return Pair; first item is true if a match was made, false if not.
+   *         Second item is the matched protocol if a match was made, otherwise
+   *         is empty.
+   */
+  std::pair<bool, StringRef> MatchProtocol(
+      std::initializer_list<StringRef> protocols) {
+    return MatchProtocol(makeArrayRef(protocols.begin(), protocols.end()));
+  }
+
   /**
    * Accept the upgrade.  Disconnect other readers (such as the HttpParser
    * reader) before calling this.  See also WebSocket::CreateServer().
@@ -125,6 +140,22 @@ class WebSocketServer : public std::enable_shared_from_this<WebSocketServer> {
       uv::Stream& stream, ArrayRef<StringRef> protocols = ArrayRef<StringRef>{},
       const ServerOptions& options = ServerOptions{});
 
+  /**
+   * Starts a dedicated WebSocket server on the provided connection.  The
+   * connection should be an accepted client stream.
+   * This also sets the stream user data to the socket server.
+   * A connected event is emitted when the connection is opened.
+   * @param stream Connection stream
+   * @param protocols Acceptable subprotocols
+   * @param options Handshake options
+   */
+  static std::shared_ptr<WebSocketServer> Create(
+      uv::Stream& stream, std::initializer_list<StringRef> protocols,
+      const ServerOptions& options = ServerOptions{}) {
+    return Create(stream, makeArrayRef(protocols.begin(), protocols.end()),
+                  options);
+  }
+
   /**
    * Connected event.  First parameter is the URL, second is the websocket.
    */

wpiutil/src/main/native/include/wpi/uv/Stream.h

@@ -1,5 +1,5 @@
 /*----------------------------------------------------------------------------*/
-/* Copyright (c) 2018 FIRST. All Rights Reserved.                             */
+/* Copyright (c) 2018-2019 FIRST. All Rights Reserved.                        */
 /* Open Source Software - may be modified and shared by FRC teams. The code   */
 /* must be accompanied by the FIRST BSD license file in the root directory of */
 /* the project.                                                               */
@@ -11,6 +11,7 @@
 #include <uv.h>
 
 #include <functional>
+#include <initializer_list>
 #include <memory>
 
 #include "wpi/ArrayRef.h"
@@ -130,6 +131,27 @@ class Stream : public Handle {
    */
   void Write(ArrayRef<Buffer> bufs, const std::shared_ptr<WriteReq>& req);
 
+  /**
+   * Write data to the stream.
+   *
+   * Data are written in order. The lifetime of the data pointers passed in
+   * the `bufs` parameter must exceed the lifetime of the write request.
+   * An easy way to ensure this is to have the write request keep track of
+   * the data and use either its Complete() function or destructor to free the
+   * data.
+   *
+   * The finish signal will be emitted on the request object when the data
+   * has been written (or if an error occurs).
+   * The error signal will be emitted on the request object in case of errors.
+   *
+   * @param bufs The buffers to be written to the stream.
+   * @param req write request
+   */
+  void Write(std::initializer_list<Buffer> bufs,
+             const std::shared_ptr<WriteReq>& req) {
+    Write(makeArrayRef(bufs.begin(), bufs.end()), req);
+  }
+
   /**
    * Write data to the stream.
    *
@@ -146,6 +168,24 @@ class Stream : public Handle {
   void Write(ArrayRef<Buffer> bufs,
              std::function<void(MutableArrayRef<Buffer>, Error)> callback);
 
+  /**
+   * Write data to the stream.
+   *
+   * Data are written in order. The lifetime of the data pointers passed in
+   * the `bufs` parameter must exceed the lifetime of the write request.
+   * The callback can be used to free data after the request completes.
+   *
+   * The callback will be called when the data has been written (even if an
+   * error occurred).  Errors will be reported to the stream error handler.
+   *
+   * @param bufs The buffers to be written to the stream.
+   * @param callback Callback function to call when the write completes
+   */
+  void Write(std::initializer_list<Buffer> bufs,
+             std::function<void(MutableArrayRef<Buffer>, Error)> callback) {
+    Write(makeArrayRef(bufs.begin(), bufs.end()), callback);
+  }
+
   /**
    * Queue a write request if it can be completed immediately.
    *
@@ -158,6 +198,20 @@ class Stream : public Handle {
    */
   int TryWrite(ArrayRef<Buffer> bufs);
 
+  /**
+   * Queue a write request if it can be completed immediately.
+   *
+   * Same as `Write()`, but won’t queue a write request if it can’t be
+   * completed immediately.
+   * An error signal will be emitted in case of errors.
+   *
+   * @param bufs The buffers to be written to the stream.
+   * @return Number of bytes written.
+   */
+  int TryWrite(std::initializer_list<Buffer> bufs) {
+    return TryWrite(makeArrayRef(bufs.begin(), bufs.end()));
+  }
+
   /**
    * Check if the stream is readable.
    * @return True if the stream is readable, false otherwise.