Remove wpiutil and update to the new build system (#210)

src/main/native/cpp/Storage.h

@@ -0,0 +1,183 @@
+/*----------------------------------------------------------------------------*/
+/* Copyright (c) FIRST 2015. 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.                                                               */
+/*----------------------------------------------------------------------------*/
+
+#ifndef NT_STORAGE_H_
+#define NT_STORAGE_H_
+
+#include <atomic>
+#include <cstddef>
+#include <fstream>
+#include <functional>
+#include <iosfwd>
+#include <memory>
+#include <mutex>
+#include <vector>
+
+#include "llvm/DenseMap.h"
+#include "llvm/SmallSet.h"
+#include "llvm/StringMap.h"
+#include "support/atomic_static.h"
+#include "Message.h"
+#include "Notifier.h"
+#include "ntcore_cpp.h"
+#include "RpcServer.h"
+#include "SequenceNumber.h"
+
+namespace nt {
+
+class NetworkConnection;
+class StorageTest;
+
+class Storage {
+  friend class StorageTest;
+
+ public:
+  static Storage& GetInstance() {
+    ATOMIC_STATIC(Storage, instance);
+    return instance;
+  }
+  ~Storage();
+
+  // Accessors required by Dispatcher.  A function pointer is used for
+  // generation of outgoing messages to break a dependency loop between
+  // Storage and Dispatcher; in operation this is always set to
+  // Dispatcher::QueueOutgoing.
+  typedef std::function<void(std::shared_ptr<Message> msg,
+                             NetworkConnection* only,
+                             NetworkConnection* except)>
+      QueueOutgoingFunc;
+  void SetOutgoing(QueueOutgoingFunc queue_outgoing, bool server);
+  void ClearOutgoing();
+
+  // Required for wire protocol 2.0 to get the entry type of an entry when
+  // receiving entry updates (because the length/type is not provided in the
+  // message itself).  Not used in wire protocol 3.0.
+  NT_Type GetEntryType(unsigned int id) const;
+
+  void ProcessIncoming(std::shared_ptr<Message> msg, NetworkConnection* conn,
+                       std::weak_ptr<NetworkConnection> conn_weak);
+  void GetInitialAssignments(NetworkConnection& conn,
+                             std::vector<std::shared_ptr<Message>>* msgs);
+  void ApplyInitialAssignments(NetworkConnection& conn,
+                               llvm::ArrayRef<std::shared_ptr<Message>> msgs,
+                               bool new_server,
+                               std::vector<std::shared_ptr<Message>>* out_msgs);
+
+  // User functions.  These are the actual implementations of the corresponding
+  // user API functions in ntcore_cpp.
+  std::shared_ptr<Value> GetEntryValue(StringRef name) const;
+  bool SetDefaultEntryValue(StringRef name, std::shared_ptr<Value> value);
+  bool SetEntryValue(StringRef name, std::shared_ptr<Value> value);
+  void SetEntryTypeValue(StringRef name, std::shared_ptr<Value> value);
+  void SetEntryFlags(StringRef name, unsigned int flags);
+  unsigned int GetEntryFlags(StringRef name) const;
+  void DeleteEntry(StringRef name);
+  void DeleteAllEntries();
+  std::vector<EntryInfo> GetEntryInfo(StringRef prefix, unsigned int types);
+  void NotifyEntries(StringRef prefix,
+                     EntryListenerCallback only = nullptr) const;
+
+  // Filename-based save/load functions.  Used both by periodic saves and
+  // accessible directly via the user API.
+  const char* SavePersistent(StringRef filename, bool periodic) const;
+  const char* LoadPersistent(
+      StringRef filename,
+      std::function<void(std::size_t line, const char* msg)> warn);
+
+  // Stream-based save/load functions (exposed for testing purposes).  These
+  // implement the guts of the filename-based functions.
+  void SavePersistent(std::ostream& os, bool periodic) const;
+  bool LoadPersistent(
+      std::istream& is,
+      std::function<void(std::size_t line, const char* msg)> warn);
+
+  // RPC configuration needs to come through here as RPC definitions are
+  // actually special Storage value types.
+  void CreateRpc(StringRef name, StringRef def, RpcCallback callback);
+  void CreatePolledRpc(StringRef name, StringRef def);
+
+  unsigned int CallRpc(StringRef name, StringRef params);
+  bool GetRpcResult(bool blocking, unsigned int call_uid, std::string* result);
+  bool GetRpcResult(bool blocking, unsigned int call_uid, double time_out,
+                    std::string* result);
+  void CancelBlockingRpcResult(unsigned int call_uid);
+
+ private:
+  Storage();
+  Storage(Notifier& notifier, RpcServer& rpcserver);
+  Storage(const Storage&) = delete;
+  Storage& operator=(const Storage&) = delete;
+
+  // Data for each table entry.
+  struct Entry {
+    Entry(llvm::StringRef name_)
+        : name(name_), flags(0), id(0xffff), rpc_call_uid(0) {}
+    bool IsPersistent() const { return (flags & NT_PERSISTENT) != 0; }
+
+    // We redundantly store the name so that it's available when accessing the
+    // raw Entry* via the ID map.
+    std::string name;
+
+    // The current value and flags.
+    std::shared_ptr<Value> value;
+    unsigned int flags;
+
+    // Unique ID for this entry as used in network messages.  The value is
+    // assigned by the server, so on the client this is 0xffff until an
+    // entry assignment is received back from the server.
+    unsigned int id;
+
+    // Sequence number for update resolution.
+    SequenceNumber seq_num;
+
+    // RPC callback function.  Null if either not an RPC or if the RPC is
+    // polled.
+    RpcCallback rpc_callback;
+
+    // Last UID used when calling this RPC (primarily for client use).  This
+    // is incremented for each call.
+    unsigned int rpc_call_uid;
+  };
+
+  typedef llvm::StringMap<std::unique_ptr<Entry>> EntriesMap;
+  typedef std::vector<Entry*> IdMap;
+  typedef llvm::DenseMap<std::pair<unsigned int, unsigned int>, std::string>
+      RpcResultMap;
+  typedef llvm::SmallSet<unsigned int, 12> RpcBlockingCallSet;
+
+  mutable std::mutex m_mutex;
+  EntriesMap m_entries;
+  IdMap m_idmap;
+  RpcResultMap m_rpc_results;
+  RpcBlockingCallSet m_rpc_blocking_calls;
+  // If any persistent values have changed
+  mutable bool m_persistent_dirty = false;
+
+  // condition variable and termination flag for blocking on a RPC result
+  std::atomic_bool m_terminating;
+  std::condition_variable m_rpc_results_cond;
+
+  // configured by dispatcher at startup
+  QueueOutgoingFunc m_queue_outgoing;
+  bool m_server = true;
+
+  // references to singletons (we don't grab them directly for testing purposes)
+  Notifier& m_notifier;
+  RpcServer& m_rpc_server;
+
+  bool GetPersistentEntries(
+      bool periodic,
+      std::vector<std::pair<std::string, std::shared_ptr<Value>>>* entries)
+      const;
+  void DeleteAllEntriesImpl();
+
+  ATOMIC_STATIC_DECL(Storage)
+};
+
+}  // namespace nt
+
+#endif  // NT_STORAGE_H_