OLD | NEW |
| (Empty) |
1 // Copyright (c) 2012 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 NET_QUIC_QUIC_DATA_READER_H_ | |
6 #define NET_QUIC_QUIC_DATA_READER_H_ | |
7 | |
8 #include "base/basictypes.h" | |
9 #include "base/strings/string_piece.h" | |
10 #include "net/base/int128.h" | |
11 #include "net/base/net_export.h" | |
12 | |
13 namespace net { | |
14 | |
15 // Used for reading QUIC data. Though there isn't really anything terribly | |
16 // QUIC-specific here, it's a helper class that's useful when doing QUIC | |
17 // framing. | |
18 // | |
19 // To use, simply construct a QuicDataReader using the underlying buffer that | |
20 // you'd like to read fields from, then call one of the Read*() methods to | |
21 // actually do some reading. | |
22 // | |
23 // This class keeps an internal iterator to keep track of what's already been | |
24 // read and each successive Read*() call automatically increments said iterator | |
25 // on success. On failure, internal state of the QuicDataReader should not be | |
26 // trusted and it is up to the caller to throw away the failed instance and | |
27 // handle the error as appropriate. None of the Read*() methods should ever be | |
28 // called after failure, as they will also fail immediately. | |
29 class NET_EXPORT_PRIVATE QuicDataReader { | |
30 public: | |
31 // Caller must provide an underlying buffer to work on. | |
32 QuicDataReader(const char* data, const size_t len); | |
33 | |
34 // Empty destructor. | |
35 ~QuicDataReader() {} | |
36 | |
37 // Reads a 16-bit unsigned integer into the given output parameter. | |
38 // Forwards the internal iterator on success. | |
39 // Returns true on success, false otherwise. | |
40 bool ReadUInt16(uint16* result); | |
41 | |
42 // Reads a 32-bit unsigned integer into the given output parameter. | |
43 // Forwards the internal iterator on success. | |
44 // Returns true on success, false otherwise. | |
45 bool ReadUInt32(uint32* result); | |
46 | |
47 // Reads a 48-bit unsigned integer into the given output parameter. | |
48 // Forwards the internal iterator on success. | |
49 // Returns true on success, false otherwise. | |
50 bool ReadUInt48(uint64* result); | |
51 | |
52 // Reads a 64-bit unsigned integer into the given output parameter. | |
53 // Forwards the internal iterator on success. | |
54 // Returns true on success, false otherwise. | |
55 bool ReadUInt64(uint64* result); | |
56 | |
57 // Reads a 128-bit unsigned integer into the given output parameter. | |
58 // Forwards the internal iterator on success. | |
59 // Returns true on success, false otherwise. | |
60 bool ReadUInt128(uint128* result); | |
61 | |
62 // Reads a 16-bit unsigned float into the given output parameter. | |
63 // Forwards the internal iterator on success. | |
64 // Returns true on success, false otherwise. | |
65 bool ReadUFloat16(uint64* result); | |
66 | |
67 // Reads a string prefixed with 16-bit length into the given output parameter. | |
68 // | |
69 // NOTE: Does not copy but rather references strings in the underlying buffer. | |
70 // This should be kept in mind when handling memory management! | |
71 // | |
72 // Forwards the internal iterator on success. | |
73 // Returns true on success, false otherwise. | |
74 bool ReadStringPiece16(base::StringPiece* result); | |
75 | |
76 // Reads a given number of bytes into the given buffer. The buffer | |
77 // must be of adequate size. | |
78 // Forwards the internal iterator on success. | |
79 // Returns true on success, false otherwise. | |
80 bool ReadStringPiece(base::StringPiece* result, size_t len); | |
81 | |
82 // Returns the remaining payload as a StringPiece. | |
83 // | |
84 // NOTE: Does not copy but rather references strings in the underlying buffer. | |
85 // This should be kept in mind when handling memory management! | |
86 // | |
87 // Forwards the internal iterator. | |
88 base::StringPiece ReadRemainingPayload(); | |
89 | |
90 // Returns the remaining payload as a StringPiece. | |
91 // | |
92 // NOTE: Does not copy but rather references strings in the underlying buffer. | |
93 // This should be kept in mind when handling memory management! | |
94 // | |
95 // DOES NOT forward the internal iterator. | |
96 base::StringPiece PeekRemainingPayload(); | |
97 | |
98 // Reads a given number of bytes into the given buffer. The buffer | |
99 // must be of adequate size. | |
100 // Forwards the internal iterator on success. | |
101 // Returns true on success, false otherwise. | |
102 bool ReadBytes(void* result, size_t size); | |
103 | |
104 // Returns true if the entirety of the underlying buffer has been read via | |
105 // Read*() calls. | |
106 bool IsDoneReading() const; | |
107 | |
108 // Returns the number of bytes remaining to be read. | |
109 size_t BytesRemaining() const; | |
110 | |
111 private: | |
112 // Returns true if the underlying buffer has enough room to read the given | |
113 // amount of bytes. | |
114 bool CanRead(size_t bytes) const; | |
115 | |
116 // To be called when a read fails for any reason. | |
117 void OnFailure(); | |
118 | |
119 // The data buffer that we're reading from. | |
120 const char* data_; | |
121 | |
122 // The length of the data buffer that we're reading from. | |
123 const size_t len_; | |
124 | |
125 // The location of the next read from our data buffer. | |
126 size_t pos_; | |
127 | |
128 DISALLOW_COPY_AND_ASSIGN(QuicDataReader); | |
129 }; | |
130 | |
131 } // namespace net | |
132 | |
133 #endif // NET_QUIC_QUIC_DATA_READER_H_ | |
OLD | NEW |