X-Git-Url: http://plrg.eecs.uci.edu/git/?a=blobdiff_plain;f=folly%2FVarint.h;h=c28d7f724fa2ddace0307b5b71d3dd8accbd1a9c;hb=ee207f19892790e091082cc7c7ab8c5df0398061;hp=07968799f8a265cc3546de8cbcf5c556c2e70299;hpb=1c098e2758d1bd55c48ffa26dab389dbbe96a666;p=folly.git

diff --git a/folly/Varint.h b/folly/Varint.h
index 07968799..c28d7f72 100644
--- a/folly/Varint.h
+++ b/folly/Varint.h
@@ -1,5 +1,5 @@
 /*
- * Copyright 2016 Facebook, Inc.
+ * Copyright 2017 Facebook, Inc.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -17,7 +17,10 @@
 #pragma once
 
 #include <type_traits>
+
 #include <folly/Conv.h>
+#include <folly/Expected.h>
+#include <folly/Likely.h>
 #include <folly/Range.h>
 
 namespace folly {
@@ -55,10 +58,24 @@ size_t encodeVarint(uint64_t val, uint8_t* buf);
 
 /**
  * Decode a value from a given buffer, advances data past the returned value.
+ * Throws on error.
  */
 template <class T>
 uint64_t decodeVarint(Range<T*>& data);
 
+enum class DecodeVarintError {
+  TooManyBytes = 0,
+  TooFewBytes = 1,
+};
+
+/**
+ * A variant of decodeVarint() that does not throw on error. Useful in contexts
+ * where only part of a serialized varint may be attempted to be decoded, e.g.,
+ * when a serialized varint arrives on the boundary of a network packet.
+ */
+template <class T>
+Expected<uint64_t, DecodeVarintError> tryDecodeVarint(Range<T*>& data);
+
 /**
  * ZigZag encoding that maps signed integers with a small absolute value
  * to unsigned integers with a small (positive) values. Without this,
@@ -88,11 +105,23 @@ inline size_t encodeVarint(uint64_t val, uint8_t* buf) {
     val >>= 7;
   }
   *p++ = uint8_t(val);
-  return p - buf;
+  return size_t(p - buf);
 }
 
 template <class T>
 inline uint64_t decodeVarint(Range<T*>& data) {
+  auto expected = tryDecodeVarint(data);
+  if (!expected) {
+    throw std::invalid_argument(
+        expected.error() == DecodeVarintError::TooManyBytes
+            ? "Invalid varint value: too many bytes."
+            : "Invalid varint value: too few bytes.");
+  }
+  return *expected;
+}
+
+template <class T>
+inline Expected<uint64_t, DecodeVarintError> tryDecodeVarint(Range<T*>& data) {
   static_assert(
       std::is_same<typename std::remove_cv<T>::type, char>::value ||
           std::is_same<typename std::remove_cv<T>::type, unsigned char>::value,
@@ -107,17 +136,57 @@ inline uint64_t decodeVarint(Range<T*>& data) {
   if (LIKELY(size_t(end - begin) >= kMaxVarintLength64)) {  // fast path
     int64_t b;
     do {
-      b = *p++; val  = (b & 0x7f)      ; if (b >= 0) break;
-      b = *p++; val |= (b & 0x7f) <<  7; if (b >= 0) break;
-      b = *p++; val |= (b & 0x7f) << 14; if (b >= 0) break;
-      b = *p++; val |= (b & 0x7f) << 21; if (b >= 0) break;
-      b = *p++; val |= (b & 0x7f) << 28; if (b >= 0) break;
-      b = *p++; val |= (b & 0x7f) << 35; if (b >= 0) break;
-      b = *p++; val |= (b & 0x7f) << 42; if (b >= 0) break;
-      b = *p++; val |= (b & 0x7f) << 49; if (b >= 0) break;
-      b = *p++; val |= (b & 0x7f) << 56; if (b >= 0) break;
-      b = *p++; val |= (b & 0x7f) << 63; if (b >= 0) break;
-      throw std::invalid_argument("Invalid varint value. Too big.");
+      b = *p++;
+      val = (b & 0x7f);
+      if (b >= 0) {
+        break;
+      }
+      b = *p++;
+      val |= (b & 0x7f) << 7;
+      if (b >= 0) {
+        break;
+      }
+      b = *p++;
+      val |= (b & 0x7f) << 14;
+      if (b >= 0) {
+        break;
+      }
+      b = *p++;
+      val |= (b & 0x7f) << 21;
+      if (b >= 0) {
+        break;
+      }
+      b = *p++;
+      val |= (b & 0x7f) << 28;
+      if (b >= 0) {
+        break;
+      }
+      b = *p++;
+      val |= (b & 0x7f) << 35;
+      if (b >= 0) {
+        break;
+      }
+      b = *p++;
+      val |= (b & 0x7f) << 42;
+      if (b >= 0) {
+        break;
+      }
+      b = *p++;
+      val |= (b & 0x7f) << 49;
+      if (b >= 0) {
+        break;
+      }
+      b = *p++;
+      val |= (b & 0x7f) << 56;
+      if (b >= 0) {
+        break;
+      }
+      b = *p++;
+      val |= (b & 0x01) << 63;
+      if (b >= 0) {
+        break;
+      }
+      return makeUnexpected(DecodeVarintError::TooManyBytes);
     } while (false);
   } else {
     int shift = 0;
@@ -126,9 +195,7 @@ inline uint64_t decodeVarint(Range<T*>& data) {
       shift += 7;
     }
     if (p == end) {
-      throw std::invalid_argument("Invalid varint value. Too small: " +
-                                  folly::to<std::string>(end - begin) +
-                                  " bytes");
+      return makeUnexpected(DecodeVarintError::TooFewBytes);
     }
     val |= static_cast<uint64_t>(*p++) << shift;
   }
@@ -137,4 +204,4 @@ inline uint64_t decodeVarint(Range<T*>& data) {
   return val;
 }
 
-}  // namespaces
+} // namespace folly