FileID
Small_fd::get_fileid(const WriterPtr &writer) {
map<ssize_t, FileID>::iterator itr;
FileID fid;
ssize_t did;
did = writer->get_droppingid();
pthread_rwlock_rdlock(&fileids_lock);
itr = idmap_.find(did);
if (itr != idmap_.end()) {
fid = itr->second;
} else {
pthread_rwlock_unlock(&fileids_lock);
pthread_rwlock_wrlock(&fileids_lock);
itr = idmap_.find(did);
if (itr != idmap_.end()) { // Somebody else wins the race.
fid = itr->second;
} else {
fid = writer->get_fileid(myName, &container->files);
idmap_[did] = fid;
}
}
pthread_rwlock_unlock(&fileids_lock);
return fid;
}
GA_Detail::IOStatus GEO_CobIOTranslator::fileSaveToFile( const GEO_Detail *geo, ostream &os, const char *fileName )
{
((ofstream&)os).close();
GU_DetailHandle handle;
handle.allocateAndSet( (GU_Detail*)geo, false );
FromHoudiniGeometryConverterPtr converter = FromHoudiniGeometryConverter::create( handle );
if ( !converter )
{
return false;
}
ObjectPtr object = converter->convert();
if ( !object )
{
return false;
}
try
{
WriterPtr writer = Writer::create( object, fileName );
writer->write();
}
catch ( IECore::Exception e )
{
return false;
}
return true;
}
void Engine::Impl::run()
{
std::vector< std::pair<QString, QString> > vec = {
{PLAYER_X,"MaybePerfect"},
{PLAYER_O,"MaybePerfect"},
{NUM_OF_GAMES, "1"}
};
config_->initialize(vec);
WriterPtr sw = nullptr;
bool savingGame = false;
initAgentFromConfig();
initWriterFromConfig(sw, savingGame);
int numGames = config_->get<int>(NUM_OF_GAMES);
for(int i=0;i<numGames;++i){
//restart
for(char& c: board_){ c = MARK_E; }
curTurn_ = MARK_X;
std::vector<int> vec;
while(1){
//player X's turn
int move = playerX_->move(board_);
board_[move] = MARK_X;
record(savingGame, vec, move);
if(isWon(board_,move)) break;
else if(isFull(board_)) break;
//player O's turn
move = playerO_->move(board_);
board_[move] = MARK_O;
record(savingGame, vec, move);
if(isWon(board_,move)) break;
}//end while
playerX_->postProcess();
playerO_->postProcess();
if(savingGame){
sw->writeLine(toString(vec));
}
}//end for
}
plfs_error_t
Small_fd::trunc(off_t offset)
{
plfs_error_t ret;
if (open_flags == O_WRONLY || open_flags == O_RDWR) {
FileID fileid;
WriterPtr writer;
writer = container->get_writer(open_by_pid);
fileid = get_fileid(writer);
pthread_rwlock_rdlock(&indexes_lock);
ret = writer->truncate(fileid, offset, NULL, indexes.get());
pthread_rwlock_unlock(&indexes_lock);
if (ret == PLFS_SUCCESS) container->files.truncate_file(myName, offset);
} else {
ret = PLFS_EBADF;
}
return ret;
}
plfs_error_t
Small_fd::write(const char *buf, size_t size, off_t offset, pid_t /* pid */,
ssize_t *bytes_written)
{
plfs_error_t ret = PLFS_EBADF;
*bytes_written = -1;
if (open_flags == O_WRONLY || open_flags == O_RDWR) {
FileID fileid;
WriterPtr writer;
writer = container->get_writer(open_by_pid);
fileid = get_fileid(writer);
pthread_rwlock_rdlock(&indexes_lock);
ret = writer->write(fileid, buf, offset, size, NULL, indexes.get());
if (ret == PLFS_SUCCESS) *bytes_written = (ssize_t)size;
pthread_rwlock_unlock(&indexes_lock);
if (ret == PLFS_SUCCESS) container->files.expand_filesize(myName, offset+size);
}
return ret;
}
void logSearchResult(T pQuery,
T pResult,
double searchTime,
mreal_t precision,
mreal_t epsilon,
WriterPtr<T> pWriter,
CoordinatePtr<T, mreal_t> pCoordinate,
RealCoordinateWriterPtr<T> pRealCoordinateWriter,
std::ostream& outputStream) {
const std::string delimeter = ", ";
//Temporally output nothing but the result 's coordinate and approximation precision
/*outputStream << "Query:" << END_LINE;
pWriter->write(pQuery, outputStream);
outputStream << "Epsilon:" << epsilon << END_LINE;
outputStream << "Info" << END_LINE;
outputStream << "Search time: " ;
outputStream << searchTime << delimeter;
outputStream << "Result:" << END_LINE;*/
outputStream << "Search time: " << searchTime << delimeter;
if(pResult != NullPtr) {
pWriter->write(pResult, outputStream);
if(pCoordinate != NullPtr) {
pRealCoordinateWriter->writeCoordinate(*pCoordinate, outputStream);
}
}
outputStream << "Distance to target:";
outputStream << precision;
outputStream << END_LINE;
}
inline WriterPtr operator<<(WriterPtr writer, std::ostream& (*manip)(std::ostream&))
{
writer->manipulate(manip);
return writer;
}
inline WriterPtr operator<<(WriterPtr writer, T const& x)
{
writer->print(x);
return writer;
}
bool process( std::istream& ifs,
std::string const& output,
liblas::Header & header,
std::vector<liblas::FilterPtr>& filters,
std::vector<liblas::TransformPtr>& transforms,
boost::uint32_t split_mb,
boost::uint32_t split_pts,
bool verbose,
bool min_offset)
{
liblas::ReaderFactory f;
liblas::Reader reader = f.CreateWithStream(ifs);
SummaryPtr summary(new::liblas::CoordinateSummary);
reader.SetFilters(filters);
reader.SetTransforms(transforms);
if (min_offset)
{
liblas::property_tree::ptree tree = SummarizeReader(reader);
try
{
header.SetOffset(tree.get<double>("summary.points.minimum.x"),
tree.get<double>("summary.points.minimum.y"),
tree.get<double>("summary.points.minimum.z"));
}
catch (liblas::property_tree::ptree_bad_path const& e)
{
std::cerr << "Unable to write minimum header info. Does the outputted file have any points?";
std::cerr << e.what() << std::endl;
return false;
}
if (verbose)
{
std::cout << "Using minimum offsets ";
SetStreamPrecision(std::cout, header.GetScaleX());
std::cout << header.GetOffsetX() << " ";
SetStreamPrecision(std::cout, header.GetScaleY());
std::cout << header.GetOffsetY() << " ";
SetStreamPrecision(std::cout, header.GetScaleZ());
std::cout << header.GetOffsetZ() << " ";
std::cout << std::endl;
}
reader.Reset();
// If we have any reprojection going on, we have to reset the offsets
// of the HeaderPtr that is applied to the points as they are reprojected
// or things will get screwed up when we go to re-assign the header
// as we write the points with the min-offset
std::vector<liblas::TransformPtr> transforms = reader.GetTransforms();
std::vector<liblas::TransformPtr> new_transforms;
for (std::size_t i = 0; i < transforms.size(); i++)
{
liblas::TransformPtr transform = transforms[i];
if (dynamic_cast<liblas::ReprojectionTransform*>(transform.get()))
{
dynamic_cast<liblas::ReprojectionTransform*>(transform.get())->SetHeader(&header);
}
new_transforms.push_back(transform);
}
reader.SetTransforms(new_transforms);
}
std::ostream* ofs = NULL;
std::string out = output;
WriterPtr writer;
if (!split_mb && !split_pts) {
writer = start_writer(ofs, output, header);
} else {
string::size_type dot_pos = output.find_first_of(".");
out = output.substr(0, dot_pos);
writer = start_writer(ofs, out+"-1"+".las", header);
}
if (verbose)
std::cout << "Writing output:"
<< "\n - : " << output
<< std::endl;
//
// Translation of points cloud to features set
//
boost::uint32_t i = 0;
boost::uint32_t const size = header.GetPointRecordsCount();
boost::int32_t split_bytes_count = 1024*1024*split_mb;
boost::uint32_t split_points_count = 0;
int fileno = 2;
while (reader.ReadNextPoint())
{
if (min_offset)
{
liblas::Point p = reader.GetPoint();
summary->AddPoint(p);
p.SetHeader(&header);
writer->WritePoint(p);
}
else
{
liblas::Point const& p = reader.GetPoint();
summary->AddPoint(p);
writer->WritePoint(p);
}
if (verbose)
term_progress(std::cout, (i + 1) / static_cast<double>(size));
i++;
split_points_count++;
split_bytes_count = split_bytes_count - header.GetSchema().GetByteSize();
if (split_bytes_count < 0 && split_mb > 0 && ! split_pts) {
// The user specifies a split size in mb, and we keep counting
// down until we've written that many points into the file.
// After that point, we make a new file and start writing into
// that.
// dereference the writer so it is deleted before the ofs
writer = WriterPtr();
delete ofs;
ofs = NULL;
ostringstream oss;
oss << out << "-"<< fileno <<".las";
writer = start_writer(ofs, oss.str(), header);
ostringstream old_filename;
old_filename << out << "-" << fileno - 1 << ".las";
liblas::Header hnew = FetchHeader(old_filename.str());
RepairHeader(*summary, hnew);
RewriteHeader(hnew, old_filename.str());
summary = SummaryPtr(new liblas::CoordinateSummary);
fileno++;
split_bytes_count = 1024*1024*split_mb;
}
if (split_pts > 0 && ! split_mb && split_points_count == split_pts) {
// The user specifies a split size in pts, and we keep counting
// down until we've written that many points into the file.
// After that point, we make a new file and start writing into
// that.
// dereference the writer so it is deleted before the ofs
writer = WriterPtr();
delete ofs;
ofs = NULL;
ostringstream oss;
oss << out << "-"<< fileno <<".las";
writer = start_writer(ofs, oss.str(), header);
ostringstream old_filename;
old_filename << out << "-" << fileno - 1 << ".las";
liblas::Header hnew = FetchHeader(old_filename.str());
RepairHeader(*summary, hnew);
RewriteHeader(hnew, old_filename.str());
summary = SummaryPtr(new liblas::CoordinateSummary);
fileno++;
split_points_count = 0;
}
}
if (verbose)
std::cout << std::endl;
// cheap hackery. We need the Writer to disappear before the stream.
// Fix this up to not suck so bad.
writer = WriterPtr();
delete ofs;
ofs = NULL;
if (!split_mb && !split_pts) {
reader.Reset();
liblas::Header hnew = FetchHeader(output);
RepairHeader(*summary, hnew);
RewriteHeader(hnew, output);
}
return true;
}
BufferAllocator::ReaderPtr BufferAllocator::create_reader(const WriterPtr &raw) {
raw->was_reader_ = true;
raw->ref_cnt_.fetch_add(1, std::memory_order_acq_rel);
return ReaderPtr(raw.get());
}
