// TODO: Set dimension labels
// DataIO_Std::ReadData()
int DataIO_Std::ReadData(FileName const& fname,
DataSetList& dsl, std::string const& dsname)
{
int err = 0;
switch ( mode_ ) {
case READ1D:
err = Read_1D(fname.Full(), dsl, dsname);
if (err == IS_ASCII_CMATRIX)
err = ReadCmatrix(fname, dsl, dsname);
break;
case READ2D: err = Read_2D(fname.Full(), dsl, dsname); break;
case READ3D: err = Read_3D(fname.Full(), dsl, dsname); break;
case READVEC: err = Read_Vector(fname.Full(), dsl, dsname); break;
case READMAT3X3: err = Read_Mat3x3(fname.Full(), dsl, dsname); break;
}
return err;
}
int bbcp_File::Read_All(bbcp_BuffPool &inPool, int Vn)
{
bbcp_FileChkSum *csP = 0;
bbcp_BuffPool *outPool;
bbcp_Buffer *bP;
pthread_t tid;
int rc = 0;
// Get the size of the file
//
if ((bytesLeft = FSp->getSize(IOB->FD())) < 0)
{bbcp_Emsg("Read", static_cast<int>(-bytesLeft), "stat", iofn);
inPool.Abort(); return 200;
}
// Adjust bytes left based on where we will be reading from
//
bytesLeft -= nextoffset;
if (bytesLeft < 0)
{bbcp_Emsg("Read", ESPIPE, "stat", iofn);
inPool.Abort(); return 200;
}
// If this is a real-time copy operation, start the rtcopy object
//
if (rtCopy && !bbcp_RTCopy.Start(FSp, iofn, IOB->FD()))
{inPool.Abort(); return 200;
}
// Set up checksumming. We would prefer to do this in the calling thread but
// this is easier. One day we will generalize buffer piping.
//
if (bbcp_Config.csOpts & bbcp_csVerIn)
{csP = new bbcp_FileChkSum(&inPool, this, bbcp_Config.csType,
bbcp_Config.csOpts & bbcp_csVerIO);
if ((rc = bbcp_Thread_Start(bbcp_FileCSX, (void *)csP, &tid)) < 0)
{bbcp_Emsg("File", rc, "starting file checksum thread.");
delete csP;
if (rtCopy) bbcp_RTCopy.Stop();
inPool.Abort(); return 201;
}
outPool = &csP->csPool;
} else outPool = &inPool;
// Establish logging options
//
if (bbcp_Config.Options & bbcp_LOGRD) IOB->Log("DISK", 0);
// Determine what kind of reading we will do here and do it
//
// cerr <<"BLOCKSIZE " <<blockSize <<endl;
if (blockSize ) rc = Read_Direct(&inPool, outPool);
else rc=(Vn > 1 ? Read_Vector(&inPool, outPool, Vn)
: Read_Normal(&inPool, outPool));
// Delete the real-time copy object if we have one to kill possible thread
//
if (rtCopy) bbcp_RTCopy.Stop();
// Check if we ended because with an error
//
IOB->Close();
if (rc && rc != -ENOBUFS) bbcp_Emsg("Read", -rc, "reading", iofn);
// Prepare an empty buffer to shutdown the buffer pipeline. The offet indicates
// how much data should have been sent and received. A negative offset implies
// that we encountered an error.
//
if (!(bP = inPool.getEmptyBuff())) return 255;
bP->blen = 0;
bP->boff = (rc ? -1 : nextoffset);
// Verify check sum if so wanted. Note that is link-level check summing is in
//
if (csP)
{csP->csPool.putFullBuff(bP);
bbcp_Thread_Wait(tid);
if (!rc && *bbcp_Config.csString)
{char *csTxt, *csVal = csP->csObj->Final(&csTxt);
if (memcmp(csVal, bbcp_Config.csValue, csP->csObj->csSize()))
{bbcp_Fmsg("Read", iofn, "source checksum", bbcp_Config.csString,
"does not match", csTxt);
rc = EILSEQ;
} else {DEBUG(csP->csObj->Type() <<": " <<csTxt <<' ' <<iofn);}
}
delete csP;
} else inPool.putFullBuff(bP);
// All done
//
DEBUG("EOF offset=" <<nextoffset <<" rc=" <<rc <<" fn=" <<iofn);
return rc;
}
