inline void readVectorData(std::istream& is, std::vector<T>& data)
{
data.clear();
while (is) {
T candidate;
is >> candidate;
if (is.rdstate() & std::ios::failbit) {
is.clear(is.rdstate() & ~std::ios::failbit);
is >> ignoreWhitespace;
char dummy;
is >> dummy;
if (dummy == '/') {
is >> ignoreLine;
break;
} else if (dummy == '-') { // "comment test"
int
GA3DBinaryStringGenome::read(std::istream & is)
{
static char c;
unsigned int i=0, j=0, k=0;
do{
is >> c;
if(isdigit(c)){
gene(i++, j, k, ((c == '0') ? 0 : 1));
if(i >= nx){
i=0;
j++;
}
if(j >= ny){
j=0;
k++;
}
}
} while(!is.fail() && !is.eof() && k < nz);
_evaluated = gaFalse;
if(is.eof() &&
((k < nz) || // didn't get some lines
(j < ny && j != 0) || // didn't get some lines
(i < nx && i != 0))){ // didn't get some lines
GAErr(GA_LOC, className(), "read", gaErrUnexpectedEOF);
is.clear(std::ios::badbit | is.rdstate());
return 1;
}
return 0;
}
void set(std::istream& in, std::ostream& out, std::ostream& err) {
if (not activated) {
using namespace std;
in_buf = cin.rdbuf(); out_buf = cout.rdbuf(); err_buf = cerr.rdbuf();
in_state = cin.rdstate(); out_state = cin.rdstate(); err_state = cerr.rdstate();
cin.rdbuf(in.rdbuf()); cout.rdbuf(out.rdbuf()); cerr.rdbuf(err.rdbuf());
cin.exceptions(ios_base::goodbit); cout.exceptions(ios_base::goodbit); cerr.exceptions(ios_base::goodbit);
cin.clear(in.rdstate()); cout.clear(out.rdstate()); cerr.clear(err.rdstate());
}
}
bool checkFileState(std::istream& unbuiltFile, std::istream& builtFile) {
// check for the stream state flags
if (unbuiltFile.eof()) {
if (! builtFile.eof()) {
throw runtime_error("unbuilt file contains more data than unbuilt");
}
}
if (builtFile.eof()) {
if (! unbuiltFile.eof()) {
throw runtime_error("built file contains more data than unbuilt");
}
}
if (unbuiltFile.rdstate()!=0 && !unbuiltFile.eof()) {
throw runtime_error("Unbuilt file has error state");
}
if (builtFile.rdstate()!=0 && ! builtFile.eof()) {
throw runtime_error("Built file has error state");
}
return (builtFile.eof() || unbuiltFile.eof());
}
std::vector<Point> Calibrator::loadPoints(std::istream &in) {
std::vector<Point> result;
for(;;) {
double x, y;
in >> x >> y;
if (in.rdstate()) {
// break if any error
break;
}
result.push_back(Point(x, y));
}
return result;
}
/*!
* \brief Check for a failure during the last stream input.
*
* If the last stream input did not succeed, throws an exception with
* details on the stream position where this occurred.
*/
void check_failedload(std::istream &is)
{
if (is.fail())
{
std::ios::iostate state = is.rdstate();
is.clear();
std::ostringstream sout;
sout << "Failure loading object at position " << is.tellg()
<< ", next line:" << std::endl;
std::string s;
getline(is, s);
sout << s;
is.clear(state);
throw load_error(sout.str());
}
}
xml_lmi::dom_parser::dom_parser(std::istream const& is)
{
try
{
error_context_ = "Unable to parse xml stream: ";
if(0 != is.rdstate())
{
throw std::runtime_error("Stream state is not 'good'.");
}
std::string s;
istream_to_string(is, s);
parser_.reset(new DomParser(s.c_str(), 1 + s.size()));
}
catch(std::exception const& e)
{
fatal_error() << error_context_ << e.what() << LMI_FLUSH;
}
}
bool VersionedFileHeader::read_known( VFH_Type i_type, std::istream &io_istream )
{
// save stream state and position
streampos pos = io_istream.tellg();
ios_base::iostate state = io_istream.rdstate();
if ( !read_raw( io_istream ) ||
m_magicNumber!=(isMSBF()?g_versioned_headers_list[i_type].magic_number_MSBF:g_versioned_headers_list[i_type].magic_number_LSBF) )
{
// reading failed, rewind to starting point and reset error flags
io_istream.seekg( pos );
io_istream.setstate( state );
m_magicNumber = m_version = 0;
m_isMSBF = MSBF_PROCESSOR();
return false;
}
return true;
}
bool VersionedFileHeader::read_unknown( std::istream &io_istream, VFH_Type &o_id )
{
// save stream state and position
streampos pos = io_istream.tellg();
ios_base::iostate state = io_istream.rdstate();
bool isMSBF_; // from magic number
if ( !read_raw( io_istream ) ||
!typeFromMagicNumber(m_magicNumber, o_id, isMSBF_) ||
isMSBF_!=isMSBF() )
{
// reading failed, rewind to starting point and reset error flags
io_istream.seekg( pos );
io_istream.setstate( state );
return false;
}
return true;
}
void Date::read(std::istream& in) {
int in_day { }, in_month { }, in_year { };
char sep1 { }, sep2 { };
in >> in_day >> sep1 >> in_month >> sep2 >> in_year;
if (isValidDate(1,1,1)) //should be (isValidYear(in_day))
std::swap(in_day, in_year);
if (in_year >= 0 && in_year < 100)
in_year += 2000;
if (!in.fail() && sep1 == sep2
&& (sep1 == '.' || sep1 == '/' || sep1 == '-')
&& isValidDate(in_year, in_month, in_day)) {
year = in_year;
month = in_month;
day = in_day;
} else {
in.setstate(std::ios::failbit | in.rdstate());
}
}
int GA1DArrayAlleleGenome<char>::read(std::istream & is)
{
unsigned int i = 0;
char c;
do
{
is.get(c);
if(!is.fail())
{
gene(i++, c);
}
}
while(!is.fail() && !is.eof() && i < nx);
if(is.eof() && i < nx)
{
GAErr(GA_LOC, className(), "read", gaErrUnexpectedEOF);
is.clear(std::ios::badbit | is.rdstate());
return 1;
}
return 0;
}
/// The read specialization takes in each number and stuffs it into the array.
template <> int
GA1DArrayAlleleGenome<float>::read(std::istream & is)
{
unsigned int i = 0;
float val;
do
{
is >> val;
if(!is.fail())
{
gene(i++, val);
}
}
while(!is.fail() && !is.eof() && i < nx);
if(is.eof() && i < nx)
{
GAErr(GA_LOC, className(), "read", gaErrUnexpectedEOF);
is.clear(std::ios::badbit | is.rdstate());
return 1;
}
return 0;
}
std::ostream& operator<<(std::ostream& out, const ostrstream& x) {
out << static_cast<strstreambuf*>(x.rdbuf())->str();
return out;
}
class istrstream : public std::istream {
strstreambuf sb;
public:
istrstream(char* buf) : sb(buf) { }
template<class T>
istrstream& operator>>(T& x) {
std::istream in(&sb);
in.copyfmt(*this);
in >> x;
setstate(in.rdstate());
return *this;
}
};
}
int main() {
using namespace std;
using namespace ch21;
char buf[1024];
ostrstream out(buf, 1024);
out << "foo bar " << 12345;
cout << out << endl;
istrstream in(buf);
int32_t vtkReadBinaryData(std::istream& in, T* data, int32_t numTuples, int32_t numComp)
{
if (numTuples == 0 || numComp == 0)
{
// nothing to read here.
return 1;
}
size_t numBytesToRead = static_cast<size_t>(numTuples) * static_cast<size_t>(numComp) * sizeof(T);
size_t numRead = 0;
// Cast our pointer to a pointer that std::istream will take
char* chunkptr = reinterpret_cast<char*>(data);
numRead = 0;
// Now start reading the data in chunks if needed.
size_t chunkSize = DEFAULT_BLOCKSIZE;
// Sanity check the chunk size to make sure it is not any larger than the chunk of data we are about to read
if (numBytesToRead < DEFAULT_BLOCKSIZE)
{
chunkSize = numBytesToRead;
}
size_t master_counter = 0;
size_t bytes_read = 0;
// Now chunk through the file reading up chunks of data that can actually be
// read in a single read. DEFAULT_BLOCKSIZE will control this.
while(1)
{
in.read(chunkptr, chunkSize);
bytes_read = in.gcount();
chunkptr = chunkptr + bytes_read;
master_counter += bytes_read;
if (numBytesToRead - master_counter < chunkSize)
{
chunkSize = numBytesToRead - master_counter;
}
if (master_counter >= numBytesToRead)
{
break;
}
if (in.good())
{
//std::cout << "all data read successfully." << in.gcount() << std::endl;
}
if ((in.rdstate() & std::ifstream::failbit) != 0)
{
std::cout << "FAIL " << in.gcount() << " could be read. Needed " << chunkSize << " total bytes read = " << master_counter << std::endl;
return -12020;
}
if ((in.rdstate() & std::ifstream::eofbit) != 0)
{
std::cout << "EOF " << in.gcount() << " could be read. Needed " << chunkSize << " total bytes read = " << master_counter << std::endl;
return -12021;
}
if ((in.rdstate() & std::ifstream::badbit) != 0)
{
std::cout << "BAD " << in.gcount() << " could be read. Needed " << chunkSize << " total bytes read = " << master_counter << std::endl;
return -12021;
}
}
return 0;
}