DimensionMapPtr IteratorBase::fetchDimensionMap(Statement statement, sdo_pc* pc, PointBuffer const& oracle_buffer, PointBuffer const& user_buffer)
{
boost::int32_t id = statement->GetInteger(&pc->pc_id);
DimensionMaps::const_iterator i = m_dimensions.find(id);
if (i != m_dimensions.end())
{
getReader().log()->get(logDEBUG2) << "IteratorBase::fetchDimensionMap: found existing DimensionMap with id " << id << std::endl;
return i->second;
}
else
{
DimensionMapPtr output = DimensionMapPtr(m_oracle_buffer->getSchema().mapDimensions( user_buffer.getSchema(),
false /*ignore namespaces*/));
getReader().log()->get(logDEBUG2) << "DimensionMapPtr->size(): " << output->size() << std::endl;
if (!output->size()) throw pdal_error("fetchDimensionMap map was unable to map any dimensions!");
for (schema::DimensionMap::const_iterator i = output->begin(); i != output->end(); ++i)
{
getReader().log()->get(logDEBUG2) << "mapping " << i->first->getFQName() << " to " << i->second->getFQName() << std::endl;
}
std::pair<int, DimensionMapPtr> p(id, output);
m_dimensions.insert(p);
getReader().log()->get(logDEBUG2) << "IteratorBase::fetchDimensionMap: creating new DimensionMap with id " << id << std::endl;
return p.second;
}
}
std::shared_ptr<IReader> PingPong::createReader()
{
std::shared_ptr<IReader> reader = getReader();
std::shared_ptr<IReader> reader2 = std::shared_ptr<IReader>(new ReverseReader(getReader()));
return std::shared_ptr<IReader>(new DoubleReader(reader, reader2));
}
void ZendParser::parse() {
setupReader();
getReader()->removeDir(outputDir);
getReader()->createDir(outputDir);
if (isRecurisve())
getReader()->read(getReader()->getPath(), "/");
else
getReader()->read();
vector<DirectoryReader::Item> *readerResult = reader->getResults();
int generated = 0, processed = 0;
vector<string> tmpOut, tmpVector;
set<string> tmpSet;
vector<pair<string, string>> tmpOutPairs;
File file;
buildFiles(file, tmpOut, processed, readerResult, tmpOutPairs, tmpVector);
filterPreparedTypes(*typesRegistryUnfiltered, *typesRegistry);
generatePreparedTypesGlobal(tmpVector);
writeFiles(tmpSet, generated);
writeTypesRegistryFile();
cout << "\n";
cout << "files processed : " << processed << "\n";
cout << "types found : " << typesRegistry->size() << "\n";
cout << "files generated : " << generated << "\n";
cout << "\n";
cout << "finished...";
}
pdal::Bounds<double> IteratorBase::getBounds(Statement statement, BlockPtr block)
{
pdal::Vector<double> mins;
pdal::Vector<double> maxs;
boost::int32_t bounds_length = statement->GetArrayLength(&(block->blk_extent->sdo_ordinates));
getReader().log()->get(logDEBUG3) << "IteratorBase::getBounds: bounds length " << bounds_length << std::endl;
double x(0.0);
double y(0.0);
statement->GetElement(&(block->blk_extent->sdo_ordinates), 0, &x);
mins.add(x);
statement->GetElement(&(block->blk_extent->sdo_ordinates), 1, &y);
mins.add(y);
statement->GetElement(&(block->blk_extent->sdo_ordinates), 2, &x);
maxs.add(x);
statement->GetElement(&(block->blk_extent->sdo_ordinates), 3, &y);
maxs.add(y);
pdal::Bounds<double> block_bounds(mins, maxs);
getReader().log()->get(logDEBUG2) << "IteratorBase::getBounds: Fetched bounds of " << block_bounds << std::endl;
return block_bounds;
}
BufferPtr IteratorBase::fetchPointBuffer(boost::int32_t const& cloud_id,
std::string const& schema_xml,
boost::uint32_t capacity)
{
BufferMap::const_iterator i = m_buffers.find(cloud_id);
if (i != m_buffers.end())
{
getReader().log()->get(logDEBUG2) << "IteratorBase::fetchPointBuffer: found existing PointBuffer with id " << cloud_id << std::endl;
return i->second;
}
else
{
std::stringstream query;
Schema schema = Schema::from_xml(schema_xml);
BufferPtr output = BufferPtr(new PointBuffer(schema, capacity));
std::pair<int, BufferPtr> p(cloud_id, output);
m_buffers.insert(p);
getReader().log()->get(logDEBUG2) << "IteratorBase::fetchPointBuffer: creating new PointBuffer with id " << cloud_id << std::endl;
return p.second;
}
}
BufferPtr IteratorBase::fetchPointBuffer(Statement statement, sdo_pc* pc)
{
boost::int32_t id = statement->GetInteger(&pc->pc_id);
BufferMap::const_iterator i = m_buffers.find(id);
if (i != m_buffers.end())
{
getReader().log()->get(logDEBUG2) << "IteratorBase::fetchPointBuffer: found existing PointBuffer with id " << id << std::endl;
return i->second;
}
else
{
boost::uint32_t block_capacity(0);
Schema schema = m_reader.fetchSchema(statement, pc, block_capacity, getReader().getName());
m_orientation = schema.getOrientation();
getReader().log()->get(logDEBUG2) << "Incoming schema orientation is " << m_orientation << std::endl;
BufferPtr output = BufferPtr(new PointBuffer(schema, block_capacity));
std::pair<int, BufferPtr> p(id, output);
m_buffers.insert(p);
getReader().log()->get(logDEBUG2) << "IteratorBase::fetchPointBuffer: creating new PointBuffer with id " << id << std::endl;
return p.second;
}
}
void WaveAudioEssenceReader::reset() throw()
{
if (getReader() == 0)
{
return;
}
_currentStartPosition = 0;
_editUnit = 0;
getReader()->setPosition(_dataOffset, Reader::BEGIN);
}
bool AnimationFile::parse(){
std::lock_guard <std::mutex> guard(mutex);
auto ok = false;
if (getReader().parse()){
auto value = getReader().findFirstValueWithAttributeValue("duration");
duration = value.toFloat(&ok);
if (!ok){
LogFile::writeToLog(getFileName()+" :parse(): The animation duration was not found!");
}
}else{
LogFile::writeToLog(getFileName()+" :parse(): The animation file failed to parse!");
}
return ok;
}
void IteratorBase::readBlob(Statement statement,
BlockPtr block,
boost::uint32_t howMany)
{
boost::uint32_t nAmountRead = 0;
boost::uint32_t nBlobLength = statement->GetBlobLength(block->locator);
if (block->chunk.size() < nBlobLength)
{
block->chunk.resize(nBlobLength);
}
getReader().log()->get(logDEBUG4) << "IteratorBase::readBlob expected point count: " << howMany << std::endl;
getReader().log()->get(logDEBUG4) << "IteratorBase::readBlob expected nBlobLength: " << nBlobLength << std::endl;
// statement->OpenBlob(block->locator);
bool read_all_data = statement->ReadBlob(block->locator,
(void*)(&(block->chunk)[0]),
block->chunk.size() ,
&nAmountRead);
// statement->CloseBlob(block->locator);
getReader().log()->get(logDEBUG4) << "IteratorBase::readBlob read nAmountRead: " << nAmountRead << std::endl;
if (!read_all_data) throw pdal_error("Did not read all blob data!");
getReader().log()->get(logDEBUG4) << "IteratorBase::readBlob actual nAmountRead: " << nAmountRead << std::endl;
if (nBlobLength > m_oracle_buffer->getBufferByteLength())
{
// resize and check again. If the schema doesn't match
// what the blob actually had, this won't divide correctly and
// we're screwed.
boost::uint32_t capacity = nBlobLength/m_oracle_buffer->getSchema().getByteSize();
assert(nBlobLength % m_oracle_buffer->getSchema().getByteSize() == 0);
m_oracle_buffer->resize(capacity, true);
}
if (m_oracle_buffer->getSchema().getOrientation() == schema::DIMENSION_INTERLEAVED)
{
boost::uint32_t capacity = nBlobLength/m_oracle_buffer->getSchema().getByteSize();
assert(nBlobLength % m_oracle_buffer->getSchema().getByteSize() == 0);
m_oracle_buffer->resize(capacity, true);
}
m_oracle_buffer->setDataStride(&(block->chunk)[0], 0, nAmountRead);
m_oracle_buffer->setNumPoints(m_block->num_points);
}
boost::shared_ptr<AUD_IReader> AUD_SquareFactory::createReader()
{
return boost::shared_ptr<AUD_IReader>(new AUD_CallbackIIRFilterReader(getReader(), 1, 1,
(doFilterIIR) squareFilter,
(endFilterIIR) endSquareFilter,
new float(m_threshold)));
}
std::shared_ptr<IReader> Volume::createReader()
{
std::vector<float> a, b;
a.push_back(1);
b.push_back(m_volume);
return std::shared_ptr<IReader>(new IIRFilterReader(getReader(), b, a));
}
AUD_IReader* AUD_VolumeFactory::createReader() const
{
std::vector<float> a, b;
a.push_back(1);
b.push_back(m_volume);
return new AUD_IIRFilterReader(getReader(), b, a);
}
VolumeHandle* VolumeSerializer::load(const VolumeOrigin& origin) const
throw (tgt::FileException, std::bad_alloc)
{
VolumeReader* reader = getReader(origin.getURL());
VolumeHandle* volumeHandle = reader->read(origin);
return volumeHandle;
}
bool Float::fillFrame() {
auto creating = _frame.isNull();
if (creating) {
_frame = QImage(getInnerRect().size() * cIntRetinaFactor(), QImage::Format_ARGB32_Premultiplied);
_frame.setDevicePixelRatio(cRetinaFactor());
}
auto frameInner = [this] {
return QRect(0, 0, _frame.width() / cIntRetinaFactor(), _frame.height() / cIntRetinaFactor());
};
if (auto reader = getReader()) {
updatePlayback();
auto frame = reader->current();
if (!frame.isNull()) {
_frame.fill(Qt::transparent);
Painter p(&_frame);
PainterHighQualityEnabler hq(p);
p.drawPixmap(frameInner(), frame);
return true;
}
}
if (creating) {
_frame.fill(Qt::transparent);
Painter p(&_frame);
PainterHighQualityEnabler hq(p);
p.setPen(Qt::NoPen);
p.setBrush(st::imageBg);
p.drawEllipse(frameInner());
}
return false;
}
sci::istream PatchFilesResourceSource::GetHeaderAndPositionedStream(const ResourceMapEntryAgnostic &mapEntry, ResourceHeaderAgnostic &headerEntry)
{
std::string fileName = _indexToFilename[mapEntry.ExtraData]; // We used package number as a transport vessel for our arbitrary data
assert(!fileName.empty());
ScopedHandle patchFile;
std::string fullPath = _gameFolder + "\\" + fileName;
patchFile.hFile = CreateFile(fullPath.c_str(), GENERIC_READ, FILE_SHARE_READ, nullptr, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, nullptr);
if (patchFile.hFile != INVALID_HANDLE_VALUE)
{
auto streamHolder = std::make_unique<sci::streamOwner>(patchFile.hFile);
sci::istream readStream = streamHolder->getReader();
// We need to be owners of this stream data.
_streamHolder[mapEntry.ExtraData] = move(streamHolder);
// Now fill in the headerEntry
headerEntry.Number = mapEntry.Number;
headerEntry.Base36Number = mapEntry.Base36Number;
headerEntry.Type = mapEntry.Type;
headerEntry.CompressionMethod = 0;
headerEntry.Version = _version;
readStream.seekg(mapEntry.Offset);
headerEntry.cbDecompressed = readStream.getBytesRemaining();
headerEntry.cbCompressed = readStream.getBytesRemaining();
headerEntry.SourceFlags = _sourceFlags;
headerEntry.PackageHint = 0; // No package.
return readStream;
}
return sci::istream(nullptr, 0); // Empty stream....
}
AUD_IReader* AUD_ReverseFactory::createReader()
{
AUD_IReader* reader = getReader();
if(reader != 0)
{
reader = new AUD_ReverseReader(reader); AUD_NEW("reader")
}
boost::shared_ptr<AUD_IReader> AUD_ConverterFactory::createReader()
{
boost::shared_ptr<AUD_IReader> reader = getReader();
if(m_specs.format != AUD_FORMAT_FLOAT32)
reader = boost::shared_ptr<AUD_IReader>(new AUD_ConverterReader(reader, m_specs));
return reader;
}
kj::Promise<Coin::Reader> StubChainAdaptor::getCoin(QString symbol) const
{
auto itr = std::find_if(coins.begin(), coins.end(), [symbol] (const capnp::Orphan<Coin>& coin) {
return coin.getReader().getName() == symbol.toStdString();
});
if (itr == coins.end())
return KJ_EXCEPTION(FAILED, "Could not find the specified coin.");
return itr->getReader();
}
AUD_IReader* AUD_LimiterFactory::createReader()
{
AUD_IReader* reader = getReader();
if(reader != 0)
{
reader = new AUD_LimiterReader(reader, m_start, m_end);
AUD_NEW("reader")
}
void ZendParser::writeTypesRegistryFile() {
string typesRegistryString;
vector<PreparedType>::iterator type = typesRegistry->begin();
for (; type != typesRegistry->end(); ++type) {
typesRegistryString += (*type).type + " | " + (*type).raw + "\n";
}
getReader()->writeTextFile(outputDir + "\\typesregistry.txt",
typesRegistryString);
}
AUD_IReader* AUD_DelayFactory::createReader()
{
AUD_IReader* reader = getReader();
if(reader != 0)
{
reader = new AUD_DelayReader(reader, m_delay);
AUD_NEW("reader")
}
AUD_IReader* AUD_SRCResampleFactory::createReader() const
{
AUD_IReader* reader = getReader();
if(reader->getSpecs().rate != m_specs.rate)
reader = new AUD_SRCResampleReader(reader, m_specs.specs);
return reader;
}
// Remove a file from the filesystem
bool STORAGE::Filesystem::unlink(File f) {
std::string thisName;
bool merged = false;
lock(f, IO::EXCLUSIVE);
{
// Save info about the file
FilePosition pos = dir->files[f];
FileSize size = dir->headers[f].size;
FileSize vsize = dir->headers[f].virtualSize;
thisName = std::string(dir->headers[f].name);
// Overwrite the file with the last file
FilePosition lastFilePos = dir->files[dir->numFiles - 1];
FileHeader lastFileHeader = readHeader(lastFilePos);
File &lastFile = lookup[std::string(lastFileHeader.name)];
lock(lastFile, IO::EXCLUSIVE);
{
dir->files[f] = dir->files[lastFile];
dir->headers[f] = dir->headers[lastFile];
dir->locks[f] = dir->locks[lastFile];
lookup[std::string(dir->headers[lastFile].name)] = f;
}
unlock(lastFile, IO::EXCLUSIVE);
// Validate that the next header is valid. Otherwise we cannot reclaim the space.
FileHeader nextHeader = readHeader(pos + size + FileHeader::SIZE);
if (strcmp(nextHeader.name, "") != 0 ||
lookup.find(std::string(nextHeader.name, strlen(nextHeader.name))) != lookup.end()) {
File nextFile = lookup[std::string(nextHeader.name)];
FileHeader &nextFileHeader = dir->headers[nextFile];
auto reader = getReader(nextFile);
auto writer = getWriter(nextFile);
lock(nextFile, IO::EXCLUSIVE);
{
char *buf = reader.readRaw();
dir->files[nextFile] = pos; // Update the file position
dir->headers[nextFile].virtualSize += vsize + FileHeader::SIZE;
writer.write(buf, nextFileHeader.size);
writeHeader(nextFile);
}
unlock(nextFile, IO::EXCLUSIVE);
merged = true;
}
}
unlock(f, IO::EXCLUSIVE);
// Remove the lookup info and fix the directory metadata
{
std::unique_lock<std::mutex> lk(dirLock);
lookup.erase(thisName);
dir->numFiles--;
dir->nextSpot--;
}
return merged;
}
void ZendParser::writeFiles(const set<string> &tmpSet, int &generated) {
generated = 0;
File fileCopy;
for (vector<ZendParser::File>::iterator file = results->begin();
file != results->end(); ++file) {
// if (file->name.compare("View.php") != 0) {
// continue;
// }
// if (file->name.compare("Role.php") != 0) {
// continue;
// }
// if (file->name.compare("Registry.php")) {
// continue;
// }
// if (file->name.compare("Exception.php")) {
// continue;
// }
// if (file->name.compare("Initializer.php")) {
// continue;
// }
// if (file->name.compare("Select.php")) {
// continue;
// }
fileCopy = *file;
getReader()->createDir(outputDir + "\\" + file->rootPath);
replaceTypesBuiltIn(fileCopy);
// cout << fileCopy.mainType << "\n";
if (fileCopy.mainType.length() > 0) {
addNamespace(fileCopy);
addUsages(fileCopy, tmpSet);
replaceTypes(fileCopy);
}
replaceTypesGlobal(fileCopy);
getReader()->writeTextFile(
outputDir + "\\" + fileCopy.rootPath + fileCopy.name,
fileCopy.content);
generated++;
}
}
RbyteArray
File::loadBinary()
{
if (canRead() == false)
return new byteArray(0);
jlong l = length();
RbyteArray ch = new byteArray(l);
RReader fin = getReader();
fin->read(ch, 0, ch->length());
return ch;
}
AUD_IReader* AUD_SRCResampleFactory::createReader()
{
AUD_IReader* reader = getReader();
if(reader != 0)
{
if(reader->getSpecs().rate != m_specs.rate)
{
reader = new AUD_SRCResampleReader(reader, m_specs);
AUD_NEW("reader")
}
}
bool WaveAudioEssenceReader::seekNextEditUnit() throw()
{
if (getReader() == 0)
{
return false;
}
// if (_editUnit < _descriptor->getContainerDuration() - 1)
if (_editUnit < _containerDuration - 1)
{
if (_currentStartPosition > 0)
{
++_editUnit;
}
_currentStartPosition = calcStartEditUnitData(_editUnit) + _dataOffset;
return (Position) getReader()->setPosition(_currentStartPosition, Reader::BEGIN) ==
_currentStartPosition;
}
return false;
}
AUD_IReader* AUD_EnvelopeFactory::createReader() const
{
AUD_IReader* reader = getReader();
EnvelopeParameters* param = new EnvelopeParameters();
param->arthreshold = m_arthreshold;
param->attack = pow(m_arthreshold, 1.0f/(reader->getSpecs().rate * m_attack));
param->release = pow(m_arthreshold, 1.0f/(reader->getSpecs().rate * m_release));
param->threshold = m_threshold;
return new AUD_CallbackIIRFilterReader(reader, 1, 2,
(doFilterIIR) envelopeFilter,
(endFilterIIR) endEnvelopeFilter,
param);
}
AUD_Reference<AUD_IReader> AUD_EnvelopeFactory::createReader()
{
AUD_Reference<AUD_IReader> reader = getReader();
EnvelopeParameters* param = new EnvelopeParameters();
param->arthreshold = m_arthreshold;
param->attack = pow(m_arthreshold, 1.0f/(static_cast<float>(reader->getSpecs().rate) * m_attack));
param->release = pow(m_arthreshold, 1.0f/(static_cast<float>(reader->getSpecs().rate) * m_release));
param->threshold = m_threshold;
return new AUD_CallbackIIRFilterReader(reader, 1, 2,
(doFilterIIR) envelopeFilter,
(endFilterIIR) endEnvelopeFilter,
param);
}
std::shared_ptr<IReader> Envelope::createReader()
{
std::shared_ptr<IReader> reader = getReader();
EnvelopeParameters* param = new EnvelopeParameters();
param->arthreshold = m_arthreshold;
param->attack = std::pow(m_arthreshold, 1.0f/(static_cast<float>(reader->getSpecs().rate) * m_attack));
param->release = std::pow(m_arthreshold, 1.0f/(static_cast<float>(reader->getSpecs().rate) * m_release));
param->threshold = m_threshold;
return std::shared_ptr<IReader>(new CallbackIIRFilterReader(reader, 1, 2,
(doFilterIIR) envelopeFilter,
(endFilterIIR) endEnvelopeFilter,
param));
}
