Support folly::getCurrentThreadID() without PThread

[folly.git] / folly / Varint.h

diff --git a/folly/Varint.h b/folly/Varint.h
index a58866fd10392b8f6dd2394db056977a5db61dc3..4664cb95d4f5c4e2aa33efdb95f3398199ff1b53 100644 (file)
--- a/folly/Varint.h
+++ b/folly/Varint.h
@@ -1,5 +1,5 @@
 /*
- * Copyright 2014 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.
@@ -14,9 +14,10 @@
  * limitations under the License.
  */
 
-#ifndef FOLLY_VARINT_H_
-#define FOLLY_VARINT_H_
+#pragma once
 
+#include <type_traits>
+#include <folly/Conv.h>
 #include <folly/Range.h>
 
 namespace folly {
@@ -55,7 +56,8 @@ size_t encodeVarint(uint64_t val, uint8_t* buf);
 /**
  * Decode a value from a given buffer, advances data past the returned value.
  */
-uint64_t decodeVarint(ByteRange& data);
+template <class T>
+uint64_t decodeVarint(Range<T*>& data);
 
 /**
  * ZigZag encoding that maps signed integers with a small absolute value
@@ -69,7 +71,8 @@ uint64_t decodeVarint(ByteRange& data);
 inline uint64_t encodeZigZag(int64_t val) {
   // Bit-twiddling magic stolen from the Google protocol buffer document;
   // val >> 63 is an arithmetic shift because val is signed
-  return static_cast<uint64_t>((val << 1) ^ (val >> 63));
+  auto uval = static_cast<uint64_t>(val);
+  return static_cast<uint64_t>((uval << 1) ^ (val >> 63));
 }
 
 inline int64_t decodeZigZag(uint64_t val) {
@@ -84,11 +87,17 @@ inline size_t encodeVarint(uint64_t val, uint8_t* buf) {
     *p++ = 0x80 | (val & 0x7f);
     val >>= 7;
   }
-  *p++ = val;
-  return p - buf;
+  *p++ = uint8_t(val);
+  return size_t(p - buf);
 }
 
-inline uint64_t decodeVarint(ByteRange& data) {
+template <class T>
+inline uint64_t decodeVarint(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,
+      "Only character ranges are supported");
+
   const int8_t* begin = reinterpret_cast<const int8_t*>(data.begin());
   const int8_t* end = reinterpret_cast<const int8_t*>(data.end());
   const int8_t* p = begin;
@@ -118,15 +127,14 @@ inline uint64_t decodeVarint(ByteRange& data) {
     }
     if (p == end) {
       throw std::invalid_argument("Invalid varint value. Too small: " +
-                                  std::to_string(end - begin) + " bytes");
+                                  folly::to<std::string>(end - begin) +
+                                  " bytes");
     }
     val |= static_cast<uint64_t>(*p++) << shift;
   }
 
-  data.advance(p - begin);
+  data.uncheckedAdvance(p - begin);
   return val;
 }
 
 }  // namespaces
-
-#endif /* FOLLY_VARINT_H_ */