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)); }