folly::io::Cursor·RWCursor — chain 위의 stream

1
// chain 직접 — boilerplate
2
uint32_t readU32(IOBuf* buf, size_t offset) {
3
  IOBuf* cur = buf;
4
  while (cur && offset >= cur->length()) {
5
    offset -= cur->length();
6
    cur = cur->next();
7
  }
8
  // cur에 [offset, offset+4)이 들어맞는지 확인
9
  // 안 맞으면 다음 buffer로 넘어가서 합쳐서 읽기
10
  ...
11
}

1
#include <folly/io/Cursor.h>
2

3
auto buf = ...;   // IOBuf chain
4

5
folly::io::Cursor cur(buf.get());
6

7
uint32_t magic = cur.readBE<uint32_t>();   // big-endian
8
uint8_t type = cur.read<uint8_t>();
9
uint64_t size = cur.readLE<uint64_t>();    // little-endian
10

11
// 문자열 읽기
12
std::string name = cur.readFixedString(16);
13

14
// 가변 길이
15
auto body = std::make_unique<folly::IOBuf>(folly::IOBuf::create(size));
16
cur.pull(body->writableTail(), size);
17
body->append(size);
18

19
// 남은 길이
20
size_t remaining = cur.totalLength();

1
// folly/io/Cursor.h (요약)
2
class CursorBase {
3
 public:
4
  // peek (advance 안 함)
5
  template <class T> T peekBE() const;
6
  template <class T> T peekLE() const;
7
  template <class T> T peek() const;
8

9
  // read (advance)
10
  template <class T> T readBE();
11
  template <class T> T readLE();
12
  template <class T> T read();
13

14
  // pull bytes
15
  void pull(void* buf, size_t n);
16
  size_t pullAtMost(void* buf, size_t n);
17

18
  // skip
19
  void skip(size_t n);
20
  size_t skipAtMost(size_t n);
21

22
  // clone — 같은 chain, 다른 cursor
23
  CursorBase clone() const;
24

25
  // accessors
26
  size_t totalLength() const;
27
  bool isAtEnd() const;
28
};

1
#include <folly/io/Cursor.h>
2

3
auto buf = folly::IOBuf::create(1024);
4
buf->append(64);   // 64 bytes 영역 확보
5

6
folly::io::RWCursor cur(buf.get());
7

8
cur.writeBE<uint32_t>(0xDEADBEEF);
9
cur.writeBE<uint32_t>(0x12345678);
10
cur.write<uint8_t>(0xFF);

1
folly::IOBufQueue q;
2
folly::io::QueueAppender app(&q, 4096);   // chunk 4096
3

4
app.writeBE<uint32_t>(0xDEADBEEF);
5
app.push(reinterpret_cast<const uint8_t*>("hello"), 5);
6
app.write<uint8_t>(0xFF);
7

8
// q에 모두 들어감

1
// 네트워크 byte order = big-endian
2
cur.writeBE<uint16_t>(port);
3
cur.writeBE<uint32_t>(addr);
4

5
// 일부 protocol은 little-endian (Windows API 등)
6
cur.writeLE<uint64_t>(timestamp);
7

8
// host-endian (보통 little)
9
cur.write<uint32_t>(localValue);

1
struct Header {
2
  uint32_t magic;
3
  uint8_t version;
4
  uint8_t type;
5
  uint16_t flags;
6
  uint32_t length;
7
};
8

9
Header parseHeader(folly::IOBufQueue& q) {
10
  if (q.chainLength() < sizeof(Header)) {
11
    throw std::runtime_error("not enough data");
12
  }
13
  folly::io::Cursor cur(q.front());
14
  Header h;
15
  h.magic = cur.readBE<uint32_t>();
16
  h.version = cur.read<uint8_t>();
17
  h.type = cur.read<uint8_t>();
18
  h.flags = cur.readBE<uint16_t>();
19
  h.length = cur.readBE<uint32_t>();
20
  return h;
21
}

1
// pull — buffer로 복사
2
char temp[64];
3
cur.pull(temp, 64);
4

5
// skip — 그냥 건너뜀
6
cur.skip(64);
7

8
// pullAtMost — 부분도 OK
9
size_t n = cur.pullAtMost(temp, 64);
10

11
// skipAtMost — 마찬가지
12
size_t skipped = cur.skipAtMost(64);

1
auto cur1 = folly::io::Cursor(buf.get());
2

3
auto magic = cur1.peekBE<uint32_t>();
4
if (magic == kVersion1) {
5
  parseV1(cur1);
6
} else {
7
  // 다른 parsing 시도
8
  auto cur2 = cur1.clone();
9
  parseV2(cur2);
10
  // cur1은 여전히 원래 위치 유지
11
}

1
// 1. endian 잘못
2
cur.read<uint32_t>();   // host-endian — network protocol이면 BE 필요
3

4
// 2. 길이 검증 없이 read
5
auto h = cur.read<Header>();   // 모자라면 throw — 부분 도착 처리 안 됨
6
// 옳음:
7
if (cur.totalLength() < sizeof(Header)) return std::nullopt;
8

9
// 3. RWCursor + cloned buffer
10
auto cloned = buf->clone();
11
folly::io::RWCursor cur(cloned.get());
12
cur.writeBE<uint32_t>(0);   // 원본 buf의 data도 바뀜 — share
13

14
// 4. struct를 raw read
15
struct Pkt { uint32_t a; uint64_t b; };
16
auto p = cur.read<Pkt>();   // padding/alignment 위험 — 필드별로 읽자