/** * @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; }