← Back to branch summary

~alinuxninja/nginx-edge/trunk

« back to all changes in this revision

Viewing changes to debian/modules/ngx_pagespeed/psol/include/third_party/chromium/src/base/big_endian.h

  • Committer: Vivian
  • Date: 2015-12-04 18:20:11 UTC
  • Revision ID: git-v1:a36f2bc32e884f7473b3a47040e5411306144d7d
* Do not extract psol.tar.gz

Show diffs side-by-side

added added

removed removed

Lines of Context:
debian/modules/ngx_pagespeed/psol/include/third_party/chromium/src/base/big_endian.h
1
 
// Copyright 2014 The Chromium Authors. All rights reserved.
2
 
// Use of this source code is governed by a BSD-style license that can be
3
 
// found in the LICENSE file.
4
 
 
5
 
#ifndef BASE_BIG_ENDIAN_H_
6
 
#define BASE_BIG_ENDIAN_H_
7
 
 
8
 
#include "base/base_export.h"
9
 
#include "base/basictypes.h"
10
 
#include "base/strings/string_piece.h"
11
 
 
12
 
namespace base {
13
 
 
14
 
// Read an integer (signed or unsigned) from |buf| in Big Endian order.
15
 
// Note: this loop is unrolled with -O1 and above.
16
 
// NOTE(szym): glibc dns-canon.c and SpdyFrameBuilder use
17
 
// ntohs(*(uint16_t*)ptr) which is potentially unaligned.
18
 
// This would cause SIGBUS on ARMv5 or earlier and ARMv6-M.
19
 
template<typename T>
20
 
inline void ReadBigEndian(const char buf[], T* out) {
21
 
  *out = buf[0];
22
 
  for (size_t i = 1; i < sizeof(T); ++i) {
23
 
    *out <<= 8;
24
 
    // Must cast to uint8 to avoid clobbering by sign extension.
25
 
    *out |= static_cast<uint8>(buf[i]);
26
 
  }
27
 
}
28
 
 
29
 
// Write an integer (signed or unsigned) |val| to |buf| in Big Endian order.
30
 
// Note: this loop is unrolled with -O1 and above.
31
 
template<typename T>
32
 
inline void WriteBigEndian(char buf[], T val) {
33
 
  for (size_t i = 0; i < sizeof(T); ++i) {
34
 
    buf[sizeof(T)-i-1] = static_cast<char>(val & 0xFF);
35
 
    val >>= 8;
36
 
  }
37
 
}
38
 
 
39
 
// Specializations to make clang happy about the (dead code) shifts above.
40
 
template<>
41
 
inline void ReadBigEndian<uint8>(const char buf[], uint8* out) {
42
 
  *out = buf[0];
43
 
}
44
 
 
45
 
template<>
46
 
inline void WriteBigEndian<uint8>(char buf[], uint8 val) {
47
 
  buf[0] = static_cast<char>(val);
48
 
}
49
 
 
50
 
// Allows reading integers in network order (big endian) while iterating over
51
 
// an underlying buffer. All the reading functions advance the internal pointer.
52
 
class BASE_EXPORT BigEndianReader {
53
 
 public:
54
 
  BigEndianReader(const char* buf, size_t len);
55
 
 
56
 
  const char* ptr() const { return ptr_; }
57
 
  int remaining() const { return end_ - ptr_; }
58
 
 
59
 
  bool Skip(size_t len);
60
 
  bool ReadBytes(void* out, size_t len);
61
 
  // Creates a StringPiece in |out| that points to the underlying buffer.
62
 
  bool ReadPiece(base::StringPiece* out, size_t len);
63
 
  bool ReadU8(uint8* value);
64
 
  bool ReadU16(uint16* value);
65
 
  bool ReadU32(uint32* value);
66
 
 
67
 
 private:
68
 
  // Hidden to promote type safety.
69
 
  template<typename T>
70
 
  bool Read(T* v);
71
 
 
72
 
  const char* ptr_;
73
 
  const char* end_;
74
 
};
75
 
 
76
 
// Allows writing integers in network order (big endian) while iterating over
77
 
// an underlying buffer. All the writing functions advance the internal pointer.
78
 
class BASE_EXPORT BigEndianWriter {
79
 
 public:
80
 
  BigEndianWriter(char* buf, size_t len);
81
 
 
82
 
  char* ptr() const { return ptr_; }
83
 
  int remaining() const { return end_ - ptr_; }
84
 
 
85
 
  bool Skip(size_t len);
86
 
  bool WriteBytes(const void* buf, size_t len);
87
 
  bool WriteU8(uint8 value);
88
 
  bool WriteU16(uint16 value);
89
 
  bool WriteU32(uint32 value);
90
 
 
91
 
 private:
92
 
  // Hidden to promote type safety.
93
 
  template<typename T>
94
 
  bool Write(T v);
95
 
 
96
 
  char* ptr_;
97
 
  char* end_;
98
 
};
99
 
 
100
 
}  // namespace base
101
 
 
102
 
#endif  // BASE_BIG_ENDIAN_H_