void ClientServer::handleFileFormatsResponse(FileFormats *response) { QSettings settings; QStringList filters; for (int i=0; i<response->formats_size(); i++) { FileFormat format = response->formats(i); QString filter = tr("%1 (").arg(QString::fromStdString(format.name())); for (int j=0; j<format.extension_size(); j++) { filter += tr("*.%1").arg(QString::fromStdString(format.extension(j))); if (j != format.extension_size()-1) filter += " "; } filter += ")"; filters << filter; } qDebug() << filters.join(";;"); QString dir = settings.value(lastOpenDirSettingPath()).toString(); FileDialog *remoteFileDialog = new FileDialog(m_channel, NULL, QString("Remote File Dialog"), dir, filters.join(";;")); connect(remoteFileDialog, SIGNAL(accepted()), this, SLOT(onAccepted())); connect(remoteFileDialog, SIGNAL(finished(int)), this, SLOT(onFinished(int))); remoteFileDialog->show(); delete response; }
Defaults::Defaults(void) { FileFormat *filef; FSSpec fspec; McoStatus status; int magic_num; int version; Str255 def = MONACO_DEFAULT; Str255 fold = MONACO_FOLDER; // set factory defaults printer_type = 1; input_type = DT_None; patch_format = 1; port = 1; // now try to load in the user defults filef = new FileFormat; ptocstr(def); ptocstr(fold); status = filef->openFilefromPref(&fspec,(char*)def,(char*)fold); if (status != MCO_SUCCESS) goto bail; status = filef->relRead(sizeof(int),(char*)&magic_num); if (status != MCO_SUCCESS) goto bail; if (magic_num != DEFAULTS_MAGIC_NUM) goto bail; status = filef->relRead(sizeof(int),(char*)&version); if (status != MCO_SUCCESS) goto bail; if (version > DEFAULTS_VERSION) goto bail; status = filef->relRead(sizeof(int),(char*)&printer_type); if (status != MCO_SUCCESS) goto bail; status = filef->relRead(sizeof(int),(char*)&input_type); if (status != MCO_SUCCESS) goto bail; status = filef->relRead(sizeof(int),(char*)&patch_format); if (status != MCO_SUCCESS) goto bail; status = filef->relRead(sizeof(int),(char*)&port); if (status != MCO_SUCCESS) goto bail; filef->closeFile(); bail: delete filef; }
TEST(FileFormatManagerTest, readFile) { FileFormat *format = FileFormatManager::instance().newFormatFromIdentifier("Avogadro: CML"); EXPECT_TRUE(format != NULL); if (!format) return; Molecule molecule; format->readFile(std::string(AVOGADRO_DATA) + "/data/ethane.cml", molecule); delete format; format = NULL; EXPECT_EQ(molecule.data("name").type(), Variant::String); EXPECT_EQ(molecule.data("name").toString(), "Ethane"); EXPECT_EQ(molecule.data("inchi").type(), Variant::String); EXPECT_EQ(molecule.data("inchi").toString(), "1/C2H6/c1-2/h1-2H3"); }
void BuildFileOps(OpRcPtrVec & ops, const Config& config, const ConstContextRcPtr & context, const FileTransform& fileTransform, TransformDirection dir) { std::string src = fileTransform.getSrc(); if(src.empty()) { std::ostringstream os; os << "The transform file has not been specified."; throw Exception(os.str().c_str()); } std::string filepath = context->resolveFileLocation(src.c_str()); CreateFileNoOp(ops, filepath); FileFormat* format = NULL; CachedFileRcPtr cachedFile; GetCachedFileAndFormat(format, cachedFile, filepath); if(!format) { std::ostringstream os; os << "The specified file load "; os << filepath << " appeared to succeed, but no format "; os << "was returned."; throw Exception(os.str().c_str()); } if(!cachedFile.get()) { std::ostringstream os; os << "The specified file load "; os << filepath << " appeared to succeed, but no cachedFile "; os << "was returned."; throw Exception(os.str().c_str()); } format->BuildFileOps(ops, config, context, cachedFile, fileTransform, dir); }
bool SimpleReadWriter::writeHeader( const ReaderContext& context, bool sorted, int argc, const char **argv, const char *version, const char *rgLine, bool omitSQLines) { char* buffer; size_t size; size_t used; char *localBuffer = NULL; writer->inHeader(true); if (! writer->getBuffer(&buffer, &size)) { return false; } char *writerBuffer = buffer; size_t writerBufferSize = size; while (!format->writeHeader(context, buffer, size, &used, sorted, argc, argv, version, rgLine, omitSQLines)) { delete[] localBuffer; size = 2 * size; localBuffer = new char[size]; buffer = localBuffer; } if (NULL == localBuffer) { _ASSERT(writerBuffer == buffer); writer->advance((unsigned)used, 0); writer->nextBatch(); } else { size_t bytesRemainingToWrite = used; size_t bytesWritten = 0; while (bytesRemainingToWrite > 0) { size_t bytesToWrite = __min(bytesRemainingToWrite, writerBufferSize); memcpy(writerBuffer, localBuffer + bytesWritten, bytesToWrite); writer->advance(bytesToWrite); writer->nextBatch(); if (!writer->getBuffer(&writerBuffer, &writerBufferSize)) { return false; } bytesWritten += bytesToWrite; bytesRemainingToWrite -= bytesToWrite; } delete[] localBuffer; } writer->inHeader(false); return true; }
Palette* load_palette(const char *filename) { std::string ext = base::string_to_lower(base::get_file_extension(filename)); Palette* pal = NULL; if (ext == "col") { pal = doc::file::load_col_file(filename); } else if (ext == "gpl") { pal = doc::file::load_gpl_file(filename); } else { FileFormat* ff = FileFormatsManager::instance()->getFileFormatByExtension(ext.c_str()); if (ff->support(FILE_SUPPORT_LOAD)) { FileOp* fop = fop_to_load_document(NULL, filename, FILE_LOAD_SEQUENCE_NONE | FILE_LOAD_ONE_FRAME); if (fop && !fop->has_error()) { fop_operate(fop, NULL); fop_post_load(fop); if (fop->document && fop->document->sprite() && fop->document->sprite()->getPalette(FrameNumber(0))) { pal = new Palette( *fop->document->sprite()->getPalette(FrameNumber(0))); // TODO remove this line when support for palettes with less // than 256 colors is added. pal->resize(Palette::MaxColors); } delete fop->document; fop_done(fop); } } } if (pal) pal->setFilename(filename); return pal; }
/******************************************************************************************** > FormatEntry* FilterManager::FindFormatEntryFromName(const StringBase& FormatName) const Author: Colin_Barfoot (Xara Group Ltd) <*****@*****.**> Created: 10/12/96 Inputs: FormatName: The name of a FileFormat given in the FileFormat's constructor which has subsequently been Added to this FilterManager. Returns: A pointer to the FileFormat with the name given or NULL if none was found Purpose: Finds the one & only FileFormat with the given FormatName Used by Xtra's mainly ********************************************************************************************/ FormatEntry* FilterManager::FindFormatEntryFromName(const StringBase& FormatName) const { for (UINT32 index = 0; index < GetLastFormatID(); ++index) { FormatEntry* pFormatEntry = GetFormats()[index]; if (pFormatEntry != NULL) { FileFormat* pFormat = pFormatEntry->GetFormat(); if (pFormat->GetName() == FormatName) { return pFormatEntry; } } else { // we'll ignore this one } } return NULL; }
bool save_palette(const char *filename, Palette* pal) { std::string ext = base::string_to_lower(base::get_file_extension(filename)); bool success = false; if (ext == "col") { success = doc::file::save_col_file(pal, filename); } else if (ext == "gpl") { success = doc::file::save_gpl_file(pal, filename); } else { FileFormat* ff = FileFormatsManager::instance()->getFileFormatByExtension(ext.c_str()); if (ff->support(FILE_SUPPORT_SAVE)) { app::Context tmpContext; doc::Document* doc = tmpContext.documents().add( 16, 16, doc::ColorMode::INDEXED, Palette::MaxColors); Sprite* sprite = doc->sprite(); doc->sprite()->setPalette(pal, false); LayerImage* layer = dynamic_cast<LayerImage*>(sprite->folder()->getFirstLayer()); Image* image = layer->getCel(FrameNumber(0))->image(); int x, y, c; for (y=c=0; y<16; y++) for (x=0; x<16; x++) image->putPixel(x, y, c++); doc->setFilename(filename); success = (save_document(&tmpContext, doc) == 0); doc->close(); delete doc; } } return success; }
void Baker::bake(std::ostream & os) const { FileFormat* fmt = FormatRegistry::GetInstance().getFileFormatByName(getImpl()->formatName_); if(!fmt) { std::ostringstream err; err << "The format named '" << getImpl()->formatName_; err << "' could not be found. "; throw Exception(err.str().c_str()); } try { fmt->Write(*this, getImpl()->formatName_, os); } catch(std::exception & e) { std::ostringstream err; err << "Error baking " << getImpl()->formatName_ << ":"; err << e.what(); throw Exception(err.str().c_str()); } // // TODO: // // - throw exception when we don't have inputSpace and targetSpace // at least set // - check limits of shaper and target, throw exception if we can't // write that much data in x format // - check that the shaper is 1D transform only, throw excpetion // - check the file format supports shapers, 1D and 3D // - add some checks to make sure we are monotonic // - deal with the case of writing out non cube formats (1D only) // - do a compare between ocio transform and output lut transform // throw error if we going beyond tolerance // }
bool sameEncoding(const FileFormat & src, const FileFormat & tgt) { if (src.equals(tgt)) return true; switch (src.type) { case FFTutf8n: return (tgt.type == FFTutf8); case FFTutf16be: return (tgt.type == FFTutf16); case FFTutf32be: return (tgt.type == FFTutf32); } return false; }
bool FileFormatManager::removeFormat(const std::string &identifier) { FormatIdVector ids = m_identifiers[identifier]; m_identifiers.erase(identifier); if (ids.empty()) return false; for (FormatIdVector::const_iterator it = ids.begin(), itEnd = ids.end(); it != itEnd; ++it) { FileFormat *fmt = m_formats[*it]; if (fmt == NULL) continue; removeFromMap(m_mimeTypes, fmt->mimeTypes(), *it); removeFromMap(m_fileExtensions, fmt->fileExtensions(), *it); m_formats[*it] = NULL; delete fmt; } return true; }
bool processPartitionCommand(ISocket * masterSocket, MemoryBuffer & msg, MemoryBuffer & results) { FileFormat srcFormat; FileFormat tgtFormat; unsigned whichInput; RemoteFilename fullPath; offset_t totalSize; offset_t thisOffset; offset_t thisSize; unsigned thisHeaderSize; unsigned numParts; bool compressedInput = false; unsigned compatflags = 0; srcFormat.deserialize(msg); tgtFormat.deserialize(msg); msg.read(whichInput); fullPath.deserialize(msg); msg.read(totalSize); msg.read(thisOffset); msg.read(thisSize); msg.read(thisHeaderSize); msg.read(numParts); if (msg.remaining()) msg.read(compressedInput); if (msg.remaining()) msg.read(compatflags); // not yet used StringAttr decryptkey; if (msg.remaining()) msg.read(decryptkey); if (msg.remaining()) { srcFormat.deserializeExtra(msg, 1); tgtFormat.deserializeExtra(msg, 1); } StringBuffer text; fullPath.getRemotePath(text); LOG(MCdebugProgress, unknownJob, "Process partition %d(%s)", whichInput, text.str()); Owned<IFormatProcessor> processor = createFormatProcessor(srcFormat, tgtFormat, true); Owned<IOutputProcessor> target = createOutputProcessor(tgtFormat); processor->setTarget(target); processor->setPartitionRange(totalSize, thisOffset, thisSize, thisHeaderSize, numParts); processor->setSource(whichInput, fullPath, compressedInput, decryptkey); processor->calcPartitions(NULL); PartitionPointArray partition; processor->getResults(partition); serialize(partition, results); return true; }
bool SimpleReadWriter::writePairs( const ReaderContext& context, Read **reads /* array of size NUM_READS_PER_PAIR */, PairedAlignmentResult *result, int nResults, SingleAlignmentResult **singleResults /* array of size NUM_READS_PER_PAIR*/, int *nSingleResults /* array of size NUM_READS_PER_PAIR*/, bool firstIsPrimary) { bool retVal = false; // // We need to write all alignments for the pair into the same buffer, so that a write from // some other thread doesn't separate them. We make two passes, trying to write into the // existing buffer, and then into a clean one. If that doesn't work, abort the alignment // run and ask for a bigger write buffer. // const int staticUsedBufferSize = 2000; size_t staticUsedBuffer[NUM_READS_PER_PAIR][staticUsedBufferSize]; GenomeLocation staticLocationBuffer[NUM_READS_PER_PAIR][staticUsedBufferSize]; GenomeLocation *finalLocations[NUM_READS_PER_PAIR]; size_t *usedBuffer[NUM_READS_PER_PAIR]; if (nResults + nSingleResults[0] <= staticUsedBufferSize && nResults + nSingleResults[1] <= staticUsedBufferSize) { usedBuffer[0] = staticUsedBuffer[0]; usedBuffer[1] = staticUsedBuffer[1]; finalLocations[0] = staticLocationBuffer[0]; finalLocations[1] = staticLocationBuffer[1]; } else { usedBuffer[0] = new size_t[nResults * NUM_READS_PER_PAIR + nSingleResults[0] + nSingleResults[1]]; usedBuffer[1] = usedBuffer[0] + nResults + nSingleResults[0]; finalLocations[0] = new GenomeLocation[nResults * NUM_READS_PER_PAIR + nSingleResults[0] + nSingleResults[1]]; finalLocations[1] = finalLocations[0] + nResults + nSingleResults[0]; } // // For paired reads, we need to have the same QNAME for both of them, and it needs to be unique among all other // reads in the dataset. For now, all we do is see if the read names end in /1 and /2, and if so truncate them. // size_t idLengths[NUM_READS_PER_PAIR]; idLengths[0] = reads[0]->getIdLength(); idLengths[1] = reads[1]->getIdLength(); if (idLengths[0] == idLengths[1] && idLengths[0] > 2 && reads[0]->getId()[idLengths[0]-2] == '/' && reads[1]->getId()[idLengths[0]-2] == '/') { char lastChar0, lastChar1; lastChar0 = reads[0]->getId()[idLengths[0] - 1]; lastChar1 = reads[1]->getId()[idLengths[1] - 1]; if ((lastChar0 == '1' || lastChar0 == '2') && (lastChar1 == '1' || lastChar1 == '2') && lastChar0 != lastChar1) { idLengths[0] -= 2; idLengths[1] -= 2; } } for (int pass = 0; pass < 2; pass++) { char* buffer; size_t size; size_t used = 0; bool fitInBuffer = true; if (!writer->getBuffer(&buffer, &size)) { goto done; } // // Write all of the pair alignments into the buffer. // for (int whichAlignmentPair = 0; whichAlignmentPair < nResults; whichAlignmentPair++) { reads[0]->setAdditionalFrontClipping(0); reads[1]->setAdditionalFrontClipping(0); GenomeLocation locations[2]; locations[0] = result[whichAlignmentPair].status[0] != NotFound ? result[whichAlignmentPair].location[0] : InvalidGenomeLocation; locations[1] = result[whichAlignmentPair].status[1] != NotFound ? result[whichAlignmentPair].location[1] : InvalidGenomeLocation; int writeOrder[2]; // The order in which we write the reads, which is just numerical by genome location. SO writeOrder[0] gets written first, and writeOrder[1] second. if (locations[0] <= locations[1]) { writeOrder[0] = 0; writeOrder[1] = 1; } else { writeOrder[0] = 1; writeOrder[1] = 0; } bool secondReadLocationChanged; int cumulativePositiveAddFrontClipping[NUM_READS_PER_PAIR] = { 0, 0 }; do { size_t tentativeUsed = 0; secondReadLocationChanged = false; for (int firstOrSecond = 0; firstOrSecond < NUM_READS_PER_PAIR; firstOrSecond++) { // looping over the order in which the reads are written, not the order in which they arrived int whichRead = writeOrder[firstOrSecond]; // // Loop until we get a write with no additional front clipping. // int addFrontClipping = 0; while (!format->writeRead(context, &lvc, buffer + used + tentativeUsed, size - used - tentativeUsed, &usedBuffer[firstOrSecond][whichAlignmentPair], idLengths[whichRead], reads[whichRead], result[whichAlignmentPair].status[whichRead], result[whichAlignmentPair].mapq[whichRead], locations[whichRead], result[whichAlignmentPair].direction[whichRead], whichAlignmentPair != 0 || !firstIsPrimary, &addFrontClipping, true, writeOrder[firstOrSecond] == 0, reads[1 - whichRead], result[whichAlignmentPair].status[1 - whichRead], locations[1 - whichRead], result[whichAlignmentPair].direction[1 - whichRead], result[whichAlignmentPair].alignedAsPair)) { if (0 == addFrontClipping || locations[whichRead] == InvalidGenomeLocation) { // // We failed because we ran out of buffer. // goto blownBuffer; } if (1 == firstOrSecond) { // // If the location of the second read changed, we need to redo the first one as well, because it includes an offset to the second read // secondReadLocationChanged = true; } const Genome::Contig *originalContig = genome->getContigAtLocation(locations[whichRead]); const Genome::Contig *newContig = genome->getContigAtLocation(locations[whichRead] + addFrontClipping); if (newContig != originalContig || NULL == newContig || locations[whichRead] + addFrontClipping > originalContig->beginningLocation + originalContig->length - genome->getChromosomePadding()) { // // Altering this would push us over a contig boundary. Just give up on the read. // result[whichAlignmentPair].status[whichRead] = NotFound; result[whichAlignmentPair].location[whichRead] = InvalidGenomeLocation; locations[whichRead] = InvalidGenomeLocation; } else { if (addFrontClipping > 0) { cumulativePositiveAddFrontClipping[firstOrSecond] += addFrontClipping; reads[whichRead]->setAdditionalFrontClipping(cumulativePositiveAddFrontClipping[firstOrSecond]); } locations[whichRead] += addFrontClipping; } } // While formatting didn't work tentativeUsed += usedBuffer[firstOrSecond][whichAlignmentPair]; } // for first or second read } while (secondReadLocationChanged); used += usedBuffer[0][whichAlignmentPair] + usedBuffer[1][whichAlignmentPair]; // // Both reads are written into the buffer. Save the final locations we used for when we commit. // for (int whichRead = 0; whichRead < NUM_READS_PER_PAIR; whichRead++) { finalLocations[whichRead][whichAlignmentPair] = locations[whichRead]; } } // for each pair. // // Now write the single alignments. // for (int whichRead = 0; whichRead < NUM_READS_PER_PAIR; whichRead++) { for (int whichAlignment = 0; whichAlignment < nSingleResults[whichRead]; whichAlignment++) { int addFrontClipping; reads[whichRead]->setAdditionalFrontClipping(0); GenomeLocation location = singleResults[whichRead][whichAlignment].status != NotFound ? singleResults[whichRead][whichAlignment].location : InvalidGenomeLocation; int cumulativePositiveAddFrontClipping = 0; while (!format->writeRead(context, &lvc, buffer + used, size - used, &usedBuffer[whichRead][nResults + whichAlignment], reads[whichRead]->getIdLength(), reads[whichRead], singleResults[whichRead][whichAlignment].status, singleResults[whichRead][whichAlignment].mapq, location, singleResults[whichRead][whichAlignment].direction, true, &addFrontClipping)) { if (0 == addFrontClipping) { goto blownBuffer; } const Genome::Contig *originalContig = genome->getContigAtLocation(location); const Genome::Contig *newContig = genome->getContigAtLocation(location + addFrontClipping); if (newContig != originalContig || NULL == newContig || location + addFrontClipping > originalContig->beginningLocation + originalContig->length - genome->getChromosomePadding()) { // // Altering this would push us over a contig boundary. Just give up on the read. // singleResults[whichRead][whichAlignment].status = NotFound; location = InvalidGenomeLocation; } else { if (addFrontClipping > 0) { cumulativePositiveAddFrontClipping += addFrontClipping; reads[whichRead]->setAdditionalFrontClipping(cumulativePositiveAddFrontClipping); } location += addFrontClipping; } } finalLocations[whichRead][nResults + whichAlignment] = location; used += usedBuffer[whichRead][nResults + whichAlignment]; } // For each single alignment of a read } // For each read // // They all fit into the buffer. // // // Commit the updates for the pairs. // for (int whichReadPair = 0; whichReadPair < nResults; whichReadPair++) { for (int firstOrSecond = 0; firstOrSecond < NUM_READS_PER_PAIR; firstOrSecond++) { // adjust for write order int writeFirstOrSecond = (!!firstOrSecond) ^ (finalLocations[0][whichReadPair] > finalLocations[1][whichReadPair]); // goofy looking !! converts int to bool writer->advance((unsigned)usedBuffer[firstOrSecond][whichReadPair], finalLocations[writeFirstOrSecond][whichReadPair] == InvalidGenomeLocation ? finalLocations[1 - writeFirstOrSecond][whichReadPair] : finalLocations[writeFirstOrSecond][whichReadPair]); } } // // Now commit the updates for the single reads. // for (int whichRead = 0; whichRead < NUM_READS_PER_PAIR; whichRead++) { for (int whichAlignment = 0; whichAlignment < nSingleResults[whichRead]; whichAlignment++) { writer->advance((unsigned)usedBuffer[whichRead][nResults + whichAlignment], finalLocations[whichRead][nResults + whichAlignment]); } } retVal = true; break; blownBuffer: if (pass > 0) { WriteErrorMessage("Unable to fit all alignments for one read pair into a single write buffer. Increase the size of the write buffer with -wbs, or reduce the number of alignments with -om or -omax\n"); WriteErrorMessage("Read id: '%.*s'\n", reads[0]->getIdLength(), reads[0]->getId()); soft_exit(1); } if (!writer->nextBatch()) { goto done; } } // For each buffer full pass done: if (usedBuffer[0] != staticUsedBuffer[0]) { delete[] usedBuffer[0]; usedBuffer[0] = usedBuffer[1] = NULL; delete[] finalLocations[0]; finalLocations[0] = finalLocations[1] = NULL; } reads[0]->setAdditionalFrontClipping(0); reads[1]->setAdditionalFrontClipping(0); return retVal; }
McoStatus PrinterType::Save(FSSpec *fspec) { int i; McoStatus status = MCO_SUCCESS; FileFormat *filef; int magic_num = PRINTERTYPE_MAGICNUM; int version = PRINTERTYPE_VERSION; filef = new FileFormat; // status = filef->createFilewithtype(fspec,smSystemScript,'Mprn','MCO6'); // if (status != MCO_SUCCESS) goto bail; status = filef->openFile(fspec); if (status != MCO_SUCCESS) goto bail; status = filef->relWrite(sizeof(int),(char*)&magic_num); if (status != MCO_SUCCESS) goto bailclose; status = filef->relWrite(sizeof(int),(char*)&version); if (status != MCO_SUCCESS) goto bailclose; status = filef->relWrite(sizeof(ConData),(char*)&data); if (status != MCO_SUCCESS) goto bailclose; status = filef->relWrite(sizeof(int),(char*)&num_hands); if (status != MCO_SUCCESS) goto bailclose; status = filef->relWrite(sizeof(double)*31,(char*)x_hands); if (status != MCO_SUCCESS) goto bailclose; status = filef->relWrite(sizeof(double)*31,(char*)y_hands); if (status != MCO_SUCCESS) goto bailclose; status = filef->relWrite(sizeof(int),(char*)&sim_num); if (status != MCO_SUCCESS) goto bailclose; status = filef->relWrite(sizeof(int),(char*)&num_tweaks); if (status != MCO_SUCCESS) goto bailclose; for (i=0; i<num_tweaks; i++) { status = filef->relWrite(sizeof(Tweak_Element),(char*)tweaks[i]); if (status != MCO_SUCCESS) goto bailclose; } filef->setInfo(fspec,MONACO_SIG,'MCO6'); bailclose: filef->closeFile(); bail: delete filef; return status; }
FileFormatInstance::FileFormatInstance( const FileFormat& fmt ) : UIObject( (*API->FileFormat->CreateFileFormatInstance)( ModuleHandle(), fmt.Handle() ) ) { if ( IsNull() ) throw APIFunctionError( "CreateFileFormatInstance" ); }
bool SimpleReadWriter::writeReads( const ReaderContext& context, Read *read, SingleAlignmentResult *results, int nResults, bool firstIsPrimary) { char* buffer; size_t size; size_t used; bool result = false; for (int i = 0; i < nResults; i++) { if (results[i].status == NotFound) { results[i].location = InvalidGenomeLocation; } } // // We need to keep track of the offsets of all of the alignments in the output buffer so we can commit them. However, // we want to avoid dynamic memory allocation as much as possible. So, we have a static buffer on the stack that's big enough // for the great majority of cases, and then allocate dynamically if that's too small. Makes for annoying, but efficient // code. // const int staticUsedBufferSize = 2000; size_t staticUsedBuffer[staticUsedBufferSize]; GenomeLocation staticFinalLocationsBuffer[staticUsedBufferSize]; size_t *usedBuffer; GenomeLocation *finalLocations; if (nResults <= staticUsedBufferSize) { usedBuffer = staticUsedBuffer; finalLocations = staticFinalLocationsBuffer; } else { usedBuffer = new size_t[nResults]; finalLocations = new GenomeLocation[nResults]; } for (int pass = 0; pass < 2; pass++) { // Make two passes, one with whatever buffer space is left and one with a clean buffer. bool blewBuffer = false; if (!writer->getBuffer(&buffer, &size)) { goto done; } used = 0; for (int whichResult = 0; whichResult < nResults; whichResult++) { int addFrontClipping = 0; read->setAdditionalFrontClipping(0); int cumulativeAddFrontClipping = 0; finalLocations[whichResult] = results[whichResult].location; while (!format->writeRead(context, &lvc, buffer + used, size - used, &usedBuffer[whichResult], read->getIdLength(), read, results[whichResult].status, results[whichResult].mapq, finalLocations[whichResult], results[whichResult].direction, (whichResult > 0) || !firstIsPrimary, &addFrontClipping)) { if (0 == addFrontClipping) { blewBuffer = true; break; } // redo if read modified (e.g. to add soft clipping, or move alignment for a leading I. const Genome::Contig *originalContig = results[whichResult].status == NotFound ? NULL : genome->getContigAtLocation(results[whichResult].location); const Genome::Contig *newContig = results[whichResult].status == NotFound ? NULL : genome->getContigAtLocation(results[whichResult].location + addFrontClipping); if (newContig == NULL || newContig != originalContig || finalLocations[whichResult] + addFrontClipping > originalContig->beginningLocation + originalContig->length - genome->getChromosomePadding()) { // // Altering this would push us over a contig boundary. Just give up on the read. // results[whichResult].status = NotFound; results[whichResult].location = InvalidGenomeLocation; finalLocations[whichResult] = InvalidGenomeLocation; } else { cumulativeAddFrontClipping += addFrontClipping; if (addFrontClipping > 0) { read->setAdditionalFrontClipping(cumulativeAddFrontClipping); } finalLocations[whichResult] = results[whichResult].location + cumulativeAddFrontClipping; } } // while formatting doesn't work if (blewBuffer) { break; } used += usedBuffer[whichResult]; _ASSERT(used <= size); if (used > 0xffffffff) { WriteErrorMessage("SimpleReadWriter:writeReads: used too big\n"); soft_exit(1); } } // for each result. if (!blewBuffer) { // // Everything worked OK. // for (int whichResult = 0; whichResult < nResults; whichResult++) { writer->advance((unsigned)usedBuffer[whichResult], finalLocations[whichResult]); } result = true; goto done; } if (pass == 1) { WriteErrorMessage("Failed to write into fresh buffer; trying providing the -wbs switch with a larger value\n"); soft_exit(1); } if (!writer->nextBatch()) { goto done; } } // for each pass (i.e., not empty, empty buffer) done: if (usedBuffer != staticUsedBuffer) { delete[] usedBuffer; usedBuffer = NULL; delete[] finalLocations; finalLocations = NULL; } read->setAdditionalFrontClipping(0); return result; }
void FileDialog_import(EditorState *state) { std::string path = getSaveLoadDirectory(state->settings->get("save_directory"), state->isInstalled); const char* filters[] = {"*.nbe"}; const char *cfile = tinyfd_openFileDialog("Import Nodes", path.c_str(), 1, filters, 0); if (!cfile) return; std::string file = cfile; if (file == "") return; std::cerr << file.c_str() << std::endl; // Get file parser FileFormat *parser = getFromType(FILE_FORMAT_NBE, state); if (!parser) { state->device->getGUIEnvironment()->addMessageBox(L"Unable to open", L"File format does not exist."); return; } // Get directory, and load std::cerr << "Reading from " << file << std::endl; Project *tmp = parser->read(file, state->project); if (tmp) { state->project->remesh(); } else { switch(parser->error_code) { case EFFE_IO_ERROR: state->device->getGUIEnvironment()->addMessageBox(L"Unable to open", L"Failed to open the file\n\t(Does it not exist, or is it readonly?)"); break; case EFFE_READ_OLD_VERSION: state->device->getGUIEnvironment()->addMessageBox(L"Unable to open", L"This file is outdated and is not supported"); break; case EFFE_READ_NEW_VERSION: state->device->getGUIEnvironment()->addMessageBox(L"Unable to open", L"This file was created with a new version of NBE\n\t(Update your copy)"); break; case EFFE_READ_PARSE_ERROR: state->device->getGUIEnvironment()->addMessageBox(L"Unable to open", L"An error occurred while reading the file - it may be corrupted\n\t(This should never happen)"); break; case EFFE_READ_WRONG_TYPE: state->device->getGUIEnvironment()->addMessageBox(L"Unable to open", L"The file is not in the correct format\n\t(Are you opening the wrong type of file?)"); break; default: state->device->getGUIEnvironment()->addMessageBox(L"Unable to open", L"Unknown error"); break; } delete parser; parser = NULL; } }
// The event handler for the main menu McoStatus ToneTab::DoEvents(short item, Point clickPoint, WindowCode *wc, int32 *numwc, void **data,Boolean &changed) { int didit = 0; int i,j; McoStatus status = MCO_SUCCESS; short item2 = item - startNum; Str255 prompt; StandardFileReply soutReply,sinReply; Str255 outname = "\p"; SFTypeList filelist; Str255 inname; Rect r1; short iType; Handle iHandle; WindowPtr oldP; GetPort(&oldP); SetPort( dp ) ; // no codes passed back *numwc = 0; for (i=0; i<numControls; i++) { status = controls[i]->DoEvents(item,clickPoint,wc,numwc,data,changed,&didit); if (status) return status; if (changed) { doc->changedLinearTone = 1; last_changed = 1; CopyOutofControl(i); CopyIntoControl(i); } else last_changed = 0; if (didit) return status; } if (item2 == EXPORT) { if (doc->calCurves) { GetIndString(prompt,PROMPT_STRINGS,STANDARD_PROMPT); StandardPutFile(prompt, outname, &soutReply); if(soutReply.sfGood) { memcpy(outname, soutReply.sfFile.name, *(soutReply.sfFile.name)+1); PathNameFromDirID(soutReply.sfFile.parID, soutReply.sfFile.vRefNum, outname); ptocstr(outname); status = doc->calCurves->exportTone((char*)outname); if (status) McoErrorAlert(status); else { FileFormat ff; ff.setInfo(&soutReply.sfFile,MONACO_SIG,'TEXT'); } } } } else if (item2 == IMPORT) { if (doc->calCurves) { filelist[0] = 'TEXT'; StandardGetFile(0L, 1, filelist, &sinReply); if(sinReply.sfGood) { memcpy(inname, sinReply.sfFile.name, *(sinReply.sfFile.name)+1); PathNameFromDirID(sinReply.sfFile.parID, sinReply.sfFile.vRefNum, inname); ptocstr(inname); status = doc->calCurves->importTone((char*)inname); if (status) McoErrorAlert(status); else { CopyIntoControl(-1); doc->changedLinearTone = 1; } status = MCO_SUCCESS; } } } else { GetDItem (dp, DESCRIPTION+startNum, &iType, (Handle*)&iHandle, &r1); GetIText(iHandle,inname); if (inname[0] > 100) inname[0] = 100; ptocstr(inname); strcpy(doc->printData->setting.toneDesc,(char*)inname); } SetPort(oldP); return status; }
McoStatus PrinterType::Save(void) { int i; StandardFileReply soutReply; Str255 prompt; Str255 outname = "\p"; McoStatus status = MCO_SUCCESS; FileFormat *filef; int magic_num = PRINTERTYPE_MAGICNUM; int version = PRINTERTYPE_VERSION; GetIndString(prompt,PROMPT_STRINGS,SETTINGS_PROMPT); StandardPutFile(prompt, outname, &soutReply); if(!soutReply.sfGood) return MCO_CANCEL; filef = new FileFormat; status = filef->createFilewithtype(&soutReply.sfFile,soutReply.sfScript,MONACO_SIG,'MCO6'); if (status != MCO_SUCCESS) goto bail; status = filef->relWrite(sizeof(int),(char*)&magic_num); if (status != MCO_SUCCESS) goto bailclose; status = filef->relWrite(sizeof(int),(char*)&version); if (status != MCO_SUCCESS) goto bailclose; status = filef->relWrite(sizeof(ConData),(char*)&data); if (status != MCO_SUCCESS) goto bailclose; status = filef->relWrite(sizeof(int),(char*)&num_hands); if (status != MCO_SUCCESS) goto bailclose; status = filef->relWrite(sizeof(double)*31,(char*)x_hands); if (status != MCO_SUCCESS) goto bailclose; status = filef->relWrite(sizeof(double)*31,(char*)y_hands); if (status != MCO_SUCCESS) goto bailclose; status = filef->relWrite(sizeof(int),(char*)&sim_num); if (status != MCO_SUCCESS) goto bailclose; status = filef->relWrite(sizeof(int),(char*)&num_tweaks); if (status != MCO_SUCCESS) goto bailclose; for (i=0; i<num_tweaks; i++) { status = filef->relWrite(sizeof(Tweak_Element),(char*)tweaks[i]); if (status != MCO_SUCCESS) goto bailclose; } bailclose: filef->closeFile(); bail: delete filef; return status; }
Defaults::~Defaults(void) { FileFormat *filef; FSSpec fspec; McoStatus status; int magic_num = DEFAULTS_MAGIC_NUM; int version = DEFAULTS_VERSION; Str255 def = MONACO_DEFAULT; Str255 fold = MONACO_FOLDER; // now try to load in the user defults filef = new FileFormat; ptocstr(def); ptocstr(fold); status = filef->createFileinPref(&fspec,(char*)def,(char*)fold); if (status != MCO_SUCCESS) return; status = filef->openFile(&fspec); if (status != MCO_SUCCESS) return; status = filef->relWrite(sizeof(int),(char*)&magic_num); if (status != MCO_SUCCESS) return; status = filef->relWrite(sizeof(int),(char*)&version); if (status != MCO_SUCCESS) return; status = filef->relWrite(sizeof(int),(char*)&printer_type); if (status != MCO_SUCCESS) return; status = filef->relWrite(sizeof(int),(char*)&input_type); if (status != MCO_SUCCESS) return; status = filef->relWrite(sizeof(int),(char*)&patch_format); if (status != MCO_SUCCESS) return; status = filef->relWrite(sizeof(int),(char*)&port); if (status != MCO_SUCCESS) return; filef->setInfo(&fspec,MONACO_SIG,'MCO7'); filef->closeFile(); delete filef; }
bool PlotIO::write(const QString& path, const ros::Time& start, const ros::Time& end) { FileFormat* io = 0; if(path.endsWith(".bag")) io = new BagFormat; else if(path.endsWith(".csv")) io = new CSVFormat; if(!io) { fprintf(stderr, "Could not find output format\n"); return false; } if(!io->init(path, start)) return false; QLinkedList<Plot::LinkedBufferIterator> its = m_rootPlot->iterators(io->defaultFlags()); io->writeHeader(its); QVector<Plot::LinkedBufferIterator*> to_write(its.size(), 0); while(1) { ros::Time stamp = ros::Time(0); qFill(to_write, (Plot::LinkedBufferIterator*)0); // Get a list of iterators with the next timestamp int i = 0; for(QLinkedList<Plot::LinkedBufferIterator>::iterator it = its.begin(); it != its.end(); ++it, ++i) { Plot::LinkedBufferIterator& buf_it = *it; if(!buf_it.isValid()) continue; const Plot::DataPoint& point = *buf_it; if(point.time < stamp || stamp == ros::Time(0)) { qFill(to_write, (Plot::LinkedBufferIterator*)0); to_write[i] = &buf_it; stamp = point.time; } else if(point.time == stamp) to_write[i] = &buf_it; } if(stamp == ros::Time(0)) break; if(end != ros::Time(0) && stamp > end) break; if(stamp >= start) io->writeData(stamp, to_write); // Advance all used iterators Q_FOREACH(Plot::LinkedBufferIterator* it, to_write) { if(!it) continue; ++(*it); } } delete io; return true; }
int main (int commands, char *control []) { FileFormat *exe = new FileFormat (); return (exe->Start_Execution (commands, control)); }
McoStatus PrinterType::Load(FSSpec *fspec) { int i; McoStatus status = MCO_SUCCESS; FileFormat *filef; int magic_num; int version; filef = new FileFormat; status = filef->openFile(fspec); if (status != MCO_SUCCESS) goto bail; status = filef->relRead(sizeof(int),(char*)&magic_num); if (status != MCO_SUCCESS) goto bailclose; status = filef->relRead(sizeof(int),(char*)&version); if (status != MCO_SUCCESS) goto bailclose; if (version != PRINTERTYPE_VERSION) goto bailclose; status = filef->relRead(sizeof(ConData),(char*)&data); if (status != MCO_SUCCESS) goto bailclose; status = filef->relRead(sizeof(int),(char*)&num_hands); if (status != MCO_SUCCESS) goto bailclose; status = filef->relRead(sizeof(double)*31,(char*)x_hands); if (status != MCO_SUCCESS) goto bailclose; status = filef->relRead(sizeof(double)*31,(char*)y_hands); if (status != MCO_SUCCESS) goto bailclose; status = filef->relRead(sizeof(int),(char*)&sim_num); if (status != MCO_SUCCESS) goto bailclose; status = filef->relRead(sizeof(int),(char*)&num_tweaks); if (status != MCO_SUCCESS) goto bailclose; for (i=0; i<num_tweaks; i++) { if (!tweaks[i]) tweaks[i] = new Tweak_Element(0L); if (!tweaks[i]) goto bailclose; status = filef->relRead(sizeof(Tweak_Element),(char*)tweaks[i]); if (status != MCO_SUCCESS) goto bailclose; } bailclose: filef->closeFile(); bail: delete filef; return status; }