// Null constructor
JobInfo::JobInfo()
:
runningJobsDir_(getEnv("FOAM_JOB_DIR")/"runningJobs"),
finishedJobsDir_(getEnv("FOAM_JOB_DIR")/"finishedJobs"),
jobFileName_(hostName() + '.' + Foam::name(pid())),
runningJobPath_(runningJobsDir_/jobFileName_),
finishedJobPath_(finishedJobsDir_/jobFileName_)
{
name() = "JobInfo";
if (writeJobInfo && Pstream::master())
{
if (!dir(runningJobsDir_) && !mkDir(runningJobsDir_))
{
FatalErrorIn("JobInfo::JobInfo()")
<< "Cannot make JobInfo directory " << runningJobsDir_
<< Foam::exit(FatalError);
}
if (!dir(finishedJobsDir_) && !mkDir(finishedJobsDir_))
{
FatalErrorIn("JobInfo::JobInfo()")
<< "Cannot make JobInfo directory " << finishedJobsDir_
<< Foam::exit(FatalError);
}
}
constructed = true;
}
fileName IOModel::createLagrangianDir(fileName path) const
{
fileName lagrangianDirPath(path/"lagrangian");
mkDir(lagrangianDirPath,0777);
fileName cfdemCloudDirPath(lagrangianDirPath/"cfdemCloud1");
mkDir(cfdemCloudDirPath,0777);
return cfdemCloudDirPath;
}
int main ()
{
testResult_t *result = initializeTestResult();
getFS();
deleteFile("File to Delete");
deleteDir("Dir to Delete");
int newFd = openFile("NewFile");
char *text = "Here is some text.";
int writeLen = writeInFile(newFd, text, strlen(text));
assert(writeLen == strlen(text), "File write return value test.", result);
seekInFile(newFd, 0);
char target[100];
memset(target, 0, sizeof(target));
int readLen = readInFile(newFd, target, strlen(text));
assert(readLen == strlen(text), "File write return value test.", result);
deny(strcmp(target, text), "Read + write test.", result);
int fd = openFile("File to Delete");
seekInFile(newFd, FILE_BLOCK_DATA_SIZE - 2);
writeLen = writeInFile(newFd, text, strlen(text));
seekInFile(newFd, FILE_BLOCK_DATA_SIZE - 2);
readLen = readInFile(newFd, target, strlen(text));
assert(readLen == strlen(text), "Non-contiguous allocation read+write test.", result);
deny(strcmp(target, text), "Read + write test.", result);
mkDir("Dir to Delete");
giveDirListing();
deleteFile("File to Delete");
mkDir("NewDir");
giveDirListing();
deleteDir("Dir to Delete");
giveDirListing();
seekInFile(newFd, 0);
int i;
for (i = 0; i < 150; i++)
{
writeInFile(newFd, text, strlen(text));
seekInFile(newFd, (i * FILE_BLOCK_DATA_SIZE) - 2);
}
printTestResult(result);
freeTestResult(result);
return 0;
}
void operationThread::moveCopy(){
//перемещение\копирование
while(!param->files.isEmpty()){
if(canceled)
return;
QFileInfo tmp(param->dest);
QDir();
if (!tmp.exists())
if (!mkDir(tmp))
{
sendError(trUtf8("Не удалось создать папку назначения"));
/*не удалось создать папку назначения, ошибка-завершение*/
return;
}
if (param->files.first().isDir()&&!param->files.first().isSymLink()){
if (param->files.first().absoluteFilePath()==param->dest){
sendError(trUtf8("Невозможно скопировать папку в саму себя"));
return;
}
if (!mkDir(param->files.first())){
sendError(trUtf8("Не удалось создать папку"));
return;
}
dirRound(param->files.first().absoluteFilePath());
if (canceled) return;
if (param->type!=0) {
QString dirName=param->files.first().absoluteFilePath();
system("rm -rf \""+dirName.toLocal8Bit()+"\"");
}
}
else{
copyFile(param->files.first());
if (canceled) return;
if (param->type==2){
QFile f(param->files.first().absoluteFilePath());
f.remove();
}
if (param->type==1){
QFile f(param->files.first().absoluteFilePath());
f.remove();
}
}
param->files.pop_front();
}
}
bool mkDir(const fileName& pathName, const mode_t mode)
{
if (pathName.empty())
{
return false;
}
bool success = ::CreateDirectory(pathName.c_str(), NULL);
if (success)
{
chMod(pathName, mode);
}
else
{
const DWORD error = ::GetLastError();
switch (error)
{
case ERROR_ALREADY_EXISTS:
{
success = true;
break;
}
case ERROR_PATH_NOT_FOUND:
{
// Part of the path does not exist so try to create it
const fileName& parentName = pathName.path();
if (parentName.size() && mkDir(parentName, mode))
{
success = mkDir(pathName, mode);
}
break;
}
}
if (!success)
{
FatalErrorIn("mkDir(const fileName&, mode_t)")
<< "Couldn't create directory: " << pathName
<< " " << MSwindows::getLastError()
<< exit(FatalError);
}
}
return success;
}
void cumTrapz::writeScalar
(
const List<scalarField>& ct
)
{
Info << " - Writing cumulative trapezoidal integral: "
<< directDir_.c_str() << this->type() << endl;
mkDir( directDir_ + this->type() );
autoPtr<OFstream> spectrumPtr_;
forAll (indices_, indexi)
{
std::stringstream ss;
ss << callName_ << "_" << indices_[indexi];
spectrumPtr_.reset
(
new OFstream
(
directDir_ + "/" + this->type() + "/"
+ ss.str() + "_cumTrapz.dat"
)
);
const scalarField& data( ct[indexi] );
forAll (data, ii)
{
spectrumPtr_() << data[ii] << endl;
}
}
MainWindow::MainWindow(QWidget *parent) :
QMainWindow(parent),
ui(new Ui::MainWindow)
{
ui->setupUi(this);
setWindowTitle(trUtf8("Chess"));
setWindowIcon(QIcon("://images/black_king.png"));
moveToCenter();
mkDir();
scene = new QGraphicsScene(this);
ui->graphicsView->setScene(scene);
scene->setBackgroundBrush(Qt::lightGray);
ellipse = scene->addEllipse(0,0,150,150,QPen(Qt::gray),QBrush(Qt::white));
saver = scene->addPixmap(QPixmap("://images/black_king.png"));
saver->setPos(25, 25);
connect(ui->loadButton, SIGNAL(clicked()),SLOT(showLoad())); //показываем окно загрузки сохраненной игры
connect(ui->loadButton, SIGNAL(clicked()),SLOT(hide())); //делаем невидимым главное окно
connect(ui->newButton, SIGNAL(clicked()),SLOT(showNew()));
connect(ui->newButton, SIGNAL(clicked()),SLOT(hide()));
}
void Foam::proxySurfaceWriter::write
(
const fileName& outputDir,
const fileName& surfaceName,
const pointField& points,
const faceList& faces,
const bool verbose
) const
{
// avoid bad values
if (ext_.empty())
{
return;
}
if (!isDir(outputDir))
{
mkDir(outputDir);
}
fileName outName(outputDir/surfaceName + "." + ext_);
if (verbose)
{
Info<< "Writing geometry to " << outName << endl;
}
MeshedSurfaceProxy<face>(points, faces).write(outName);
}
void Foam::stl<Type>::write
(
const fileName& samplePath,
const fileName& timeDir,
const fileName& surfaceName,
const pointField& points,
const faceList& faces,
const fileName& fieldName,
const Field<Type>& values,
const bool verbose
) const
{
fileName surfaceDir(samplePath/timeDir);
if (!exists(surfaceDir))
{
mkDir(surfaceDir);
}
fileName planeFName(surfaceDir/fieldName + '_' + surfaceName + ".stl");
if (verbose)
{
Info<< "Writing field " << fieldName << " to " << planeFName << endl;
}
// Convert faces to triangles.
DynamicList<labelledTri> tris(faces.size());
forAll(faces, i)
{
const face& f = faces[i];
faceList triFaces(f.nTriangles(points));
label nTris = 0;
f.triangles(points, nTris, triFaces);
forAll(triFaces, triI)
{
const face& tri = triFaces[triI];
tris.append(labelledTri(tri[0], tri[1], tri[2], 0));
}
}
triSurface
(
tris.shrink(),
geometricSurfacePatchList
(
1,
geometricSurfacePatch
(
"patch", // geometricType
string::validate<word>(fieldName), // fieldName
0 // index
)
),
points
).write(planeFName);
}
/*!
Implementation for traverse so always true.
*/
bool FileFixture::execute(void * objectInstance, QString actionName, QHash<QString, QString> parameters, QString & stdOut)
{
Q_UNUSED(objectInstance);
TasLogger::logger()->debug("> FileFixture::execute:" + actionName);
if (actionName == "read_file") {
readFile(parameters.value(FILE_NAME), stdOut);
}else if (actionName == "read_file_part") {
readFilePart(parameters.value(FILE_NAME),parameters.value(FILE_OFFSET).toInt(),parameters.value(DATA_LENGHT).toInt(), stdOut);
} else if(actionName == "write_file") {
writeFile(parameters.value(FILE_NAME), parameters.value(FILE_DATA), stdOut);
} else if(actionName == "write_file_append") {
writeFileAppend(parameters.value(FILE_NAME), parameters.value(FILE_DATA),parameters.value(FILE_OFFSET).toInt(),parameters.value(DATA_LENGHT).toInt(), stdOut);
} else if(actionName == "delete_file") {
deleteFile(parameters.value(FILE_NAME), stdOut);
} else if(actionName == "mk_dir") {
mkDir(parameters.value(FILE_NAME), stdOut);
} else if(actionName == "rm_dir") {
rmDir(parameters.value(FILE_NAME), stdOut);
} else if(actionName == "list_files") {
listFiles(parameters.value(FILE_PATH), parameters.value(FILE_NAME), stdOut);
}
return true;
}
bool Foam::dynamicCode::createMakeFiles() const
{
// Create Make/files
if (compileFiles_.empty())
{
return false;
}
const fileName dstFile(this->codePath()/"Make/files");
// Create dir
mkDir(dstFile.path());
OFstream os(dstFile);
//Info<< "Writing to " << dstFile << endl;
if (!os.good())
{
FatalErrorInFunction
<< "Failed writing " << dstFile
<< exit(FatalError);
}
writeCommentSHA1(os);
// Write compile files
forAll(compileFiles_, fileI)
{
os.writeQuoted(compileFiles_[fileI], false) << nl;
}
void powerSpectraLS::writeScalar
(
const scalarField& frequencies,
const List<scalarField>& spectra
)
{
Info << " - Writing computed spectra to: " << directDir_.c_str()
<< this->type() << endl;
mkDir( directDir_ + this->type() );
autoPtr<OFstream> spectrumPtr_;
forAll (indices_, indexi)
{
std::stringstream ss;
ss << callName_ << "_" << indices_[indexi];
spectrumPtr_.reset
(
new OFstream
(
directDir_ + "/" + this->type() + "/"
+ ss.str() + "_spectrum.dat"
)
);
const scalarField& spectrum( spectra[indexi] );
forAll (frequencies, freqi)
{
spectrumPtr_() << frequencies[freqi] << tab << spectrum[freqi]
<< endl;
}
}
void Foam::foamFileSurfaceWriter<Type>::write
(
const fileName& outputDir,
const fileName& surfaceName,
const pointField& points,
const faceList& faces,
const bool verbose
) const
{
fileName surfaceDir(outputDir/surfaceName);
if (!isDir(surfaceDir))
{
mkDir(surfaceDir);
}
if (verbose)
{
Info<< "Writing geometry to " << surfaceDir << endl;
}
// Points
OFstream(surfaceDir/"points")() << points;
// Faces
OFstream(surfaceDir/"faces")() << faces;
}
void DbService::dbOpen()
{
BfDebug(__FUNCTION__);
g_sm->checkCurrentOn(ServiceMgr::DB);
if (db_) {
BfInfo("db opened already");
return;
}
QString path = Profile::dbPath();
mkDir(path);
leveldb::Options options;
options.create_if_missing = true;
options.error_if_exists = false;
options.compression = leveldb::kNoCompression;
options.paranoid_checks = false;
leveldb::DB* db;
leveldb::Status status = leveldb::DB::Open(options,
path.toStdString(),
&db);
if (!status.ok()) {
qFatal("leveldb::DB::Open fail");
}
db_ = db;
}
void operationThread::dirRound(QString down){
QDirIterator it(down,QDir::AllEntries|QDir::NoDotAndDotDot|QDir::Hidden,QDirIterator::Subdirectories);
while (it.hasNext()) {
if (canceled)
return;
while (stopped) msleep(DELAY);
if (canceled)
return;
QFileInfo tmp(it.next());
if (tmp.isDir()&&!tmp.isSymLink()){
if (param->type!=1) mkDir(tmp);
}
else
if(param->type!=1) copyFile(tmp);
else delFile(tmp);
if (canceled) return;
}
}
//- write field
void dsmcVibrationalDegreesOfFreedomZone::writeField()
{
const Time& runTime = time_.time();
if(runTime.outputTime())
{
fileName timePath(runTime.path()/runTime.timeName()/"uniform");
if (!isDir(timePath))
{
mkDir(timePath);
}
const scalarField& timeField = time_.averagingTimes();
writeTimeData(timePath, fieldName_+"_"+regionName_+"_vibrationalDegreesOfFreedom", timeField, vDoFField_);
//- reset
if(time_.resetFieldsAtOutput())
{
vibrationalETotal_ = scalar(0.0);
nParcels_ = scalar(0.0);
vibT_ = scalar(0.0);
vDof_ = scalar(0.0);
vibTxvDof_ = scalar(0.0);
}
}
}
//- Constructor
clockTimer::clockTimer(Time& t, word fieldName, bool write)
:
time_(t),
fieldName_(fieldName),
instTimeIndex_(0.0),
timeIndex_(0.0),
totalDuration_(0.0),
duration_(0.0),
instantDuration_(0.0),
writeOut_(write),
timePath_()
{
if(writeOut_)
{
// directory: case/boundaries
timePath_ = time_.path()/"timings";
if(isDir(timePath_))
{
rmDir(timePath_);
}
if(Pstream::master())
{
mkDir(timePath_);
}
}
}
void mkDirRecursively(const char *dir) {
struct stat sb;
if (!stat(dir, &sb)) return;
mkDirRecursively(path::dirname(dir).c_str());
mkDir(dir);
}
fileName basicIO::buildFilePath(word dirName) const
{
// create file structure
fileName path("");
if(parOutput_)
{
path=fileName(particleCloud_.mesh().time().path()/particleCloud_.mesh().time().timeName()/dirName/"particleCloud");
mkDir(path,0777);
} else
{
path=fileName("."/dirName);
mkDir(path,0777);
mkDir(fileName(path/"constant"),0777);
OFstream* stubFile = new OFstream(fileName(path/"particles.foam"));
delete stubFile;
}
return path;
}
// Null constructor
Foam::JobInfo::JobInfo()
:
runningJobPath_(),
finishedJobPath_(),
cpuTime_()
{
name() = "JobInfo";
if (writeJobInfo && Pstream::master())
{
string baseDir = getEnv("FOAM_JOB_DIR");
string jobFile = hostName() + '.' + Foam::name(pid());
fileName runningDir(baseDir/"runningJobs");
fileName finishedDir(baseDir/"finishedJobs");
runningJobPath_ = runningDir/jobFile;
finishedJobPath_ = finishedDir/jobFile;
if (baseDir.empty())
{
FatalErrorIn("JobInfo::JobInfo()")
<< "Cannot get JobInfo directory $FOAM_JOB_DIR"
<< Foam::exit(FatalError);
}
if (!isDir(runningDir) && !mkDir(runningDir))
{
FatalErrorIn("JobInfo::JobInfo()")
<< "Cannot make JobInfo directory " << runningDir
<< Foam::exit(FatalError);
}
if (!isDir(finishedDir) && !mkDir(finishedDir))
{
FatalErrorIn("JobInfo::JobInfo()")
<< "Cannot make JobInfo directory " << finishedDir
<< Foam::exit(FatalError);
}
}
constructed = true;
}
bool isoBubble::write(fileName file) const
{
fileName fullPath = file.lessExt();
mkDir(fullPath);
fullPath = fullPath + "/" + paddWithZeros(file);
bubblePtr_->write(fullPath);
return true;
}
void Foam::foamFileSurfaceWriter<Type>::write
(
const fileName& outputDir,
const fileName& surfaceName,
const pointField& points,
const faceList& faces,
const fileName& fieldName,
const Field<Type>& values,
const bool verbose
) const
{
fileName surfaceDir(outputDir/surfaceName);
if (!isDir(surfaceDir))
{
mkDir(surfaceDir);
}
if (verbose)
{
Info<< "Writing field " << fieldName << " to " << surfaceDir << endl;
}
// geometry should already have been written
// Values to separate directory (e.g. "scalarField/p")
fileName foamName(pTraits<Type>::typeName);
fileName valuesDir(surfaceDir / (foamName + Field<Type>::typeName));
if (!isDir(valuesDir))
{
mkDir(valuesDir);
}
// values
OFstream(valuesDir/fieldName)() << values;
}
void TakeScreenshot() {
g_TakeScreenshot = false;
mkDir(g_Config.memCardDirectory + "/PSP/SCREENSHOT");
// First, find a free filename.
int i = 0;
char temp[256];
while (i < 10000){
if(g_Config.bScreenshotsAsPNG)
sprintf(temp, "%s/PSP/SCREENSHOT/screen%05d.png", g_Config.memCardDirectory.c_str(), i);
else
sprintf(temp, "%s/PSP/SCREENSHOT/screen%05d.jpg", g_Config.memCardDirectory.c_str(), i);
FileInfo info;
if (!getFileInfo(temp, &info))
break;
i++;
}
// Okay, allocate a buffer.
u8 *buffer = new u8[3 * pixel_xres * pixel_yres];
// Silly openGL reads upside down, we flip to another buffer for simplicity.
u8 *flipbuffer = new u8[3 * pixel_xres * pixel_yres];
glReadPixels(0, 0, pixel_xres, pixel_yres, GL_RGB, GL_UNSIGNED_BYTE, buffer);
for (int y = 0; y < pixel_yres; y++) {
memcpy(flipbuffer + y * pixel_xres * 3, buffer + (pixel_yres - y - 1) * pixel_xres * 3, pixel_xres * 3);
}
if (g_Config.bScreenshotsAsPNG) {
png_image png;
memset(&png, 0, sizeof(png));
png.version = PNG_IMAGE_VERSION;
png.format = PNG_FORMAT_RGB;
png.width = pixel_xres;
png.height = pixel_yres;
png_image_write_to_file(&png, temp, 0, flipbuffer, pixel_xres * 3, NULL);
png_image_free(&png);
} else {
jpge::params params;
params.m_quality = 90;
compress_image_to_jpeg_file(temp, pixel_xres, pixel_yres, 3, flipbuffer, params);
}
delete [] buffer;
delete [] flipbuffer;
osm.Show(temp);
}
void initramfs () {
kprintf ("Initializing root directory (ramfs)\n");
rootDir = kmalloc (sizeof (dirEntry_t));
rootDir->extent = rootDir;
rootDir->name = (uint8 *) ".";
rootDir->file = 0;
dirEntry_t *newDir = kmalloc (sizeof (dirEntry_t));
rootDir->nextDir = newDir;
newDir->nextDir = (dirEntry_t *) -1;
newDir->extent = rootDir;
newDir->name = (uint8 *) "..";
newDir->file = 0;
mkDir ((uint8 *) "/", (uint8 *) "test");
mkDir ((uint8 *) "/test/", (uint8 *) "test2");
mkDir ((uint8 *) "/test/", (uint8 *) "boink");
mkFile ((uint8 *) "/test", (uint8 *) "boo.txt");
uint8 *buf = (uint8 *) "Hello from boo.txt!";
writeFS (openFS ((uint8 *) "/test/boo.txt", 0, 0), 100, buf);
registerRootFS ((uint8 *) "/", openFS, readFS, writeFS, listDir, 0, 0);
}
bool isoBubble::write() const
{
// Create the path to the instance directory.
mkDir(path());
fileName outFileName = paddWithZeros(objectPath());
if (OFstream::debug)
{
Info<< "regIOobject::write() : "
<< "writing file " << outFileName << endl;
}
bubblePtr_->write(outFileName);
return true;
}
void TakeScreenshot() {
#ifdef _WIN32
g_TakeScreenshot = false;
mkDir(g_Config.memCardDirectory + "/PSP/SCREENSHOT");
// First, find a free filename.
int i = 0;
char temp[256];
while (i < 10000){
if(g_Config.bScreenshotsAsPNG)
sprintf(temp, "%s/PSP/SCREENSHOT/screen%05d.png", g_Config.memCardDirectory.c_str(), i);
else
sprintf(temp, "%s/PSP/SCREENSHOT/screen%05d.jpg", g_Config.memCardDirectory.c_str(), i);
FileInfo info;
if (!getFileInfo(temp, &info))
break;
i++;
}
// Okay, allocate a buffer.
u8 *buffer = new u8[4 * pixel_xres * pixel_yres];
// Silly openGL reads upside down, we flip to another buffer for simplicity.
u8 *flipbuffer = new u8[4 * pixel_xres * pixel_yres];
glReadPixels(0, 0, pixel_xres, pixel_yres, GL_RGBA, GL_UNSIGNED_BYTE, buffer);
for (int y = 0; y < pixel_yres; y++) {
memcpy(flipbuffer + y * pixel_xres * 4, buffer + (pixel_yres - y - 1) * pixel_xres * 4, pixel_xres * 4);
}
if(g_Config.bScreenshotsAsPNG)
stbi_write_png(temp, pixel_xres, pixel_yres, 4, flipbuffer, pixel_xres * 4);
else
{
jpge::params params;
params.m_quality = 90;
compress_image_to_jpeg_file(temp, pixel_xres, pixel_yres, 4, flipbuffer, params);
}
delete [] buffer;
delete [] flipbuffer;
osm.Show(temp);
#endif
}
Foam::basicLIGGGHTSParticleCloud::basicLIGGGHTSParticleCloud
(
const fvMesh& mesh,
const word& cloudName
)
:
Cloud<basicLIGGGHTSParticle>(mesh, cloudName, false),
mesh_(mesh)
{
fileName particleFolder(mesh.time().path()/"particles");
mkDir(particleFolder/"constant");
OFstream *dummy = new OFstream(particleFolder/"particles.foam");
delete dummy;
}
void Foam::ParticleCollector<CloudType>::makeLogFile
(
const faceList& faces,
const Field<point>& points,
const Field<scalar>& area
)
{
// Create the output file if not already created
if (log_)
{
if (debug)
{
Info<< "Creating output file" << endl;
}
if (Pstream::master())
{
const fileName logDir = outputDir_/this->owner().time().timeName();
// Create directory if does not exist
mkDir(logDir);
// Open new file at start up
outputFilePtr_.reset
(
new OFstream(logDir/(type() + ".dat"))
);
outputFilePtr_()
<< "# Source : " << type() << nl
<< "# Total area : " << sum(area) << nl
<< "# Time";
forAll(faces, i)
{
word id = Foam::name(i);
outputFilePtr_()
<< tab << "area[" << id << "]"
<< tab << "mass[" << id << "]"
<< tab << "massFlowRate[" << id << "]"
<< endl;
}
}
}
void Foam::overtopping::makeFile()
{
// Create the overtopping file if not already created
if (outputFilePtr_.empty())
{
if (debug)
{
Info<< "Creating output file." << endl;
}
// File update
if (Pstream::master())
{
fileName outputDir;
word startTimeName =
mesh_.time().timeName(mesh_.time().startTime().value());
if (Pstream::parRun())
{
// Put in undecomposed case (Note: gives problems for
// distributed data running)
outputDir =
mesh_.time().path()/".."/this->type()/startTimeName;
}
else
{
outputDir = mesh_.time().path()/this->type()/startTimeName;
}
// Create directory if does not exist
mkDir(outputDir);
// Open new file at start up
outputFilePtr_.reset(new OFstream(outputDir/(type() + ".dat")));
outputFileForcePtr_.reset
(
new OFstream(outputDir/(type() + "_rhoU2A.dat"))
);
// Add headers to output data
writeFileHeader();
}
}
}
void writeCellGraph
(
const volScalarField& vsf,
const word& graphFormat
)
{
fileName path(vsf.time().path()/"graphs"/vsf.time().timeName());
mkDir(path);
graph
(
vsf.name(),
"x",
vsf.name(),
vsf.mesh().C().primitiveField().component(vector::X),
vsf.primitiveField()
).write(path/vsf.name(), graphFormat);
}
