bool ZipArchive::writeCentralDirectory(std::ofstream& ofs,
const std::vector<ZipArchive::ArchivedFile>& files)
{
std::streampos offsetCD = ofs.tellp();
size_t sizeCD = 0;
bool error = false;
for (size_t i = 0; i < files.size(); ++i) {
const ZipFileHeader& fileHeader = files[i].zipFileHader_;
ofs.write(reinterpret_cast<const char*>(&fileHeader), SIZE_ZIPFILEHEADER);
sizeCD += SIZE_ZIPFILEHEADER;
error = ofs.fail();
size_t stringSize = files[i].fileName_.size();
sizeCD += stringSize;
if ((error == false) && (stringSize > 0) && (stringSize == fileHeader.filenameLength)) {
ofs.write(files[i].fileName_.c_str(), stringSize);
error = ofs.fail();
}
stringSize = files[i].fileExtra_.size();
sizeCD += stringSize;
if ((error == false) && (stringSize > 0) && (stringSize == fileHeader.extraFieldLength)) {
ofs.write(files[i].fileExtra_.c_str(), stringSize);
error = ofs.fail();
}
stringSize = files[i].fileComment_.size();
sizeCD += stringSize;
if ((error == false) && (stringSize > 0) && (stringSize == fileHeader.fileCommentLength)) {
ofs.write(files[i].fileComment_.c_str(), stringSize);
error = ofs.fail();
}
if (error == true) {
LERROR("writeCentralDirectory(): failed to write Central Directory Entry in zip archive!");
break;
}
} // for
ZipEOCDHeaderRecord eocd;
eocd.signature = SIGNATURE_ZIPEOCDHEADERRECORD;
eocd.numberOfDisk = 0;
eocd.numberOfDiskWithStartOfCD = 0;
eocd.numberOfEntriesInThisCD = static_cast<uint16_t>(files.size());
eocd.numberOfEntriesInCD = static_cast<uint16_t>(files.size());
eocd.sizeOfCD = static_cast<uint32_t>(sizeCD);
eocd.offsetStartCD = (offsetCD >= 0) ? static_cast<uint32_t>(offsetCD) : 0;
eocd.commmentLength = 0;
if (error == false) {
ofs.write(reinterpret_cast<char*>(&eocd), SIZE_ZIPEOCDRECORD);
error = ofs.fail();
}
return (! error);
}
void cineon_writer_t::write_pixels( std::ofstream& out, const image::const_image_view_t& view) const
{
std::vector<boost::uint32_t> buffer( view.width());
for( int y = 0; y < view.height(); ++y)
{
image::const_image_view_t::x_iterator src_it( view.row_begin( y));
for( int x = 0; x < view.width(); ++x)
{
boost::uint32_t pix = 0;
float r = boost::gil::get_color( *src_it, boost::gil::red_t());
float g = boost::gil::get_color( *src_it, boost::gil::green_t());
float b = boost::gil::get_color( *src_it, boost::gil::blue_t());
boost::uint32_t ri = adobe::clamp( r, 0.0f, 1.0f) * 1023;
boost::uint32_t gi = adobe::clamp( g, 0.0f, 1.0f) * 1023;
boost::uint32_t bi = adobe::clamp( b, 0.0f, 1.0f) * 1023;
pix = ( ri << 22) | ( gi << 12) | ( bi << 2);
buffer[x] = IECore::asBigEndian( pix);
++src_it;
}
// write vector
out.write( reinterpret_cast<char *>( &buffer[0]), view.width() * sizeof( boost::uint32_t));
if ( out.fail())
throw exception( "error while writting image");
}
}
/*---------------------------------------------------------*/
bool NOMAD::Cache_File_Point::write(std::ofstream &fout) const
{
// do nothing if no point:
if (_n <= 0)
return true;
// 1. _eval_status:
fout.write((char *) &_eval_status , sizeof(_eval_status));
// 2. _n:
fout.write((char *) &_n , sizeof(_n));
// 3. _m:
fout.write((char *) &_m , sizeof(_m));
// 4. _m_def:
fout.write((char *) &_m_def , sizeof(_m_def));
// 5. _coords:
fout.write((char *) _coords , _n*sizeof(double));
if (_m_def > 0)
{
// 6. _bbo_def:
fout.write((char *) _bbo_def , _m_def*sizeof(double));
// 7. _bbo_index:
fout.write((char *) _bbo_index , _m_def*sizeof(int));
}
return !fout.fail();
}
void openOutputFile(std::ofstream& s, std::string path){
s.open(path);
if(s.fail()){
std::cerr << "Failure opening file \"" << path << "\" for output." << std::endl;
exit(0);
}
}
bool File::write(std::ofstream& stream)
{
CwdGuard cg(physical_dir_);
stream.open(ACE_TEXT_ALWAYS_CHAR(physical_file_.c_str()),
ios::binary | ios::out);
return !stream.bad() && !stream.fail();
}
bool redirect_cout (const std::string& fn)
{
static std::ofstream alt_cout;
alt_cout.open (fn.c_str(), std::ios::out | std::ios::binary);
if (alt_cout.fail() ) return false;
std::cout.rdbuf (alt_cout.rdbuf() );
return true;
}
std::string openFileDialog(std::ofstream& stream,
const std::string& title,
const std::string& path) {
std::string filename = pp->file_openFileDialog(title, "save", path);
if (filename == "") return "";
stream.open(filename.c_str());
return (stream.fail()) ? "" : filename;
}
int Path::write(std::ofstream &out, std::string &msg)
{
short record_size;
record_size = 4;
writeShort(out, record_size);
writeByte(out, PATH);
writeByte(out, NoData);
record_size = 6;
writeShort(out, record_size);
writeByte(out, EFLAGS);
writeByte(out, Integer_2);
writeShort(out, Eflags);
record_size = 6;
writeShort(out, record_size);
writeByte(out, LAYER);
writeByte(out, Integer_2);
writeShort(out, Layer);
record_size = 6;
writeShort(out, record_size);
writeByte(out, DATATYPE);
writeByte(out, Integer_2);
writeShort(out, Data_type);
record_size = 8;
writeShort(out, record_size);
writeByte(out, WIDTH);
writeByte(out, Integer_4);
writeInteger(out, Width);
record_size = 6;
writeShort(out, record_size);
writeByte(out, PATHTYPE);
writeByte(out, Integer_2);
writeShort(out, Path_type);
record_size = 4 + short(8 * Pts.size());
writeShort(out, record_size);
writeByte(out, XY);
writeByte(out, Integer_4);
for (auto p : Pts)
{
writeInteger(out, p.x);
writeInteger(out, p.y);
}
record_size = 4;
writeShort(out, record_size);
writeByte(out, ENDEL);
writeByte(out, NoData);
return out.fail() ? FILE_ERROR : 0;
}
void _LogAppenderBase::open()
{
if (out.is_open())
{
return;
}
makeLogDir();
out.open(context.path.c_str(), std::fstream::out | std::fstream::app);
if (out.fail())
{
out.open(context.path.c_str(), std::fstream::out | std::fstream::app);
if (out.fail())
{
throw LOG_ER_OPEN;
}
}
}
void
OpenOFile(std::ofstream& fs, const char* filenm)
{
using namespace std;
fs.open(filenm, ios::out | ios::trunc);
if (!fs.is_open() || fs.fail()) {
DIAG_Throw("Cannot open file '" << filenm << "'");
}
}
int FileManagement::getLogStream(std::ofstream& logStream) {
log = logFileName + "/" + fname;
fullPath = log + ".debug";
logStream.open(log.c_str(), ios::app);
if (logStream.fail()) {
return errno;
} else {
chmod(log.c_str(), (mode_t) 0644);
return 0;
}
}
/*
* Open an ofstream with fully specified path and mode.
*/
void
FileMaster::open(const std::string& name, std::ofstream& out,
std::ios_base::openmode mode) const
{
out.open(name.c_str(), mode);
if (out.fail()) {
std::string message = "Error opening output file. Filename: ";
message += name;
UTIL_THROW(message.c_str());
}
}
/*!
Save an homography in a file.
The laod() function allows then to read and set the homography from this file.
\sa load()
*/
void
vpHomography::save(std::ofstream &f) const
{
if (! f.fail())
{
f << *this ;
}
else
{
throw(vpException(vpException::ioError, "Cannot write the homography to the output stream")) ;
}
}
void openStreamInto( Ptr<Config> const& config, std::ofstream& ofs ) {
// Open output file, if specified
if( !config->getFilename().empty() ) {
ofs.open( config->getFilename().c_str() );
if( ofs.fail() ) {
std::ostringstream oss;
oss << "Unable to open file: '" << config->getFilename() << "'";
throw std::domain_error( oss.str() );
}
config->setStreamBuf( ofs.rdbuf() );
}
}
/*!
Save the pose vector in the output file stream.
\param f : Output file stream. Should be open before entering in this method.
\exception vpException::ioError : If the output stream is not open.
\sa load()
*/
void
vpPoseVector::save(std::ofstream &f) const
{
if (! f.fail())
{
f << *this ;
}
else
{
vpERROR_TRACE("\t\t file not open " );
throw(vpException(vpException::ioError, "\t\t file not open")) ;
}
}
std::string promptUserForFile(std::ofstream &outFile, std::string prompt) {
while (true) {
std::cout << prompt;
std::string fileName;
getline(std::cin, fileName);
outFile.open(fileName.c_str());
if (!outFile.fail()) return fileName;
outFile.clear();
std::cout << "Unable to open that file. Try again." << std::endl;
if (prompt == "") prompt = "Output file: ";
}
}
void fstreamWriteBig(std::ofstream &S, char* A, unsigned long long N, std::string fileName, std::string errorID, Parameters *P) {
struct statvfs statvfsBuf;
statvfs(fileName.c_str(), &statvfsBuf);
P->inOut->logMain << "Writing " << N << " bytes into " <<fileName << " ; empty space on disk = " << statvfsBuf.f_bavail * statvfsBuf.f_bsize <<" bytes ..." <<flush;
unsigned long long C=0;
unsigned long long iC;
for (iC=0; iC<N/fstream_Chunk_Max; iC++) {
S.write(A+C,fstream_Chunk_Max);
C+=fstream_Chunk_Max;
};
if (!S.fail()) S.write(A+C,N%fstream_Chunk_Max);
if (S.fail()) {//failed to write
struct statvfs statvfsBuf;
statvfs(fileName.c_str(), &statvfsBuf);
// system(( "ls -lL "+ P->genomeDir + " > "+ P->genomeDir +"/error.info 2>&1").c_str());
// ifstream error_info((P->genomeDir +"/error.info").c_str());
// P->inOut->logMain <<error_info.rdbuf();
struct stat statBuf;
stat(fileName.c_str(), &statBuf);
remove(fileName.c_str());
ostringstream errOut;
errOut << errorID<<": exiting because of *OUTPUT FILE* error: could not write the output file "<< fileName <<"\n";
errOut << "fail()=" <<S.fail() <<" ; bad()="<< S.bad()<<"\n";
errOut << "Error while trying to write chunk # " << iC << "; "<< C << " bytes\n";
errOut << "File size full = "<< N <<" bytes\n";
errOut << "File size on disk = " << statBuf.st_size<<" bytes\n";
errOut << "Solution: check that you have enough space on the disk\n";
errOut << "Empty space on disk = " << statvfsBuf.f_bavail * statvfsBuf.f_bsize <<" bytes\n";
exitWithError(errOut.str(),std::cerr, P->inOut->logMain, EXIT_CODE_FILE_WRITE, *P);
};
P->inOut->logMain << " done\n" <<flush;
};
static void createTextFile(const std::string& filepath, std::ofstream& file){
#ifdef _WIN32
// WIN32 will create the wrong file names if we don't first convert them to UTF-16.
std::wstring_convert<std::codecvt_utf8<wchar_t>, wchar_t> converter;
std::wstring wide_path = converter.from_bytes(filepath);
file.open(wide_path, std::ios::out | std::ios::trunc);
#else
file.open(filepath, std::ios::trunc);
#endif
if (file.fail())
throw std::ios_base::failure(std::strerror(errno));
}
void pluginUnload()
{
if (notifyFrequency > 0)
{
if (writeToFile)
{
outFile.flush();
outFile << std::endl; //now all data are written to file
if (outFile.fail())
std::cerr << "Error on flushing file [" << filename << "]. " << std::endl;
outFile.close();
}
}
}
void file(const char *f)
{
exit();
if(f)
out.open(f);
if(out.fail())
{
std::cerr << "could not open output file '"
<< f << "'" << std::endl;
::exit(1);
}
s = &out;
reset();
}
/// Open the next file with given prefix. If one_file is false,
/// append _0, _1, etc. to the prefix for actual file name. If
/// one_file is true, the prefix is the file name. The first time
/// the file is open in trunc mode, the subsequent times in append
/// mode.
void open_next_file(const char *prefix, std::ofstream &out) {
std::ostringstream name;
name << prefix;
std::ios::openmode mode = std::ios::out;
if(one_file_) {
mode |= (index_++ ? std::ios::ate : std::ios::trunc);
} else {
name << index_++;
mode |= std::ios::trunc;
}
file_names_.push_back(name.str());
out.open(name.str().c_str());
if(out.fail())
eraise(ErrorWriting) << "'" << name.str() << "': "
<< "Can't open file for writing" << err::no;
}
// writes out the index list;
// 'top' indicates the vertex ordering and should be
// true for a polygon visible from above the PCB
bool VRML_LAYER::WriteIndices( bool aTopFlag, std::ofstream& aOutFile )
{
if( triplets.empty() )
{
error = "WriteIndices(): no triplets (triangular facets) to write";
return false;
}
// go through the triplet list and write out the indices based on order
std::list<TRIPLET_3D>::const_iterator tbeg = triplets.begin();
std::list<TRIPLET_3D>::const_iterator tend = triplets.end();
int i = 1;
if( aTopFlag )
aOutFile << tbeg->i1 << ", " << tbeg->i2 << ", " << tbeg->i3 << ", -1";
else
aOutFile << tbeg->i2 << ", " << tbeg->i1 << ", " << tbeg->i3 << ", -1";
++tbeg;
while( tbeg != tend )
{
if( (i++ & 7) == 4 )
{
i = 1;
if( aTopFlag )
aOutFile << ",\n" << tbeg->i1 << ", " << tbeg->i2 << ", " << tbeg->i3 << ", -1";
else
aOutFile << ",\n" << tbeg->i2 << ", " << tbeg->i1 << ", " << tbeg->i3 << ", -1";
}
else
{
if( aTopFlag )
aOutFile << ", " << tbeg->i1 << ", " << tbeg->i2 << ", " << tbeg->i3 << ", -1";
else
aOutFile << ", " << tbeg->i2 << ", " << tbeg->i1 << ", " << tbeg->i3 << ", -1";
}
++tbeg;
}
return !aOutFile.fail();
}
void inicializarSharedObjects(CajaRegistradora& caja, Grilla& grilla, GrillaJefe& grillaJefe, Surtidores& surtidores,
unsigned int cantEmpleados, unsigned int cantSurtidores,
std::ofstream& archivoColaInputJefe, ColaConPrioridad<automovil>& colaAutosJefe) {
caja.inicializarCaja();
grilla.inicializarGrilla(cantEmpleados);
grillaJefe.inicializarGrillaJefe();
surtidores.inicializarSurtidores(cantSurtidores);
if (archivoColaInputJefe.fail() || archivoColaInputJefe.bad()) {
std::string me = __FILE__ ":inicializarSharedObjects";
std::string _msg = std::string("Error creando archivo para la cola entre el jefe y el input: ") + std::string(strerror(errno));
Logger::error(_msg, me);
throw _msg;
}
// TODO: Ordenar la creacion de esta cola. Encapsularlo porque queda feito
colaAutosJefe = ColaConPrioridad<automovil> ( colaInputJefe, colaInputJefeKey );
}
// writes out the vertex list for a planar feature
bool VRML_LAYER::WriteVertices( double aZcoord, std::ofstream& aOutFile, int aPrecision )
{
if( ordmap.size() < 3 )
{
error = "WriteVertices(): not enough vertices";
return false;
}
if( aPrecision < 4 )
aPrecision = 4;
int i, j;
VERTEX_3D* vp = getVertexByIndex( ordmap[0], pholes );
if( !vp )
return false;
std::string strx, stry, strz;
FormatDoublet( vp->x + offsetX, vp->y + offsetY, aPrecision, strx, stry );
FormatSinglet( aZcoord, aPrecision, strz );
aOutFile << strx << " " << stry << " " << strz;
for( i = 1, j = ordmap.size(); i < j; ++i )
{
vp = getVertexByIndex( ordmap[i], pholes );
if( !vp )
return false;
FormatDoublet( vp->x + offsetX, vp->y + offsetY, aPrecision, strx, stry );
if( i & 1 )
aOutFile << ", " << strx << " " << stry << " " << strz;
else
aOutFile << ",\n" << strx << " " << stry << " " << strz;
}
return !aOutFile.fail();
}
bool OTASCIIArmor::SaveTo_ofstream(std::ofstream& fout)
{
String strOutput;
std::string str_type("DATA"); // -----BEGIN OT ARMORED DATA-----
if (WriteArmoredString(strOutput, str_type) && strOutput.Exists()) {
// WRITE IT TO THE FILE
//
fout << strOutput;
if (fout.fail()) {
otErr << __FUNCTION__ << ": Failed saving to file.\n Contents:\n\n"
<< strOutput << "\n\n";
return false;
}
return true;
}
return false;
}
//--- Open an output file.
//
// Note not under unit test.
//
bool openOutputFile(std::ofstream& fileStream, const char *const fileName, std::ios_base::openmode mode,
std::string& errStr)
{
//
// Start with a clean slate.
if( fileStream.is_open() )
fileStream.close();
fileStream.clear(std::ios_base::goodbit);
//
// Open file.
fileStream.open(fileName, mode);
if( fileStream.fail() )
{
if( 0 != errStr.size() )
errStr.push_back('\n');
errStr.append("Failed to open file '").append(fileName).push_back('\'');
return( 0 );
}
//
return( 1 );
} // End fcn openOutputFile().
std::string promptUserForFile(std::ofstream& stream,
const std::string& prompt,
const std::string& reprompt) {
std::string promptCopy = prompt;
std::string repromptCopy = reprompt;
if (reprompt == "") {
repromptCopy = "Unable to open that file. Try again.";
}
appendSpace(promptCopy);
while (true) {
std::cout << promptCopy;
std::string filename;
getline(std::cin, filename);
if (!filename.empty()) {
openFile(stream, filename);
if (!stream.fail()) return filename;
stream.clear();
}
std::cout << repromptCopy << std::endl;
if (promptCopy == "") promptCopy = "Output file: ";
}
}
bool OTASCIIArmor::SaveTo_ofstream(std::ofstream & fout)
{
OTString strOutput;
std::string str_type("DATA"); // -----BEGIN OT ARMORED DATA-----
if (this->WriteArmoredString(strOutput, str_type) && strOutput.Exists())
{
// WRITE IT TO THE FILE
//
fout << strOutput.Get();
if (fout.fail())
{
OTLog::vError("%s: Failed saving to file.\n Contents:\n\n%s\n\n",
__FUNCTION__, strOutput.Get());
return false;
}
// --------------------------------------------------------------------
return true;
}
// -----------------------
return false;
}
bool IDF3::WriteLayersText( std::ofstream& aBoardFile, IDF3::IDF_LAYER aLayer )
{
switch( aLayer )
{
case LYR_TOP:
aBoardFile << "TOP";
break;
case LYR_BOTTOM:
aBoardFile << "BOTTOM";
break;
case LYR_BOTH:
aBoardFile << "BOTH";
break;
case LYR_INNER:
aBoardFile << "INNER";
break;
case LYR_ALL:
aBoardFile << "ALL";
break;
default:
do{
std::ostringstream ostr;
ostr << "invalid IDF layer: " << aLayer;
throw( IDF_ERROR( __FILE__, __FUNCTION__, __LINE__, ostr.str() ) );
} while( 0 );
break;
}
return !aBoardFile.fail();
}
int parse_args(int argc, char **argv)
{
int option;
while ((option = getopt(argc, argv,"l:")) != -1)
{
switch (option) {
case 'l' :
if(logger)
logger.close();
logger.open(optarg, std::ofstream::out | std::ofstream::app);
if (logger.fail()) {
cerr << "open failure as expected: " << strerror(errno) << '\n';
return -1;
}
break;
default :
usage();
return -1;
}
}
}
