/**
* @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());
}
}
bool FASTA_format::get_seq(vector<char>& id, vector<Letter>& seq, Compressed_istream & s) const
{
if (!have_char(s, '>'))
return false;
id.clear();
seq.clear();
copy_line(s, id, Raw_text());
copy_until(s, '>', seq);
return true;
}
size_t
TypeDesc::fromstring (const char *typestring)
{
TypeDesc t;
size_t len = 0;
if (! typestring)
return 0;
// The first "word" should be a type name.
char type[16];
len = copy_until (typestring, " [", type, sizeof(type));
// Check the scalar types in our table above
for (int i = 0; i < LASTBASE; ++i) {
if (! strcmp (type, basetype_name[i])) {
t.basetype = i;
break;
}
}
// Some special case names for aggregates
if (t.basetype != UNKNOWN) {
// already solved
}
else if (! strcmp (type, "color"))
t = TypeColor;
else if (! strcmp (type, "point"))
t = TypePoint;
else if (! strcmp (type, "vector"))
t = TypeVector;
else if (! strcmp (type, "normal"))
t = TypeNormal;
else if (! strcmp (type, "matrix"))
t = TypeMatrix;
else {
return 0; // unknown
}
// Is there an array length following the type name?
while (typestring[len] == ' ')
++len;
if (typestring[len] == '[') {
++len;
while (typestring[len] == ' ')
++len;
if (typestring[len] == ']') { // '[]' indicates array of unknown len
t.arraylen = -1;
} else {
t.arraylen = atoi (typestring+len);
while ((typestring[len] >= '0' && typestring[len] <= '9') ||
typestring[len] == ' ')
++len;
}
if (typestring[len] == ']')
++len;
else
return 0;
}
*this = t;
return len;
}
aku_Status SeriesParser::to_normal_form(const char* begin, const char* end,
char* out_begin, char* out_end,
const char** keystr_begin,
const char** keystr_end)
{
// Verify args
if (end < begin) {
return AKU_EBAD_ARG;
}
if (out_end < out_begin) {
return AKU_EBAD_ARG;
}
int series_name_len = end - begin;
if (series_name_len > AKU_LIMITS_MAX_SNAME) {
return AKU_EBAD_DATA;
}
if (series_name_len > (out_end - out_begin)) {
return AKU_EBAD_ARG;
}
char* it_out = out_begin;
const char* it = begin;
// Get metric name
it = skip_space(it, end);
it = copy_until(it, end, ' ', &it_out);
it = skip_space(it, end);
if (it == end) {
// At least one tag should be specified
return AKU_EBAD_DATA;
}
*keystr_begin = it_out;
// Get pointers to the keys
const char* tags[AKU_LIMITS_MAX_TAGS];
auto ix_tag = 0u;
bool error = false;
while(it < end && ix_tag < AKU_LIMITS_MAX_TAGS) {
tags[ix_tag] = it;
it = skip_tag(it, end, &error);
it = skip_space(it, end);
if (!error) {
ix_tag++;
} else {
break;
}
}
if (error) {
// Bad string
return AKU_EBAD_DATA;
}
if (ix_tag == 0) {
// User should specify at least one tag
return AKU_EBAD_DATA;
}
std::sort(tags, tags + ix_tag, [tags, end](const char* lhs, const char* rhs) {
// lhs should be always less thenn rhs
auto lenl = 0u;
auto lenr = 0u;
if (lhs < rhs) {
lenl = rhs - lhs;
lenr = end - rhs;
} else {
lenl = end - lhs;
lenr = lhs - rhs;
}
auto it = 0u;
while(true) {
if (it >= lenl || it >= lenr) {
return it < lenl;
}
if (lhs[it] == '=' || rhs[it] == '=') {
return lhs[it] == '=';
}
if (lhs[it] < rhs[it]) {
return true;
} else if (lhs[it] > rhs[it]) {
return false;
}
it++;
}
return true;
});
// Copy tags to output string
for (auto i = 0u; i < ix_tag; i++) {
// insert space
*it_out++ = ' ';
// insert tag
const char* tag = tags[i];
copy_until(tag, end, ' ', &it_out);
}
*keystr_begin = skip_space(*keystr_begin, out_end);
*keystr_end = it_out;
return AKU_SUCCESS;
}
/**
* @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;
}
