folly::symbolizer::LineReader Class Reference

#include <LineReader.h>

Inheritance diagram for folly::symbolizer::LineReader:

Public Types
enum	State { kReading, kEof, kError }

Public Member Functions
	LineReader (int fd, char *buf, size_t bufSize)
State	readLine (StringPiece &line)

Private Attributes
int const	fd_
char *const	buf_
char *const	bufEnd_
char *	bol_
char *	eol_
char *	end_
State	state_

Detailed Description

Async-signal-safe line reader.

Definition at line 31 of file LineReader.h.

Member Enumeration Documentation

enum folly::symbolizer::LineReader::State

Enumerator
kReading
kEof
kError

Definition at line 39 of file LineReader.h.

             {
    kReading,
    kEof,
    kError,
  };

Constructor & Destructor Documentation

folly::symbolizer::LineReader::LineReader	(	int	fd,
		char *	buf,
		size_t	bufSize
	)

Create a line reader that reads into a user-provided buffer (of size bufSize).

Definition at line 26 of file LineReader.cpp.

    : fd_(fd),
      buf_(buf),
      bufEnd_(buf_ + bufSize),
      bol_(buf),
      eol_(buf),
      end_(buf),
      state_(kReading) {}

Member Function Documentation

LineReader::State folly::symbolizer::LineReader::readLine

(

StringPiece &

line

)

Read the next line from the file.

If the line is at most bufSize characters long, including the trailing newline, it will be returned (including the trailing newline).

If the line is longer than bufSize, we return the first bufSize bytes (which won't include a trailing newline) and then continue from that point onwards.

The lines returned are not null-terminated.

Returns kReading with a valid line, kEof if at end of file, or kError if a read error was encountered.

Example: bufSize = 10 input has "hello world\n" The first call returns "hello worl" The second call returns "d\n"

Definition at line 35 of file LineReader.cpp.

References folly::Range< Iter >::assign(), bol_, buf_, bufEnd_, end_, eol_, fd_, kEof, kError, kReading, folly::readFull(), and state_.

Referenced by folly::symbolizer::test::expect().

                                                      {
  bol_ = eol_; // Start past what we already returned
  for (;;) {
    // Search for newline
    char* newline = static_cast<char*>(memchr(eol_, '\n', end_ - eol_));
    if (newline) {
      eol_ = newline + 1;
      break;
    } else if (state_ != kReading || (bol_ == buf_ && end_ == bufEnd_)) {
      // If the buffer is full with one line (line too long), or we're
      // at the end of the file, return what we have.
      eol_ = end_;
      break;
    }

    // We don't have a full line in the buffer, but we have room to read.
    // Move to the beginning of the buffer.
    memmove(buf_, eol_, end_ - eol_);
    end_ -= (eol_ - buf_);
    bol_ = buf_;
    eol_ = end_;

    // Refill
    ssize_t available = bufEnd_ - end_;
    ssize_t n = readFull(fd_, end_, available);
    if (n < 0) {
      state_ = kError;
      n = 0;
    } else if (n < available) {
      state_ = kEof;
    }
    end_ += n;
  }

  line.assign(bol_, eol_);
  return eol_ != bol_ ? kReading : state_;
}

Member Data Documentation

char* folly::symbolizer::LineReader::bol_

private

Definition at line 82 of file LineReader.h.

Referenced by readLine().

char* const folly::symbolizer::LineReader::buf_

private

Definition at line 69 of file LineReader.h.

Referenced by readLine().

char* const folly::symbolizer::LineReader::bufEnd_

private

Definition at line 70 of file LineReader.h.

Referenced by readLine().

char* folly::symbolizer::LineReader::end_

private

Definition at line 84 of file LineReader.h.

Referenced by readLine().

char* folly::symbolizer::LineReader::eol_

private

Definition at line 83 of file LineReader.h.

Referenced by readLine().

int const folly::symbolizer::LineReader::fd_

private

Definition at line 68 of file LineReader.h.

Referenced by readLine().

State folly::symbolizer::LineReader::state_

private

Definition at line 85 of file LineReader.h.

Referenced by readLine().

---

The documentation for this class was generated from the following files:

• proxygen/folly/folly/experimental/symbolizer/LineReader.h
• proxygen/folly/folly/experimental/symbolizer/LineReader.cpp