File ReadEntireFile(std::string filename, B32 ignoreFailure) {
File result = {};
struct stat statBuffer;
HANDLE fileDescriptor = open(filename.c_str(), O_RDONLY);
if(fileDescriptor != -1) {
result.size = GetFileSize(filename, fileDescriptor, True, ignoreFailure);
if(result.size) {
Cout("File opened: \"%s\"; Size: %lu", filename.c_str(), result.size);
result.data = mmap(NULL, result.size, PROT_READ | PROT_WRITE, MAP_PRIVATE,
fileDescriptor, 0);
if(result.data != MAP_FAILED) {
U32 bytesRead = read(fileDescriptor, result.data, result.size);
if(bytesRead != result.size) {
Cerr("File allocation failed: File: \"%s\"; Size %lu", filename.c_str(),
result.size);
munmap(result.data, result.size);
result.data = NULL;
result.size = 0;
}
} else {
if(!ignoreFailure) {
Cerr("File request allocation failed: File \"%s\"; Size %lu",
filename.c_str(), result.size);
}
}
} else {
if(!ignoreFailure) {
Cerr("File request failed with size of 0; File: \"%s\"", filename.c_str());
}
}
close(fileDescriptor);
}
return result;
}
B32 WriteEntireFile(std::string filename, U32 memorySize, void* memory, B32 ignoreFailure) {
B32 result = false;
HANDLE fileDescriptor = open(filename.c_str(), O_WRONLY | O_CREAT | O_TRUNC, S_IRWXU |
S_IRWXG | S_IRWXO);
if(fileDescriptor != -1) {
U32 bytesWritten = write(fileDescriptor, memory, memorySize);
result = bytesWritten == memorySize;
close(fileDescriptor);
} else {
if(!ignoreFailure) {
S32 err = errno;
Cerr("Could not create file: \"%s\"", filename.c_str());
Cerr("Errno: %d", err);
}
}
return result;
}
S64 GetLastWriteTime(std::string filename, B32 ignoreFailure) {
S64 result = 0;
struct stat statBuffer;
if(!stat(filename.c_str(), &statBuffer)) {
result = statBuffer.st_mtim.tv_sec;
} else {
if(!ignoreFailure) {
Cerr("Could not get stat of file: %s", filename.c_str());
}
}
return result;
}
void PlayBackInput(HLState* state, Input* input){
if(state->playbackHandle && state->playbackIndex){
if(read(state->playbackHandle, input, sizeof(*input)) < 1){
#if LOOP_AUTON_PLAYBACK
S32 err = errno;
U32 playbackIndex = state->playbackIndex;
EndInputPlayback(state);
BeginInputPlayback(state, playbackIndex);
read(state->playbackHandle, input, sizeof(*input));
if(err != 32){
Cerr("Read Error: %d", err);
}
#endif
}
}
}
void GenerateMorphsOper::GenerateMorphsOperImpl::operator()() {
auto tree = getTree();
if (tree) {
auto tree_pimpl = tree->pimpl;
ConcurrentMolVector leaves;
tree_pimpl->fetchLeaves(tree, true, leaves);
tree_pimpl->candidates.clear();
std::shared_ptr<CollectMorphs> collector(new CollectMorphs(
tree_pimpl->candidates
, tree
, mSetTreeOwnershipForMorphs
, tree_pimpl->target
, (FingerprintSelector) tree_pimpl->fingerprint
, (SimCoeffSelector) tree_pimpl->simCoeff
));
std::vector<std::shared_ptr<MorphCollector> > collectors;
collectors.push_back(std::static_pointer_cast<MorphCollector>(collector));
collectors.insert(collectors.end(), this->collectors.begin(), this->collectors.end());
for (auto& leaf : leaves) {
unsigned int morphAttempts = tree_pimpl->params.cntMorphs;
if (leaf->getDistToTarget() < tree_pimpl->params.distToTargetDepthSwitch) {
morphAttempts = tree_pimpl->params.cntMorphsInDepth;
}
// generate morphs for the current leaf
try {
Molpher molpher(
leaf
, tree_pimpl->chemOpers
, tree_pimpl->threadCnt
, morphAttempts
, collectors
);
tree_pimpl->candidates.reserve(tree_pimpl->candidates.size() + morphAttempts);
molpher();
} catch (std::exception exp) {
Cerr("Morphing failed for leaf: " + leaf->getSMILES());
if (!leaf->getParentSMILES().empty()) {
tree->deleteSubtree(leaf->getSMILES(), false);
}
continue;
}
MorphDerivationMap::accessor ac;
if (tree_pimpl->morphDerivations.find(ac, leaf->getSMILES())) {
ac->second += collector->WithdrawCollectAttemptCount();
} else {
tree_pimpl->morphDerivations.insert(ac, leaf->getSMILES());
ac->second = collector->WithdrawCollectAttemptCount();
}
}
tree_pimpl->candidates.shrink_to_fit();
tree_pimpl->candidatesMask.clear();
tree_pimpl->candidatesMask.resize(tree_pimpl->candidates.size(), true);
// SynchCout("Generated " + parseNumber(tree_pimpl->candidates.size()) + " morphs.");
} else {
throw std::runtime_error("Cannot generate morphs. No tree associated with this instance.");
}
}
