37 public:

38 enum : int {

44 };

45

53 const std::string& operator*() const { return line_; }

58

59 private:

60 bool HasOption(int option) const { return options_ & option; }

61

62 void ReadNextLine() {

63 line_.clear();

64 if (file_ == nullptr) return;

65 do {

66 while (true) {

67 int i = next_position_after_eol_;

68 for (; i < buffer_size_; ++i) {

69 if (buffer_[i] == '\n') break;

70 }

71 if (i == buffer_size_) {

72 line_.append(&buffer_[next_position_after_eol_],

73 i - next_position_after_eol_);

74 buffer_size_ = file_->Read(&buffer_, kBufferSize);

75 if (buffer_size_ < 0) {

76 LOG(WARNING) << "Error while reading file.";

77 file_ = nullptr;

78 break;

79 }

80 next_position_after_eol_ = 0;

81 if (buffer_size_ == 0) {

82 if (line_.empty()) {

83 file_ = nullptr;

84 }

85 break;

86 }

87 } else {

88 line_.append(&buffer_[next_position_after_eol_],

89 i - next_position_after_eol_ + 1);

90 next_position_after_eol_ = i + 1;

91 break;

92 }

93 }

94 PostProcessLine();

96 (line_.empty() || line_ == "\n"));

97 }

98

99 void PostProcessLine() {

101 line_.erase(std::remove(line_.begin(), line_.end(), '\r'), line_.end());

102 }

103 const auto eol = std::find(line_.begin(), line_.end(), '\n');

104 if (!HasOption(KEEP_LINEFEED) && eol != line_.end()) {

105 line_.erase(eol);

106 }

107 }

108

109 static constexpr int kBufferSize = 5 * 1024;

110 char buffer_[kBufferSize];

111 int next_position_after_eol_;

112 int64_t buffer_size_;

113 File* file_;

114 std::string line_;

115 const int options_;

116};

119 public:

120

121

122

123

124

125

126

127

128

129

130

131

139

140

141

142

143

144

157

160

164

166

168

169 private:

170

171

173 const int options_;

174};