void read_next()
{
parser_.begin_parse();
while (!eof_ && !parser_.done())
{
if (!(index_ < buffer_length_))
{
if (!is_->eof())
{
is_->read(buffer_.data(), buffer_capacity_);
buffer_length_ = static_cast<size_t>(is_->gcount());
if (buffer_length_ == 0)
{
eof_ = true;
}
index_ = 0;
}
else
{
eof_ = true;
}
}
if (!eof_)
{
parser_.parse(buffer_.data(),index_,buffer_length_);
index_ = parser_.index();
}
}
parser_.end_parse();
}
void check_done()
{
while (!eof_)
{
if (!(index_ < buffer_length_))
{
if (!is_->eof())
{
is_->read(buffer_.data(), buffer_capacity_);
buffer_length_ = static_cast<size_t>(is_->gcount());
if (buffer_length_ == 0)
{
eof_ = true;
}
index_ = 0;
}
else
{
eof_ = true;
}
}
if (!eof_)
{
parser_.check_done(buffer_.data(),index_,buffer_length_);
index_ = parser_.index();
}
}
}
int TablePaser::GetColumn(stringstream& ss_str, std::basic_istream<char>& in_put, string& column)
{
column = "";
if (ss_str.eof())
return -1;
char cur_char[2];
cur_char[1] = 0;
char separator = ' ';
if (ss_str.get(cur_char[0]).eof())
return 1;
if (cur_char[0] == ' ')
return 1;
else if (cur_char[0] == '"')
separator = '"';
else
column += string(cur_char);
while (1)
{
if (ss_str.eof())
{
if (separator == '"')
{
if (in_put.eof())
return 0;
column += string("\n\0");
ss_str.clear();
in_put.getline(LineData, LINE_DATA_MAX);
ss_str << LineData;
}
else
return 0;
}
ss_str.getline(LineData, 4096, separator);
column += LineData;
//column.append(LineData);
if (ss_str.eof())
continue;
if (separator == ' ')
return 1;
else if (separator == '"')
{
if (ss_str.eof())
return 0;
ss_str.get(cur_char[0]);
if (ss_str.eof())
return 1;
else if (cur_char[0] == ' ')
return 1;
else if (cur_char[0] != separator)
separator = ' ';
//column.push_back(cur_char);
column += string(cur_char);
}
}
return -1;
}
/**
* @brief Deserialize the integer value from the specified input stream.
* @param __s Reference to the input stream.
*/
void
load(std::basic_istream<CharT, Traits> &__s)
{
// We must ensure that subsequent actions will be performed
// for very likely integer value, otherwise and exception
// should be raised.
if (__s.peek() != basic_value_type::integer_token) {
throw type_error(
"bencode::integer::load the specified stream does "
"not contain interpretable bencode integer value\n");
}
// Read the leading "i" symbol from the provided stream.
__s.get();
// Define the integer symbol representation placeholder.
std::basic_stringstream<CharT, Traits> __i;
// Define the input stream iterator of the provided stream to
// be able to read the integer value symbol by symbol.
auto __si = std::istream_iterator<CharT, CharT, Traits>(__s);
// Define the output stream to as a buffer for the integer
// value, which will be later converted.
auto __ival = std::ostream_iterator<CharT, CharT, Traits>(__i);
// Copy the values from the input stream into the integer
// placeholder string stream.
auto __result = copy_until(__si, __ival,
[&__s](const CharT& __ch) {
// Additionally, check that we did not exceed the
// length of the stream to prevent hangs.
return !__s.eof() && __ch != basic_value_type::end_token;
}, basic_value_type::integer_length);
// Covert the value from the string into the integer.
__i >> _M_value;
// The "e" symbol should be already extracted at this moment,
// so validate that the iterator pointing right to it.
if (*__result != basic_value_type::end_token) {
std::ostringstream __error;
__error << "bencode::integer::load the end of the integer "
"`e` expected, but `" << CharT(*__result) << "` found\n";
throw encoding_error(__error.str());
}
// Validate that decoded value is an actual integer.
if (!_M_value && __i.str() != std::basic_string<
CharT, Traits>(1, CharT('0'))) {
std::ostringstream __error;
__error << "bencode::integer::load the specified "
"value is not a number\n";
throw value_error(__error.str());
}
}
int Buffer::pushBytesFromStream(std::basic_istream<char>& istr, int cnt)
{
if (writeAvailable() < cnt)
cnt = writeAvailable();
istr.read((char*)_tail, cnt);
if (istr.eof())
{
cnt = istr.gcount();
}
else if (istr.fail())
{
return -1;
}
_tail += cnt;
return cnt;
}
std::vector<typename PDBReader<vectorT>::atom_type>
PDBReader<vectorT>::read(std::basic_istream<char>& ifs, const std::size_t model_idx) const
{
while(not ifs.eof())
{
std::string line;
std::getline(ifs, line);
if(line.empty()) continue;
if(line.substr(0, 5) == "MODEL")
{
std::size_t index;
std::istringstream iss(line);
std::string model;
iss >> model >> index;
if(index == model_idx) break;
}
}
void read_ini(std::basic_istream<
typename Ptree::key_type::value_type> &stream,
Ptree &pt)
{
typedef typename Ptree::key_type::value_type Ch;
typedef std::basic_string<Ch> Str;
const Ch semicolon = stream.widen(';');
const Ch hash = stream.widen('#');
const Ch lbracket = stream.widen('[');
const Ch rbracket = stream.widen(']');
Ptree local;
unsigned long line_no = 0;
Ptree *section = 0;
Str line;
// For all lines
while (stream.good())
{
// Get line from stream
++line_no;
std::getline(stream, line);
if (!stream.good() && !stream.eof())
BOOST_PROPERTY_TREE_THROW(ini_parser_error(
"read error", "", line_no));
// If line is non-empty
line = property_tree::detail::trim(line, stream.getloc());
if (!line.empty())
{
// Comment, section or key?
if (line[0] == semicolon || line[0] == hash)
{
// Ignore comments
}
else if (line[0] == lbracket)
{
// If the previous section was empty, drop it again.
if (section && section->empty())
local.pop_back();
typename Str::size_type end = line.find(rbracket);
if (end == Str::npos)
BOOST_PROPERTY_TREE_THROW(ini_parser_error(
"unmatched '['", "", line_no));
Str key = property_tree::detail::trim(
line.substr(1, end - 1), stream.getloc());
if (local.find(key) != local.not_found())
BOOST_PROPERTY_TREE_THROW(ini_parser_error(
"duplicate section name", "", line_no));
section = &local.push_back(
std::make_pair(key, Ptree()))->second;
}
else
{
Ptree &container = section ? *section : local;
typename Str::size_type eqpos = line.find(Ch('='));
if (eqpos == Str::npos)
BOOST_PROPERTY_TREE_THROW(ini_parser_error(
"'=' character not found in line", "", line_no));
if (eqpos == 0)
BOOST_PROPERTY_TREE_THROW(ini_parser_error(
"key expected", "", line_no));
Str key = property_tree::detail::trim(
line.substr(0, eqpos), stream.getloc());
Str data = property_tree::detail::trim(
line.substr(eqpos + 1, Str::npos), stream.getloc());
if (container.find(key) != container.not_found())
BOOST_PROPERTY_TREE_THROW(ini_parser_error(
"duplicate key name", "", line_no));
container.push_back(std::make_pair(key, Ptree(data)));
}
}
}
// If the last section was empty, drop it again.
if (section && section->empty())
local.pop_back();
// Swap local ptree with result ptree
pt.swap(local);
}
/**
* @brief Deserialize the string value from the specified input stream.
* @param __s Reference to the input stream.
*/
void
load(std::basic_istream<CharT, Traits>& __s)
{
// Define the integer symbol representation placeholder.
std::basic_stringstream<CharT, Traits> __i;
// Define the input stream iterator of the provided stream to
// be able to read the string length value symbol by symbol.
auto __si = std::istream_iterator<CharT, CharT, Traits>(__s);
// Define the output stream to as a buffer for the integer
// value, which will be later converted.
auto __ival = std::ostream_iterator<CharT, CharT, Traits>(__i);
// Copy the symbols from the input stream to the integer
// placeholder until the ":" delimiter value.
auto __result = copy_until(__si, __ival,
[&__s](const CharT& __ch) {
// Additionally, check that we did not exceed the
// length of the stream to prevent hangs.
return !__s.eof() && __ch != basic_value_type::delimiter_token;
}, basic_value_type::integer_length);
if (*__result != basic_value_type::delimiter_token) {
std::ostringstream __error;
__error << "bencode::string::load the delimiter `:` "
"expected, but `" << CharT(*__result) << "` found\n";
throw encoding_error(__error.str());
}
// Save the length of the string.
int64_t __count;
__i >> __count;
if (!__count && __i.str() != std::basic_string<
CharT, Traits>(1, CharT('0'))) {
std::ostringstream __error;
__error << "bencode::string::load the specified string "
"length is not a number\n";
throw value_error(__error.str());
}
// Ensure that the string length is a non-negative value.
if (__count < 0) {
std::ostringstream __error;
__error << "bencode::string::load the length of the string "
"value must be a positive integer: `" << __count << "`\n";
throw value_error(__error.str());
}
// Allocate the list of symbols of the specified string length.
std::unique_ptr<CharT[]> __str(new CharT[__count+1]);
// Read the string value into the symbol list.
__s.get(__str.get(), std::streamsize(__count+1));
auto __strval = string_type(__str.get());
// Ensure that valid count of the symbols was extracted from
// the provided input stream.
if (int64_t(__strval.length()) != __count) {
std::ostringstream __error;
__error << "bencode::string::load the specified string "
"decoded length is not equal to the real one: `" << __count
<< "` != `" << __strval.length() << "`\n";
throw value_error(__error.str());
}
// Initialize the internal value with a new string.
_M_value = __strval;
}
