Source release 14.1.0

util/include/clock.h

@@ -0,0 +1,24 @@
+// Copyright 2013 Google Inc. All Rights Reserved.
+//
+// Clock - Platform independent interface for a time library
+//
+#ifndef WVCDM_UTIL_CLOCK_H_
+#define WVCDM_UTIL_CLOCK_H_
+
+#include <stdint.h>
+
+namespace wvcdm {
+
+// Provides time related information. The implementation is platform dependent.
+class Clock {
+ public:
+  Clock() {}
+  virtual ~Clock() {}
+
+  // Provides the number of seconds since an epoch - 01/01/1970 00:00 UTC
+  virtual int64_t GetCurrentTime();
+};
+
+}  // namespace wvcdm
+
+#endif  // WVCDM_UTIL_CLOCK_H_

util/include/disallow_copy_and_assign.h

@@ -0,0 +1,15 @@
+// Copyright 2018 Google Inc. All Rights Reserved.
+
+#ifndef WVCDM_UTIL_DISALLOW_COPY_AND_ASSIGN_H_
+#define WVCDM_UTIL_DISALLOW_COPY_AND_ASSIGN_H_
+
+namespace wvcdm {
+
+#define CORE_DISALLOW_COPY_AND_ASSIGN(TypeName) \
+  TypeName(const TypeName&);                    \
+  void operator=(const TypeName&)
+
+
+}  // namespace wvcdm
+
+#endif  //  WVCDM_UTIL_DISALLOW_COPY_AND_ASSIGN_H_

util/include/file_store.h

@@ -0,0 +1,80 @@
+// Copyright 2013 Google Inc. All Rights Reserved.
+//
+// File - Platform independent interface for a File class
+//
+#ifndef WVCDM_UTIL_FILE_STORE_H_
+#define WVCDM_UTIL_FILE_STORE_H_
+
+#include <unistd.h>
+#include <string>
+#include <vector>
+
+#include "disallow_copy_and_assign.h"
+
+namespace wvcdm {
+
+// File class. The implementation is platform dependent.
+class File {
+ public:
+  virtual ssize_t Read(char* buffer, size_t bytes);
+  virtual ssize_t Write(const char* buffer, size_t bytes);
+  virtual void Close();
+
+ protected:
+  class Impl;
+
+  File(Impl*);
+  virtual ~File();
+
+ private:
+  Impl* impl_;
+
+  friend class FileSystem;
+  CORE_DISALLOW_COPY_AND_ASSIGN(File);
+};
+
+class FileSystem {
+ public:
+  class Impl;
+
+  // defines as bit flag
+  enum OpenFlags {
+    kNoFlags = 0,
+    kCreate = 1,
+    kReadOnly = 2,  // defaults to read and write access
+    kTruncate = 4
+  };
+
+  FileSystem();
+  FileSystem(const std::string& origin, void* extra_data);
+  virtual ~FileSystem();
+
+  virtual File* Open(const std::string& file_path, int flags);
+
+  virtual bool Exists(const std::string& file_path);
+  virtual bool Remove(const std::string& file_path);
+  virtual ssize_t FileSize(const std::string& file_path);
+
+  // Return the filenames stored at dir_path.
+  // dir_path will be stripped from the returned names.
+  virtual bool List(const std::string& dir_path,
+                    std::vector<std::string>* names);
+
+  const std::string& origin() const { return origin_; }
+  void SetOrigin(const std::string& origin);
+
+  const std::string& identifier() const { return identifier_; }
+  void SetIdentifier(const std::string& identifier);
+  bool IsGlobal() const { return identifier_.empty(); }
+
+ private:
+  Impl* impl_;
+  std::string origin_;
+  std::string identifier_;
+
+  CORE_DISALLOW_COPY_AND_ASSIGN(FileSystem);
+};
+
+}  // namespace wvcdm
+
+#endif  // WVCDM_UTIL_FILE_STORE_H_

util/include/lock.h

