void Polynomial<T>::input(std::istream &in)
{
T coef;
int data;
in.clear();
in>>coef>>data;
while(in.good())
{
operator+=(Polynomial(coef,data));
in>>coef>>data;
}
in.clear();
in.get();
}
/// Determine whether the given stream is gzipped.
bool RibInputBuffer::isGzippedStream(std::istream& in)
{
bool isZipped = false;
std::istream::int_type c = in.get();
// Check whether the magic number matches that for a gzip stream
const std::istream::int_type gzipMagic[] = {0x1f, 0x8b};
if(c == gzipMagic[0])
{
if(in.peek() == gzipMagic[1])
isZipped = true;
}
in.unget();
return isZipped;
}
static bool isGzip(std::istream & in)
{
int const b0 = in.get();
if ( b0 < 0 )
return false;
int const b1 = in.get();
if ( b1 < 0 )
{
in.clear();
in.putback(b0);
return false;
}
in.clear();
in.putback(b1);
in.putback(b0);
return b0 == libmaus2::lz::GzipHeaderConstantsBase::ID1 &&
b1 == libmaus2::lz::GzipHeaderConstantsBase::ID2;
}
void HTMLForm::readUrl(std::istream& istr)
{
static const int eof = std::char_traits<char>::eof();
int fields = 0;
int ch = istr.get();
while (ch != eof)
{
if (_fieldLimit > 0 && fields == _fieldLimit)
throw HTMLFormException("Too many form fields");
std::string name;
std::string value;
while (ch != eof && ch != '=' && ch != '&')
{
if (ch == '+') ch = ' ';
name += (char) ch;
ch = istr.get();
}
if (ch == '=')
{
ch = istr.get();
while (ch != eof && ch != '&')
{
if (ch == '+') ch = ' ';
value += (char) ch;
ch = istr.get();
}
}
std::string decodedName;
std::string decodedValue;
URI::decode(name, decodedName);
URI::decode(value, decodedValue);
add(decodedName, decodedValue);
++fields;
if (ch == '&') ch = istr.get();
}
}
void HTMLForm::readMultipart(std::istream& istr, PartHandler& handler)
{
static const int eof = std::char_traits<char>::eof();
MultipartReader reader(istr, _boundary);
while (reader.hasNextPart())
{
MessageHeader header;
reader.nextPart(header);
std::string disp;
NameValueCollection params;
if (header.has("Content-Disposition"))
{
std::string cd = header.get("Content-Disposition");
MessageHeader::splitParameters(cd, disp, params);
}
if (params.has("filename"))
{
handler.handlePart(header, reader.stream());
// Ensure that the complete part has been read.
while (reader.stream().good()) reader.stream().get();
}
else
{
std::string name = params["name"];
std::string value;
std::istream& istr = reader.stream();
int ch = istr.get();
while (ch != eof)
{
value += (char) ch;
ch = istr.get();
}
add(name, value);
}
}
}
void JSSPageReader::nextToken(std::istream& istr, std::string& token)
{
token.clear();
int ch = istr.get();
if (ch != -1)
{
if (ch == '<' && istr.peek() == '%')
{
token += "<%";
ch = istr.get();
ch = istr.peek();
switch (ch)
{
case '%':
case '@':
case '=':
ch = istr.get();
token += (char) ch;
break;
case '!':
ch = istr.get();
token += (char) ch;
if (istr.peek() == '!')
{
ch = istr.get();
token += (char) ch;
}
break;
case '-':
ch = istr.get();
token += (char) ch;
if (istr.peek() == '-')
{
ch = istr.get();
token += (char) ch;
}
break;
}
}
else if (ch == '%' && istr.peek() == '>')
{
token += "%>";
ch = istr.get();
}
else token += (char) ch;
}
}
// style prompts for and accepts the style from input stream is
//
bool style(std::istream& is, char& s) {
bool rc = false, ok = false;
char c;
do {
std::cout << " EAN Style ('-', ' ', '\\n' or '0' to quit) : ";
c = ' ';
is.get(c);
if (is.fail()) {
is.clear();
is.ignore(2000, '\n');
std::cerr << " Invalid input. Try again.\n";
} else if (c != '-' && c != ' ' && c != '\n' && c != '0') {
is.ignore(2000, '\n');
std::cerr << " Invalid Character. Try again.\n";
} else if (c == '0') {
if (is.get() != '\n') {
is.ignore(2000, '\n');
std::cerr << " Trailing Characters. Try Again.\n";
} else {
ok = true;
}
} else if (c == '\n') {
ok = true;
s = '\0';
rc = true;
} else if (is.get() != '\n') {
is.ignore(2000, '\n');
std::cerr << " Trailing Characters. Try Again.\n";
} else if (c == '-' || c == ' ') {
ok = true;
s = c;
rc = true;
}
} while (!ok);
return rc;
}
/** returns inner content of a quoted string
* Matches pattern "[^"]*"\s* and returns matching part without quotes
*
*/
std::string
configparBase::parse_quoted_string(std::istream &in) {
if ( in.get() != '"' )
throw configParExceptionParseError("string doesn't start with a quotation mark");
bool escape = false;
std::string tmp;
char c;
while ( in.get(c) ) {
if ( escape ) {
if ( c == '\\' || c == '"' )
tmp += c;
else
throw configParExceptionParseError("invalid escape sequence");
escape = false;
}
else {
if ( c == '"' )
break;
else if ( c == '\\' )
escape = true;
else
tmp += c;
}
}
// we should be on the closing quotation mark
if ( c != '"' )
throw configParExceptionParseError("unterminated string");
skip_rest_of_line(in);
return tmp;
}
bool GetField(std::istream &is, std::string &name, std::string &value)
{
name.resize(0); // GCC workaround: 2.95.3 doesn't have clear()
is >> name;
if (name.empty())
return false;
if (name[name.size()-1] != ':')
SignalTestError();
name.erase(name.size()-1);
while (is.peek() == ' ')
is.ignore(1);
// VC60 workaround: getline bug
char buffer[128];
value.resize(0); // GCC workaround: 2.95.3 doesn't have clear()
bool continueLine;
do
{
do
{
is.get(buffer, sizeof(buffer));
value += buffer;
}
while (buffer[0] != 0);
is.clear();
is.ignore();
if (!value.empty() && value[value.size()-1] == '\r')
value.resize(value.size()-1);
if (!value.empty() && value[value.size()-1] == '\\')
{
value.resize(value.size()-1);
continueLine = true;
}
else
continueLine = false;
std::string::size_type i = value.find('#');
if (i != std::string::npos)
value.erase(i);
}
while (continueLine);
return true;
}
// Parses a string serialized by serializeJsonStringIfNeeded.
static std::string deSerializeJsonStringIfNeeded(std::istream &is)
{
std::ostringstream tmp_os;
bool expect_initial_quote = true;
bool is_json = false;
bool was_backslash = false;
for(;;)
{
char c = is.get();
if(is.eof())
break;
if(expect_initial_quote && c == '"')
{
tmp_os << c;
is_json = true;
}
else if(is_json)
{
tmp_os << c;
if(was_backslash)
was_backslash = false;
else if(c == '\\')
was_backslash = true;
else if(c == '"')
break; // Found end of string
}
else
{
if(c == ' ')
{
// Found end of word
is.unget();
break;
}
else
{
tmp_os << c;
}
}
expect_initial_quote = false;
}
if(is_json)
{
std::istringstream tmp_is(tmp_os.str(), std::ios::binary);
return deSerializeJsonString(tmp_is);
}
else
return tmp_os.str();
}
static std::string goto_first_of(std::istream& s, const std::string& str)
{
std::string result;
char c;
while (s.get(c))
{
if (str.find(c) != std::string::npos)
{
break;
}
result += c;
}
return result;
}
void read_with_limit(
std::istream& in,
std::string& buffer,
int delim = '\n'
)
{
using namespace std;
const size_t max = 16*1024;
buffer.clear();
buffer.reserve(300);
while (in.peek() != delim && in.peek() != EOF && buffer.size() < max)
{
buffer += (char)in.get();
}
// if we quit the loop because the data is longer than expected or we hit EOF
if (in.peek() == EOF || buffer.size() == max)
throw http_parse_error("HTTP field from client is too long", 414);
// Make sure the last char is the delim.
if (in.get() != delim)
{
in.setstate(ios::badbit);
buffer.clear();
}
else
{
// Read the remaining delimiters
if (delim == ' ')
{
while (in.peek() == ' ')
in.get();
}
}
}
std::map<char, long long> readHuffmanHeader(std::istream &inFile, int *validBitsLastByte) {
long long length, frequency;
char space, character, space2, algorithm;
map<char, long long> char_freq;
inFile >> skipws;
inFile >> (*validBitsLastByte);
if (DEBUG) cout << " + validBitsLastByte: " << *validBitsLastByte <<endl;
inFile >> length;
if (DEBUG) cout << " + length: " << length << endl;
inFile.get(space);
if (DEBUG) cout << " - It was suppose to be a space: [" << space << "]\n";
for (int i = 0; i < length; i++) {
inFile.get(character);
inFile.get(space);
inFile >> frequency;
inFile.get(space2);
if (DEBUG) cout << "character: " << character << ", space: "<< space << ", frequency: "<< frequency << ", space2: " << space2 <<endl;
if (DEBUG) cout << "char_freq["<<character<<"] : " << frequency << endl;
char_freq[character] = frequency;
}
return char_freq;
}
void
PinConfigInfoPacket::read(
std::istream& inputStream
)
{
int pin;
int direction;
pin = inputStream.get();
if (inputStream.good() != true)
{
return;
}
myPin = (unsigned int)pin;
direction = inputStream.get();
if (inputStream.good() != true)
{
return;
}
myDirection = ((direction == 1) ? DIR_OUTPUT : DIR_INPUT);
inputStream.get();
}
// throw an exception if the rest of the line doesn't only contain whitespace or a comment starting with #
void
configparBase::skip_rest_of_line(std::istream &in) {
char c;
bool ignore= false;
while ( in.get(c) ) {
if (ignore)
continue;
else
if (c == '#')
ignore= true;
else
if ( c != ' ' && c != '\t' )
throw configParExceptionParseError("junk after value");
}
}
bool putback_test_one(std::istream& is)
{
try {
do {
char buf[chunk_size];
is.read(buf, chunk_size);
if (is.gcount() < static_cast<std::streamsize>(chunk_size))
break;
is.putback('a');
if (is.get() != 'a')
return false;
} while (!is.eof());
return true;
} catch (std::exception&) { return false; }
}
load_line_ret load_line(std::string& s, std::istream& is) {
s.erase();
if (is.bad()|| is.eof())
return FOUND_EOF;
char c;
while (is.get(c)) {
if (c == '\n')
return FOUND_NL;
if (c != '\r')
s.append(1, c);
}
return FOUND_END;
}
bool get_word(std::string& output_string, std::istream& input_stream)
{
skip_emptyspace(input_stream);
char c = input_stream.peek();
while ( !isspace(c)
&& '\n' != c
&& '\r' != c
&& input_stream.good() )
{
output_string += c;
input_stream.get();
c = input_stream.peek();
}
return input_stream.good();
}
bool input(std::istream &in, std::string fmt)
{
// Just match fmt
for(unsigned i = 0; i < fmt.size(); ++i)
{
char c;
in.get(c);
if(c != fmt[i])
{
in.setstate(std::ios::failbit);
return false;
}
}
}
std::string parseEscapeSequence(std::istream& ss) {
auto ch = ss.get();
switch (ch) {
case '"': return "\"";
case '\\': return "\\";
case '/': return "/";
case 'b': return "\b";
case 'f': return "\f";
case 'n': return "\n";
case 'r': return "\r";
case 't': return "\t";
case 'u': return parseUnicodeEscapeSequence(ss);
default: throw ParseError(std::string("unexpected escape sequence: '\\")+char(ch)+"'");
}
}
void parser::parse_expr( std::istream &in )
{
precondition( in.get() == '[', "missing '[' to start expression" );
int count = 0;
while ( !in.eof() && in )
{
int c = in.get();
if ( std::char_traits<char>::not_eof( c ) )
{
if ( c == ']' )
{
if ( count == 0 )
{
_func.push_expr();
break;
}
_func.add( static_cast<char>( c ) );
--count;
}
else if ( c == '[' )
{
_func.add( static_cast<char>( c ) );
++count;
}
else if ( c == '"' )
{
_func.add( static_cast<char>( c ) );
parse_string( in );
}
else
_func.add( static_cast<char>( c ) );
}
}
if ( in.get() != ']' )
throw_runtime( "missing ']' in expression" );
}
// does the work for the keychange
void keyChange(std::istream& input)
{
//input.get(); // forward 1;
while(input)
{
char note;
input >> note;// = input.get();
if(!input)
break;
const char nextChar = input.get();
// input >> nextChar;// = input.get();
if (nextChar == 'b') // flatten
{
setNote(note, FLAT);
//input.get(); // forward 1 to skip space
continue;
}
else if(nextChar == '#') // sharpen
{
setNote(note, SHARP);
//input.get(); // forward 1 to skip space
continue;
}
// now nextChar can only equal space
else if (!std::isspace(nextChar))
{
std::cout << "Unrecognised character of '" << nextChar << "' in keychage.\n";
return;
}
const char thirdChar = input.peek();
if (std::isdigit(thirdChar)) // a pitch is being set
{
double newFreq;
input >> newFreq;
if(input.fail())
{
std::cout << "Failed to read frequency in keychange.\n";
return;
}
//input.get(); // forward 1
setNote(note,newFreq);
}
else // must be reseting to natural
{
setNote(note,NATURAL);
continue;
}
}
inline bool
AsciiXmlParser::readCharacter()
/* this reads the next character from textStream into currentChar &
* increments readNewlines if currentChar was '\n', returning
* textStream->good().
*/
{
streamIsGood = textStream->get( currentChar ).good();
if( streamIsGood
&&
( '\n' == currentChar ) )
{
++readNewlines;
}
return streamIsGood;
}
// This puts the next character from xmlStream into currentChar, then puts
// it into destinationForReadCharacters if it is not NULL, then returns
// true, unless no character could be read, in which case false is
// returned.
inline bool RestrictedXmlParser::ReadCharacter(
std::ostream* destinationForReadCharacter )
{
if( xmlStream->get( currentCharacter ).good() )
{
if( destinationForReadCharacter != NULL )
{
(*destinationForReadCharacter) << currentCharacter;
}
return true;
}
else
{
return false;
}
}
InputFormat Input_t::detectFormat(std::istream& in) {
std::istream::int_type x = std::char_traits<char>::eof();
while (in && (x = in.peek()) != std::char_traits<char>::eof()) {
unsigned char c = static_cast<unsigned char>(x);
if (c >= '0' && c <= '9') return Problem_t::LPARSE;
if (c == 'c' || c == 'p') return Problem_t::DIMACS;
if (c == '*') return Problem_t::OPB;
if (c == ' ' || c == '\t') { in.get(); continue; }
break;
}
char msg[] = "'c': Unrecognized input format!\n";
msg[1] = (char)(unsigned char)x;
in && x != std::char_traits<char>::eof()
? throw ParseError(1, msg)
: throw ParseError(0, "Bad input stream!\n");
}
std::string ObjectFactory::GetValue(std::istream& iStream)
{
char ch = '\0';
std::string sValue;
while (ch != '<' && iStream.good())
{
iStream.get(ch);
if (ch!='<')
sValue += ch;
}
if (ch=='<') iStream.putback(ch);
return sValue;
}
void ReadForCharacter(char value, std::istream& stream)
{
for (;;)
{
char ch = 0;
stream.get(ch);
if (value == ch)
{
break;
}
if (0 == ch)
{
throw runtime_error("ReadForCharacter() end of stream has been reached");
}
}
}
void compressAdaptive(std::istream& in, std::ostream& out) {
const char* header = "AC\x00";
out.write(header, 3);
ArithmeticEncoder encoder(std::make_shared<BitStreamWriter>(&out));
AdaptiveDataModel dataModel(NUM_SYMBOLS);
for (;;) {
int c = in.get();
if (c == std::char_traits<char>::eof()) {
encoder.encode(NUM_SYMBOLS - 1, &dataModel);
break;
}
encoder.encode(c, &dataModel);
}
}
void HTTPBodyResultMapper::ReadBody(String &body, std::istream &is, Context &ctx) {
StartTrace(HTTPBodyResultMapper.ReadBody);
long contentLength = ctx.Lookup("Mapper.content-length", -1L);
Trace("contentLength: " << contentLength);
if (contentLength > -1) {
body.Append(is, contentLength);
} else {
char c;
while (is.get(c).good()) {
body.Append(c);
}
}
Trace("Body[" << body.Length() << "]");
Trace("<" << body << ">");
}
static Value eatNumeric(std::istream& stream, char firstChar)
{
std::string numeric(1, firstChar);
while (!stream.eof())
{
char token = stream.peek();
if ((token >= '0' && token <= '9') || token == '.' || token == '-' || token == 'E')
numeric += stream.get();
else
break;
}
if (numeric.find('.') == std::string::npos)
return Value(atoi(numeric.c_str()));
else
return Value((float)atof(numeric.c_str()));
};