ItemSequence_t
GeneratePDFFunction::evaluate(const ExternalFunction::Arguments_t& args,
const zorba::StaticContext* aStaticContext,
const zorba::DynamicContext* aDynamincContext) const
{
Iterator_t lIter = args[0]->getIterator();
lIter->open();
Item outputFormat;
lIter->next(outputFormat);
lIter->close();
jthrowable lException = 0;
static JNIEnv* env;
try {
env = zorba::jvm::JavaVMSingleton::getInstance(aStaticContext)->getEnv();
jstring outFotmatString = env->NewStringUTF(outputFormat.getStringValue().c_str());
// Local variables
std::ostringstream os;
Zorba_SerializerOptions_t lOptions;
Serializer_t lSerializer = Serializer::createSerializer(lOptions);
jclass fopFactoryClass;
jobject fopFactory;
jmethodID fopFactoryNewInstance;
jclass byteArrayOutputStreamClass;
jobject byteArrayOutputStream;
jobject fop;
jmethodID newFop;
jclass transformerFactoryClass;
jobject transformerFactory;
jobject transormer;
jclass stringReaderClass;
jobject stringReader;
jstring xmlUTF;
const char* xml;
std::string xmlString;
jclass streamSourceClass;
jobject streamSource;
jobject defaultHandler;
jclass saxResultClass;
jobject saxResult;
jboolean isCopy;
jbyteArray res;
Item base64;
String resStore;
jsize dataSize;
jbyte* dataElements;
Item item;
lIter = args[1]->getIterator();
lIter->open();
lIter->next(item);
lIter->close();
// Searialize Item
SingletonItemSequence lSequence(item);
lSerializer->serialize(&lSequence, os);
xmlString = os.str();
xml = xmlString.c_str();
// Create an OutputStream
byteArrayOutputStreamClass = env->FindClass("java/io/ByteArrayOutputStream");
CHECK_EXCEPTION(env);
byteArrayOutputStream = env->NewObject(byteArrayOutputStreamClass,
env->GetMethodID(byteArrayOutputStreamClass, "<init>", "()V"));
CHECK_EXCEPTION(env);
// Create a FopFactory instance
fopFactoryClass = env->FindClass("org/apache/fop/apps/FopFactory");
CHECK_EXCEPTION(env);
fopFactoryNewInstance = env->GetStaticMethodID(fopFactoryClass, "newInstance", "()Lorg/apache/fop/apps/FopFactory;");
CHECK_EXCEPTION(env);
fopFactory = env->CallStaticObjectMethod(fopFactoryClass, fopFactoryNewInstance);
CHECK_EXCEPTION(env);
// Create the Fop
newFop = env->GetMethodID(fopFactoryClass, "newFop", "(Ljava/lang/String;Ljava/io/OutputStream;)Lorg/apache/fop/apps/Fop;");
CHECK_EXCEPTION(env);
fop = env->CallObjectMethod(fopFactory,
newFop,
outFotmatString, byteArrayOutputStream);
CHECK_EXCEPTION(env);
// Create the Transformer
transformerFactoryClass = env->FindClass("javax/xml/transform/TransformerFactory");
CHECK_EXCEPTION(env);
transformerFactory = env->CallStaticObjectMethod(transformerFactoryClass,
env->GetStaticMethodID(transformerFactoryClass, "newInstance", "()Ljavax/xml/transform/TransformerFactory;"));
CHECK_EXCEPTION(env);
transormer = env->CallObjectMethod(transformerFactory,
env->GetMethodID(transformerFactoryClass, "newTransformer", "()Ljavax/xml/transform/Transformer;"));
CHECK_EXCEPTION(env);
// Create Source
xmlUTF = env->NewStringUTF(xml);
stringReaderClass = env->FindClass("java/io/StringReader");
CHECK_EXCEPTION(env);
stringReader = env->NewObject(stringReaderClass,
env->GetMethodID(stringReaderClass, "<init>", "(Ljava/lang/String;)V"), xmlUTF);
CHECK_EXCEPTION(env);
streamSourceClass = env->FindClass("javax/xml/transform/stream/StreamSource");
CHECK_EXCEPTION(env);
streamSource = env->NewObject(streamSourceClass,
env->GetMethodID(streamSourceClass, "<init>", "(Ljava/io/Reader;)V"), stringReader);
CHECK_EXCEPTION(env);
// Create the SAXResult
defaultHandler = env->CallObjectMethod(fop,
env->GetMethodID(env->FindClass("org/apache/fop/apps/Fop"), "getDefaultHandler",
"()Lorg/xml/sax/helpers/DefaultHandler;"));
CHECK_EXCEPTION(env);
saxResultClass = env->FindClass("javax/xml/transform/sax/SAXResult");
CHECK_EXCEPTION(env);
saxResult = env->NewObject(saxResultClass,
env->GetMethodID(saxResultClass, "<init>", "(Lorg/xml/sax/ContentHandler;)V"),
defaultHandler);
CHECK_EXCEPTION(env);
// Transform
env->CallObjectMethod(transormer,
env->GetMethodID(env->FindClass("javax/xml/transform/Transformer"),
"transform",
"(Ljavax/xml/transform/Source;Ljavax/xml/transform/Result;)V"),
streamSource, saxResult);
CHECK_EXCEPTION(env);
// Close outputstream
env->CallObjectMethod(byteArrayOutputStream,
env->GetMethodID(env->FindClass("java/io/OutputStream"),
"close", "()V"));
CHECK_EXCEPTION(env);
saxResultClass = env->FindClass("javax/xml/transform/sax/SAXResult");
CHECK_EXCEPTION(env);
// Get the byte array
res = (jbyteArray) env->CallObjectMethod(byteArrayOutputStream,
env->GetMethodID(byteArrayOutputStreamClass, "toByteArray", "()[B"));
CHECK_EXCEPTION(env);
// Create the result
dataSize = env->GetArrayLength(res);
dataElements = env->GetByteArrayElements(res, &isCopy);
std::string lBinaryString((const char*) dataElements, dataSize);
std::stringstream lStream(lBinaryString);
String base64S;
base64::encode(lStream, &base64S);
Item lRes( theFactory->createBase64Binary(base64S.data(), base64S.size(), true) );
return ItemSequence_t(new SingletonItemSequence(lRes));
} catch (zorba::jvm::VMOpenException&) {
Item lQName = theFactory->createQName("http://zorba.io/modules/xsl-fo",
"JVM-NOT-STARTED");
throw USER_EXCEPTION(lQName, "Could not start the Java VM (is the classpath set?)");
} catch (JavaException&) {
jclass stringWriterClass = env->FindClass("java/io/StringWriter");
jclass printWriterClass = env->FindClass("java/io/PrintWriter");
jclass throwableClass = env->FindClass("java/lang/Throwable");
jobject stringWriter = env->NewObject(
stringWriterClass,
env->GetMethodID(stringWriterClass, "<init>", "()V"));
jobject printWriter = env->NewObject(
printWriterClass, env->GetMethodID(printWriterClass, "<init>", "(Ljava/io/Writer;)V"), stringWriter);
env->CallObjectMethod(lException, env->GetMethodID(throwableClass, "printStackTrace", "(Ljava/io/PrintWriter;)V"), printWriter);
//env->CallObjectMethod(printWriter, env->GetMethodID(printWriterClass, "flush", "()V"));
jmethodID toStringMethod = env->GetMethodID(stringWriterClass, "toString", "()Ljava/lang/String;");
jobject errorMessageObj = env->CallObjectMethod(
stringWriter, toStringMethod);
jstring errorMessage = (jstring) errorMessageObj;
const char *errMsg = env->GetStringUTFChars(errorMessage, 0);
std::stringstream s;
s << "A Java Exception was thrown:" << std::endl << errMsg;
env->ReleaseStringUTFChars(errorMessage, errMsg);
std::string err("");
err += s.str();
env->ExceptionClear();
Item lQName = theFactory->createQName("http://zorba.io/modules/xsl-fo",
"JAVA-EXCEPTION");
throw USER_EXCEPTION(lQName, err);
}
return ItemSequence_t(new EmptySequence());
}
/**
* FASTQ format specification: http://maq.sourceforge.net/fastq.shtml
*/
static void load(IOAdapter* io, const U2DbiRef& dbiRef, const QVariantMap& hints, const GUrl& docUrl, QList<GObject*>& objects, U2OpStatus& os,
int gapSize, int predictedSize, QString& writeLockReason) {
DbiOperationsBlock opBlock(dbiRef, os);
CHECK_OP(os, );
Q_UNUSED(opBlock);
writeLockReason.clear();
bool merge = gapSize!=-1;
QByteArray sequence;
QByteArray qualityScores;
QStringList headers;
QSet<QString> uniqueNames;
QVector<U2Region> mergedMapping;
QByteArray gapSequence((merge ? gapSize : 0), 0);
sequence.reserve(predictedSize);
qualityScores.reserve(predictedSize);
// for lower case annotations
GObjectReference sequenceRef;
qint64 sequenceStart = 0;
U2SequenceImporter seqImporter(hints, true);
const QString folder = hints.value(DocumentFormat::DBI_FOLDER_HINT, U2ObjectDbi::ROOT_FOLDER).toString();
int seqNumber = 0;
int progressUpNum = 0;
const int objectsCountLimit = hints.contains(DocumentReadingMode_MaxObjectsInDoc) ? hints[DocumentReadingMode_MaxObjectsInDoc].toInt() : -1;
const bool settingsMakeUniqueName = !hints.value(DocumentReadingMode_DontMakeUniqueNames, false).toBool();
while (!os.isCoR()) {
//read header
QString sequenceName = readSequenceName(os, io, '@');
// check for eof while trying to read another FASTQ block
if (io->isEof()) {
break;
}
CHECK_OP_BREAK(os);
if(sequenceName.isEmpty()){
sequenceName = "Sequence";
}
if ((merge == false) || (seqNumber == 0)) {
QString objName = sequenceName;
if (settingsMakeUniqueName) {
objName = (merge) ? "Sequence" : TextUtils::variate(sequenceName, "_", uniqueNames);
objName.squeeze();
uniqueNames.insert(objName);
}
seqImporter.startSequence(dbiRef, folder, objName, false, os);
CHECK_OP_BREAK(os);
}
//read sequence
if (merge && sequence.length() > 0) {
seqImporter.addDefaultSymbolsBlock(gapSize,os);
sequenceStart += sequence.length();
sequenceStart+=gapSize;
CHECK_OP_BREAK(os);
}
sequence.clear();
readSequence(os, io, sequence);
MemoryLocker lSequence(os, qCeil(sequence.size()/(1000*1000)));
CHECK_OP_BREAK(os);
Q_UNUSED(lSequence);
seqImporter.addBlock(sequence.data(),sequence.length(),os);
CHECK_OP_BREAK(os);
QString qualSequenceName = readSequenceName(os, io, '+');
if (!qualSequenceName.isEmpty()) {
static const QString err = U2::FastqFormat::tr("Not a valid FASTQ file: %1, sequence name differs from quality scores name: %2 and %3");
CHECK_EXT_BREAK(sequenceName == qualSequenceName,
os.setError(err.arg(docUrl.getURLString()).arg(sequenceName).arg(qualSequenceName)));
}
// read qualities
qualityScores.clear();
readQuality(os, io, qualityScores, sequence.size());
CHECK_OP_BREAK(os);
static const QString err = U2::FastqFormat::tr("Not a valid FASTQ file: %1. Bad quality scores: inconsistent size.").arg(docUrl.getURLString());
CHECK_EXT_BREAK(sequence.length() == qualityScores.length(), os.setError(err));
seqNumber++;
progressUpNum++;
if (merge) {
headers.append(sequenceName);
mergedMapping.append(U2Region(sequenceStart, sequence.length() ));
}
else {
if (objectsCountLimit > 0 && objects.size() >= objectsCountLimit) {
os.setError(FastqFormat::tr("File \"%1\" contains too many sequences to be displayed. "
"However, you can process these data using instruments from the menu <i>Tools -> NGS data analysis</i> "
"or pipelines built with Workflow Designer.")
.arg(io->getURL().getURLString()));
break;
}
U2Sequence u2seq = seqImporter.finalizeSequenceAndValidate(os);
CHECK_OP_BREAK(os);
sequenceRef = GObjectReference(io->getURL().getURLString(), u2seq.visualName, GObjectTypes::SEQUENCE, U2EntityRef(dbiRef, u2seq.id));
U2SequenceObject* seqObj = new U2SequenceObject(u2seq.visualName, U2EntityRef(dbiRef, u2seq.id));
CHECK_EXT_BREAK(seqObj != NULL, os.setError("U2SequenceObject is NULL"));
seqObj->setQuality(DNAQuality(qualityScores));
objects << seqObj;
U1AnnotationUtils::addAnnotations(objects, seqImporter.getCaseAnnotations(), sequenceRef, NULL, hints);
}
if (PROGRESS_UPDATE_STEP == progressUpNum) {
progressUpNum = 0;
os.setProgress(io->getProgress());
}
}
CHECK_OP_EXT(os, qDeleteAll(objects); objects.clear(), );
bool emptyObjects = objects.isEmpty();
CHECK_EXT(!emptyObjects || merge, os.setError(Document::tr("Document is empty.")), );
SAFE_POINT(headers.size() == mergedMapping.size(), "headers <-> regions mapping failed!", );
if (!merge) {
return;
}
U2Sequence u2seq = seqImporter.finalizeSequenceAndValidate(os);
CHECK_OP(os,);
sequenceRef = GObjectReference(io->getURL().getURLString(), u2seq.visualName, GObjectTypes::SEQUENCE, U2EntityRef(dbiRef, u2seq.id));
U1AnnotationUtils::addAnnotations(objects, seqImporter.getCaseAnnotations(), sequenceRef, NULL, hints);
objects << new U2SequenceObject(u2seq.visualName, U2EntityRef(dbiRef, u2seq.id));
objects << DocumentFormatUtils::addAnnotationsForMergedU2Sequence(sequenceRef, dbiRef, headers, mergedMapping, hints);
if (headers.size() > 1) {
writeLockReason = DocumentFormat::MERGED_SEQ_LOCK;
}
}