@@ -0,0 +1,51 @@
+// Copyright 2013 Google Inc. All Rights Reserved.
+//
+// Lock - Platform independent interface for a Mutex class
+//
+#ifndef WVCDM_UTIL_LOCK_H_
+#define WVCDM_UTIL_LOCK_H_
+
+#include "disallow_copy_and_assign.h"
+
+namespace wvcdm {
+
+// Simple lock class. The implementation is platform dependent.
+//
+// The lock must be unlocked by the thread that locked it.
+// The lock is also not recursive (ie. cannot be taken multiple times).
+class Lock {
+ public:
+  Lock();
+  ~Lock();
+
+  void Acquire();
+  void Release();
+
+  friend class AutoLock;
+
+ private:
+  class Impl;
+  Impl* impl_;
+
+  CORE_DISALLOW_COPY_AND_ASSIGN(Lock);
+};
+
+// Manages the lock automatically. It will be locked when AutoLock
+// is constructed and release when AutoLock goes out of scope.
+class AutoLock {
+ public:
+  explicit AutoLock(Lock& lock) : lock_(&lock) { lock_->Acquire(); }
+
+  explicit AutoLock(Lock* lock) : lock_(lock) { lock_->Acquire(); }
+
+  ~AutoLock() { lock_->Release(); }
+
+ private:
+  Lock* lock_;
+
+  CORE_DISALLOW_COPY_AND_ASSIGN(AutoLock);
+};
+
+}  // namespace wvcdm
+
+#endif  // WVCDM_UTIL_LOCK_H_

util/include/log.h

@@ -0,0 +1,46 @@
+// Copyright 2013 Google Inc. All Rights Reserved.
+//
+// Log - Platform independent interface for a Logging class
+//
+#ifndef WVCDM_UTIL_LOG_H_
+#define WVCDM_UTIL_LOG_H_
+
+namespace wvcdm {
+
+// Simple logging class. The implementation is platform dependent.
+
+typedef enum {
+  LOG_ERROR,
+  LOG_WARN,
+  LOG_INFO,
+  LOG_DEBUG,
+  LOG_VERBOSE
+} LogPriority;
+
+extern LogPriority g_cutoff;
+
+// Enable/disable verbose logging (LOGV).
+// This function is supplied for cases where the system layer does not
+// initialize logging.  This is also needed to initialize logging in
+// unit tests.
+void InitLogging();
+
+void Log(const char* file, const char* function, int line, LogPriority level,
+         const char* fmt, ...);
+
+// Log APIs
+#ifndef LOGE
+#define LOGE(...) Log(__FILE__, __func__, __LINE__, \
+                      wvcdm::LOG_ERROR, __VA_ARGS__)
+#define LOGW(...) Log(__FILE__, __func__, __LINE__, \
+                      wvcdm::LOG_WARN, __VA_ARGS__)
+#define LOGI(...) Log(__FILE__, __func__, __LINE__, \
+                      wvcdm::LOG_INFO, __VA_ARGS__)
+#define LOGD(...) Log(__FILE__, __func__, __LINE__, \
+                      wvcdm::LOG_DEBUG, __VA_ARGS__)
+#define LOGV(...) Log(__FILE__, __func__, __LINE__, \
+                      wvcdm::LOG_VERBOSE, __VA_ARGS__)
+#endif
+}  // namespace wvcdm
+
+#endif  // WVCDM_UTIL_LOG_H_

util/include/string_conversions.h

@@ -0,0 +1,30 @@
+// Copyright 2013 Google Inc. All Rights Reserved.
+
+#ifndef WVCDM_UTIL_STRING_CONVERSIONS_H_
+#define WVCDM_UTIL_STRING_CONVERSIONS_H_
+
+#include <stddef.h>
+#include <stdint.h>
+#include <string>
+#include <vector>
+
+namespace wvcdm {
+
+std::vector<uint8_t> a2b_hex(const std::string& b);
+std::vector<uint8_t> a2b_hex(const std::string& label, const std::string& b);
+std::string a2bs_hex(const std::string& b);
+std::string b2a_hex(const std::vector<uint8_t>& b);
+std::string b2a_hex(const std::string& b);
+std::string Base64Encode(const std::vector<uint8_t>& bin_input);
+std::vector<uint8_t> Base64Decode(const std::string& bin_input);
+std::string Base64SafeEncode(const std::vector<uint8_t>& bin_input);
+std::string Base64SafeEncodeNoPad(const std::vector<uint8_t>& bin_input);
+std::vector<uint8_t> Base64SafeDecode(const std::string& bin_input);
+std::string HexEncode(const uint8_t* bytes, unsigned size);
+std::string IntToString(int value);
+int64_t htonll64(int64_t x);
+inline int64_t ntohll64(int64_t x) { return htonll64(x); }
+
+}  // namespace wvcdm
+
+#endif  // WVCDM_UTIL_STRING_CONVERSIONS_H_