zorba::ItemSequence_t
GxlFunction::evaluate(
const Arguments_t& aArgs,
const zorba::StaticContext* aSctx,
const zorba::DynamicContext *aDctx) const
{
return ItemSequence_t(new LazyGxlSequence(this, aArgs[0]));
} /* GxlFunction::evaluate */
ItemSequence_t
ClosePreparedFunction::evaluate(const ExternalFunction::Arguments_t& args,
const zorba::StaticContext* aStaticContext,
const zorba::DynamicContext* aDynamincContext) const
{
String lStatementUUID = JdbcModule::getStringArg(args, 0);
CHECK_CONNECTION
JdbcModule::deleteObject(aDynamincContext, lStatementUUID, INSTANCE_MAP_PREPAREDSTATEMENTS);
return ItemSequence_t(new EmptySequence());
}
ItemSequence_t
ParseFunction::evaluate(
const ExternalFunction::Arguments_t& aArgs,
const StaticContext* aSctxCtx,
const DynamicContext* aDynCtx) const
{
std::auto_ptr<std::istringstream> iss;
std::istream *is;
String docString;
Item lStringItem, lOptionsItem;
if (aArgs.size() >= 1)
{
Iterator_t lArg0Iter = aArgs[0]->getIterator();
lArg0Iter->open();
lArg0Iter->next(lStringItem);
lArg0Iter->close();
}
if ( lStringItem.isStreamable() )
{
//
// The "iss" auto_ptr can NOT be used since it will delete the stream that,
// in this case, is a data member inside another object and not dynamically
// allocated.
//
// We can't replace "iss" with "is" since we still need the auto_ptr for
// the case when the result is not streamable.
//
is = &lStringItem.getStream();
}
else
{
docString = lStringItem.getStringValue();
iss.reset (new std::istringstream(docString.c_str()));
is = iss.get();
}
if (aArgs.size() == 2)
{
Iterator_t lArg1Iter = aArgs[1]->getIterator();
lArg1Iter->open();
lArg1Iter->next(lOptionsItem);
lArg1Iter->close();
}
return ItemSequence_t(
new SingletonItemSequence(createHtmlItem(*is, lOptionsItem)));
}
ItemSequence_t WriteTextFunctionImpl::evaluate(
ExternalFunction::Arguments_t const &args,
StaticContext const*,
DynamicContext const* ) const
{
String const path( getPathArg( args, 0 ) );
String const encoding( getStringArg( args, 2 ) );
fs::type const fs_type = fs::get_type( path );
if ( fs_type && fs_type != fs::file )
raiseFileError( "FOFL0004", "not a plain file", path );
if ( !transcode::is_supported( encoding.c_str() ) )
raiseFileError( "FOFL9999", "encoding not supported", encoding );
ios_base::openmode const mode = ios_base::out
| (append_ ? ios_base::app : ios_base::trunc);
ofstream ofs( path.c_str(), mode );
if ( !ofs ) {
ostringstream oss;
oss << '"' << path << "\": can not open file for writing";
raiseFileError( "FOFL9999", oss.str().c_str(), path );
}
transcode::auto_attach<ofstream> transcoder;
if ( transcode::is_necessary( encoding.c_str() ) )
transcoder.attach( ofs, encoding.c_str() );
Iterator_t it( args[1]->getIterator() );
it->open();
Item item;
while ( it->next( item ) ) {
if ( item.isStreamable() ) {
ofs << item.getStream().rdbuf();
} else {
zorba::String const s( item.getStringValue() );
ofs.write( s.data(), s.size() );
}
if ( newlines_ )
ofs << fs::newline;
}
it->close();
return ItemSequence_t( new EmptySequence() );
}
ItemSequence_t WriteBinaryFunctionImpl::evaluate(
ExternalFunction::Arguments_t const &args,
StaticContext const*,
DynamicContext const* ) const
{
String const path( getPathArg( args, 0 ) );
fs::type const fs_type = fs::get_type( path );
if ( fs_type && fs_type != fs::file )
raiseFileError( "FOFL0004", "not a plain file", path );
ios_base::openmode const mode = ios_base::out | ios_base::binary
| (append_ ? ios_base::app : ios_base::trunc);
ofstream ofs( path.c_str(), mode );
if ( !ofs ) {
ostringstream oss;
oss << '"' << path << "\": can not open file for writing";
raiseFileError( "FOFL9999", oss.str().c_str(), path );
}
Iterator_t it( args[1]->getIterator() );
it->open();
Item item;
while ( it->next( item ) ) {
if ( item.isStreamable() ) {
if ( item.isEncoded() )
base64::decode( item.getStream(), ofs );
else
ofs << item.getStream().rdbuf();
} else {
size_t b64_size;
char const *const b64_value = item.getBase64BinaryValue( b64_size );
if ( item.isEncoded() )
base64::decode( b64_value, b64_size, ofs );
else
ofs.write( b64_value, b64_size );
}
}
it->close();
return ItemSequence_t( new EmptySequence() );
}
ItemSequence_t
CExternalFunction::evaluate
(const ExternalFunction::Arguments_t& args) const
{
unsigned int lSequencesSize = (unsigned int)args.size();
XQC_Sequence** lSequences = new XQC_Sequence*[lSequencesSize];
// Wrap each Argument (which is just an ItemSequence) in a
// CSequence, and keep an array of each corresponding
// XQC_Sequence. These ItemSequences are being memory-managed by
// the Zorba engine, so we request that CSequence NOT free them
// when the CSequence is deleted.
for (unsigned int i = 0; i < lSequencesSize; ++i) {
std::unique_ptr<CSequence> lSeq(new CSequence(args[i], false, NULL));
lSequences[i] = lSeq.release()->getXQC();
}
return ItemSequence_t(new UserItemSequence(lSequences, lSequencesSize,
theInitFunction, theNextFunction, theFreeFunction,
theFunctionUserData, theFactory, theErrorHandler));
}
ItemSequence_t
RegisterFunction::evaluate(
const ExternalFunction::Arguments_t &args,
const zorba::StaticContext *aStaticContext,
const zorba::DynamicContext *aDynamincContext) const {
JdbcModule::initGlobals(aStaticContext);
Item result;
JDBC_MODULE_TRY;
jstring driverName(NULL);
Item item = JdbcModule::getItemArg(args, 0);
bool hasUsername = false;
if (item.isJSONItem()) {
Iterator_t lKeys = item.getObjectKeys();
lKeys->open();
Item lKey;
while (lKeys->next(lKey)) {
zorba::String keystring = lKey.getStringValue();
zorba::String value = item.getObjectValue(keystring).getStringValue();
if (keystring == "driver") {
driverName = env->NewStringUTF(value.c_str());
CHECK_EXCEPTION;
}
}
lKeys->close();
}
jobject oRegister;
if (driverName) {
oRegister = env->CallStaticObjectMethod(
jClass.classID,
jClass.forName,
driverName);
CHECK_EXCEPTION;
}
JDBC_MODULE_CATCH;
return ItemSequence_t(new EmptySequence());
}
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());
}
ItemSequence_t
SetValueFunction::evaluate(
const ExternalFunction::Arguments_t &args,
const zorba::StaticContext *aStaticContext,
const zorba::DynamicContext *aDynamincContext) const {
String lStatementUUID = JdbcModule::getStringArg(args, 0);
CHECK_CONNECTION;
Item result;
JDBC_MODULE_TRY;
jobject oPreparedStatement =
JdbcModule::getObject(aDynamincContext,
lStatementUUID,
INSTANCE_MAP_PREPAREDSTATEMENTS);
long index = (long) JdbcModule::getItemArg(args, 1).getLongValue();
Item value = JdbcModule::getItemArg(args, 2);
int type = value.getTypeCode();
switch (type) {
case XS_DOUBLE:
env->CallVoidMethod(oPreparedStatement, jPreparedStatement.setDouble,
index, value.getDoubleValue());
break;
case XS_FLOAT:
env->CallVoidMethod(oPreparedStatement, jPreparedStatement.setFloat,
index, value.getDoubleValue());
break;
case XS_INTEGER:
env->CallVoidMethod(oPreparedStatement, jPreparedStatement.setLong,
index, value.getLongValue());
break;
case XS_DECIMAL: {
double dVal;
sscanf(value.getStringValue().c_str(), "%lf", &dVal);
env->CallVoidMethod(oPreparedStatement, jPreparedStatement.setDouble,
index, dVal);
break;
}
case XS_BOOLEAN: {
jboolean boolval = JNI_FALSE;
if (value.getBooleanValue())
boolval = JNI_TRUE;
env->CallVoidMethod(oPreparedStatement, jPreparedStatement.setBoolean,
index, boolval);
break;
}
case JS_NULL: {
jobject oParameterMetadata =
env->CallObjectMethod(oPreparedStatement,
jPreparedStatement.getParameterMetaData);
CHECK_EXCEPTION;
int parameterType =
env->CallIntMethod(oParameterMetadata,
jParameterMetadata.getParameterType,
index);
CHECK_EXCEPTION;
env->CallVoidMethod(oPreparedStatement,
jPreparedStatement.setNull,
index, parameterType);
CHECK_EXCEPTION;
break;
}
default: { // STRING
jstring stringval = env->NewStringUTF(value.getStringValue().c_str());
env->CallVoidMethod(oPreparedStatement, jPreparedStatement.setString,
index, stringval);
break;
}
}
CHECK_EXCEPTION;
JDBC_MODULE_CATCH;
return ItemSequence_t(new EmptySequence());
}
