/**************************************************************
*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*
*************************************************************/
// MARKER(update_precomp.py): autogen include statement, do not remove
#include "precompiled_scripting.hxx"
#include <osl/file.hxx>
#include <osl/time.h>
#include <cppuhelper/implementationentry.hxx>
#include <com/sun/star/lang/IllegalArgumentException.hpp>
#include <com/sun/star/ucb/CommandAbortedException.hpp>
#include <com/sun/star/io/XActiveDataSource.hpp>
#include <com/sun/star/xml/sax/XExtendedDocumentHandler.hpp>
#include <com/sun/star/container/XNameAccess.hpp>
#include <com/sun/star/beans/XPropertySet.hpp>
#include <com/sun/star/beans/PropertyValue.hpp>
#include <util/util.hxx>
#include <rtl/uri.hxx>
#include "ScriptData.hxx"
#include "ScriptInfo.hxx"
#include "ScriptStorage.hxx"
#include "ScriptElement.hxx"
#include "ScriptMetadataImporter.hxx"
#include "ScriptURI.hxx"
using namespace ::rtl;
using namespace ::cppu;
using namespace ::com::sun::star;
using namespace ::com::sun::star::uno;
using namespace ::drafts::com::sun::star::script::framework;
namespace scripting_impl
{
ScriptLanguages_hash* ScriptStorage::mh_scriptLangs = NULL;
const sal_Char* const SERVICE_NAME =
"drafts.com.sun.star.script.framework.storage.ScriptStorage";
const sal_Char* const IMPL_NAME =
"drafts.com.sun.star.script.framework.storage.ScriptStorage";
const sal_Char * const SCRIPT_DIR = "/Scripts";
const sal_Char * const SCRIPT_PARCEL = "/parcel-descriptor.xml";
const sal_Char * const SCRIPT_PARCEL_NAME_ONLY = "parcel-descriptor";
static OUString ss_implName = OUString::createFromAscii( IMPL_NAME );
static OUString ss_serviceName = OUString::createFromAscii( SERVICE_NAME );
static Sequence< OUString > ss_serviceNames =
Sequence< OUString >( &ss_serviceName, 1 );
const sal_uInt16 NUMBER_STORAGE_INITIALIZE_ARGS = 3;
//extern ::rtl_StandardModuleCount s_moduleCount;
//*************************************************************************
ScriptStorage::ScriptStorage( const Reference <
XComponentContext > & xContext )
throw ( RuntimeException )
: m_xContext( xContext, UNO_SET_THROW ), m_bInitialised( false )
{
OSL_TRACE( "< ScriptStorage ctor called >\n" );
m_xMgr.set( m_xContext->getServiceManager(), UNO_SET_THROW );
if( !mh_scriptLangs )
{
::osl::MutexGuard guard( ::osl::Mutex::getGlobalMutex() );
if( !mh_scriptLangs )
{
mh_scriptLangs = new ScriptLanguages_hash();
Reference< lang::XMultiServiceFactory > xConfigProvFactory(
m_xMgr->createInstanceWithContext( OUString::createFromAscii( "com.sun.star.configuration.ConfigurationProvider" ), m_xContext ),
UNO_QUERY_THROW );
// create an instance of the ConfigurationAccess for accessing the
// scripting runtime settings
beans::PropertyValue configPath;
configPath.Name = ::rtl::OUString::createFromAscii( "nodepath" );
configPath.Value <<= ::rtl::OUString::createFromAscii( "org.openoffice.Office.Scripting/ScriptRuntimes" );
Sequence < Any > aargs( 1 );
aargs[ 0 ] <<= configPath;
Reference< container::XNameAccess > xNameAccess(
xConfigProvFactory->createInstanceWithArguments(
OUString::createFromAscii( "com.sun.star.configuration.ConfigurationAccess" ),
aargs
),
UNO_QUERY_THROW );
Sequence< OUString > names = xNameAccess->getElementNames();
for( int i = 0 ; i < names.getLength() ; i++ )
{
OSL_TRACE( "Getting propertyset for Lang=%s",
::rtl::OUStringToOString( names[i], RTL_TEXTENCODING_ASCII_US ).pData->buffer );
Reference< beans::XPropertySet > xPropSet( xNameAccess->getByName( names[i] ), UNO_QUERY_THROW );
Any aProp = xPropSet->getPropertyValue(
OUString::createFromAscii( "SupportedFileExtensions") );
Sequence< OUString > extns;
if( sal_False == ( aProp >>= extns ) )
{
throw RuntimeException(
OUSTR( "ScriptStorage:ScriptStorage: can't get runtime extensions" ),
Reference< XInterface > () );
}
for( int j = 0 ; j < extns.getLength() ; j++ )
{
OSL_TRACE( "Adding Lang=%s, Extn=%s\n",
::rtl::OUStringToOString( names[i], RTL_TEXTENCODING_ASCII_US ).pData->buffer,
::rtl::OUStringToOString( extns[j], RTL_TEXTENCODING_ASCII_US ).pData->buffer );
(*mh_scriptLangs)[ extns[j] ] =
names[i];
}
}
}
}
// s_moduleCount.modCnt.acquire( &s_moduleCount.modCnt );
}
//*************************************************************************
ScriptStorage::~ScriptStorage() SAL_THROW( () )
{
OSL_TRACE( "< ScriptStorage dtor called >\n" );
// s_moduleCount.modCnt.release( &s_moduleCount.modCnt );
}
//*************************************************************************
void
ScriptStorage::initialize( const Sequence <Any> & args )
throw ( RuntimeException, Exception )
{
OSL_TRACE( "Entering ScriptStorage::initialize\n" );
// Should not be renitialised
if ( m_bInitialised )
{
throw RuntimeException(
OUSTR( "ScriptStorage::initalize already initialized" ),
Reference<XInterface> () );
}
{ // Protect member variable writes
::osl::Guard< osl::Mutex > aGuard( m_mutex );
// Check args
if ( args.getLength() != NUMBER_STORAGE_INITIALIZE_ARGS )
{
OSL_TRACE( "ScriptStorage::initialize: got wrong number of args\n" );
throw RuntimeException(
OUSTR( "Invalid number of arguments provided!" ),
Reference< XInterface >() );
}
if ( sal_False == ( args[ 0 ] >>= m_xSimpleFileAccess ) )
{
throw RuntimeException(
OUSTR( "Invalid XSimpleFileAccess argument provided!" ),
Reference< XInterface >() );
}
if ( sal_False == ( args[ 1 ] >>= m_scriptStorageID ) )
{
throw RuntimeException(
OUSTR( "Invalid ScriptStorage ID argument provided!" ),
Reference< XInterface >() );
}
if ( sal_False == ( args[ 2 ] >>= m_stringUri ) )
{
throw RuntimeException(
OUSTR( "Invalid String Uri argument provided!" ),
Reference< XInterface >() );
}
} // End - Protect member variable writes
OSL_TRACE( "uri: %s\n", ::rtl::OUStringToOString(
m_stringUri, RTL_TEXTENCODING_ASCII_US ).pData->buffer );
try
{
// need to check for what???
// what we have is a URI for the filesystem or document
// we need to check of the last element in the path has an
// extension that is associated with a script (eg. .bsh, .js etc)
OUString fileExtension = getFileExtension( m_stringUri );
// and see if this is in our scripts map
ScriptLanguages_hash::iterator h_it = mh_scriptLangs->find( fileExtension );
if ( h_it != mh_scriptLangs->end() )
{
createForFilesystem( fileExtension );
}
else
{
create();
}
}
catch ( RuntimeException & re )
{
OSL_TRACE( "caught com::sun::star::uno::RuntimeException in ScriptStorage::initialize" );
throw RuntimeException(
OUSTR( "ScriptStorage::initalize RuntimeException: " ).concat( re.Message ),
Reference< XInterface > () );
}
catch ( Exception & ue )
{
OSL_TRACE( "caught com::sun::star::uno::Exception in ScriptStorage::initialize" );
throw RuntimeException(
OUSTR( "ScriptStorage::initalize Exception: " ).concat( ue.Message ),
Reference< XInterface > () );
}
#ifdef _DEBUG
catch ( ... )
{
OSL_TRACE( "caught unknown Exception in ScriptStorage::initialize" );
throw RuntimeException(
OUSTR( "ScriptStorage::initalize unknown exception: " ),
Reference< XInterface > () );
}
#endif
OSL_TRACE( "Parsed the XML\n" );
m_bInitialised = true;
}
void
ScriptStorage::create()
throw ( RuntimeException, Exception )
{
::osl::Guard< osl::Mutex > aGuard( m_mutex );
try
{
// clear existing hashmap - rebuilding from scratch to avoid having
// to search for deleted elements on refresh
mh_implementations.clear();
OUString xStringUri(m_stringUri);
ScriptMetadataImporter* SMI = new ScriptMetadataImporter( m_xContext );
Reference< xml::sax::XExtendedDocumentHandler > xSMI( SMI, UNO_SET_THROW );
xStringUri = xStringUri.concat( ::rtl::OUString::createFromAscii(
SCRIPT_DIR ) );
// No Scripts directory - just return
if ( ! m_xSimpleFileAccess->isFolder( xStringUri ) )
{
OSL_TRACE( "ScriptStorage::initialize: no Scripts dir for this storage - install problem\n" );
return;
}
// get the list of language folders under the Scripts directory
Sequence< ::rtl::OUString > languageDirs =
m_xSimpleFileAccess->getFolderContents( xStringUri, true );
Reference< io::XInputStream > xInput;
sal_Int32 languageDirsLength = languageDirs.getLength();
for ( sal_Int32 i = 0; i < languageDirsLength ; ++i )
{
OSL_TRACE( "contains: %s\n", ::rtl::OUStringToOString(
languageDirs[ i ], RTL_TEXTENCODING_ASCII_US ).pData->buffer );
if ( ! m_xSimpleFileAccess->isFolder( languageDirs[ i ] ) )
{
continue;
}
//get the list of parcel folders for each language folder
// under Scripts
Sequence< ::rtl::OUString > parcelDirs =
m_xSimpleFileAccess->getFolderContents( languageDirs[ i ], true );
sal_Int32 parcelDirsLength = parcelDirs.getLength();
for ( sal_Int32 j = 0; j < parcelDirsLength ; ++j )
{
OSL_TRACE( "contains: %s\n",
::rtl::OUStringToOString( parcelDirs[ j ],
RTL_TEXTENCODING_ASCII_US ).pData->buffer );
OUString parcelFile = parcelDirs[ j ].concat(
::rtl::OUString::createFromAscii( SCRIPT_PARCEL ) );
// Do not have a valid parcel.xml
if ( !m_xSimpleFileAccess->exists( parcelFile ) ||
m_xSimpleFileAccess->isFolder( parcelFile ) )
{
continue;
}
OSL_TRACE( "parcel file: %s\n",
::rtl::OUStringToOString( parcelFile,
RTL_TEXTENCODING_ASCII_US ).pData->buffer );
xInput = m_xSimpleFileAccess->openFileRead( parcelFile );
// Failed to get input stream
if ( !xInput.is() )
{
continue;
}
OSL_TRACE( "Parse the metadata \n" );
Datas_vec vScriptDatas;
try
{
SMI->parseMetaData( xInput, parcelDirs[ j ], vScriptDatas );
}
catch ( xml::sax::SAXException & saxe )
{
if ( xInput.is() )
{
xInput->closeInput();
}
OSL_TRACE(
"caught com::sun::star::xml::sax::SAXException in ScriptStorage::create %s",
::rtl::OUStringToOString( saxe.Message,
RTL_TEXTENCODING_ASCII_US ).pData->buffer );
continue;
}
catch ( io::IOException & ioe )
{
if ( xInput.is() )
{
xInput->closeInput();
}
OSL_TRACE(
"caught com::sun::star::io::IOException in ScriptStorage::create" );
continue;
}
xInput->closeInput();
updateMaps( vScriptDatas );
}
}
}
catch ( io::IOException & ioe )
{
//From ScriptMetadata Importer
OSL_TRACE( "caught com::sun::star::io::IOException in ScriptStorage::create" );
throw RuntimeException(
OUSTR( "ScriptStorage::create IOException: " ).concat( ioe.Message ),
Reference< XInterface > () );
}
catch ( ucb::CommandAbortedException & cae )
{
OSL_TRACE( "caught com::sun::star::ucb::CommandAbortedException in ScriptStorage::create" );
throw RuntimeException(
OUSTR(
"ScriptStorage::create CommandAbortedException: " ).concat( cae.Message ),
Reference< XInterface > () );
}
catch ( RuntimeException & re )
{
OSL_TRACE( "caught com::sun::star::uno::RuntimeException in ScriptStorage::create" );
throw RuntimeException(
OUSTR( "ScriptStorage::create RuntimeException: " ).concat( re.Message ),
Reference< XInterface > () );
}
catch ( Exception & ue )
{
OSL_TRACE( "caught com::sun::star::uno::Exception in ScriptStorage::create" );
throw RuntimeException(
OUSTR( "ScriptStorage::create Exception: " ).concat( ue.Message ),
Reference< XInterface > () );
}
#ifdef _DEBUG
catch ( ... )
{
OSL_TRACE( "caught unknown Exception in ScriptStorage::create" );
throw RuntimeException(
OUSTR( "ScriptStorage::initalize unknown exception: " ),
Reference< XInterface > () );
}
#endif
OSL_TRACE( "Parsed the XML\n" );
m_bInitialised = true;
}
//*************************************************************************
// private method to create the usual data structures for scripts located
// on the filesystem.
// parcelURI = the path to the script
// functionName = the full filename with extension
// logicalName = the filename without the extension
void
ScriptStorage::createForFilesystem( const OUString & fileExtension )
throw ( RuntimeException, Exception )
{
// need to decode as file urls are encoded
OUString xStringUri = ::rtl::Uri::decode( m_stringUri,
rtl_UriDecodeWithCharset, RTL_TEXTENCODING_ASCII_US );
// no x-platform issues here as we are dealing with URLs
sal_Int32 lastFileSep = xStringUri.lastIndexOf( '/' );
// the char just after the filesep
lastFileSep += 1;
sal_Int32 lastFileExt = xStringUri.lastIndexOf( fileExtension );
OUString searchString = OUString::createFromAscii( "://" );
sal_Int32 searchStringLength = searchString.getLength();
sal_Int32 startPath = xStringUri.indexOf( searchString );
sal_Int32 uriLength = xStringUri.getLength();
OUString fileNameNoExt = xStringUri.copy( lastFileSep ,
lastFileExt - lastFileSep - 1 );
OUString fileName = xStringUri.copy( lastFileSep, uriLength - lastFileSep );
OUString filePath = xStringUri.copy( startPath + searchStringLength,
lastFileSep - startPath - searchStringLength );
OUString filePathWithName = xStringUri.copy( startPath + searchStringLength,
uriLength - startPath - searchStringLength );
ScriptData scriptData;
scriptData.language = mh_scriptLangs->find( fileExtension )->second;
OSL_TRACE( "\t language = %s", ::rtl::OUStringToOString(
scriptData.language, RTL_TEXTENCODING_ASCII_US ).pData->buffer );
// do we need to encode this?
scriptData.functionname = fileName;
OSL_TRACE( "\t functionName = %s", ::rtl::OUStringToOString(
scriptData.functionname, RTL_TEXTENCODING_ASCII_US ).pData->buffer );
//scriptData.functionname = ::rtl::Uri::encode( fileName,
//rtl_UriCharClassUricNoSlash, rtl_UriEncodeCheckEscapes,
//RTL_TEXTENCODING_ASCII_US );
scriptData.parcelURI = filePath;
OSL_TRACE( "\t parcelURI = %s", ::rtl::OUStringToOString(
scriptData.parcelURI, RTL_TEXTENCODING_ASCII_US ).pData->buffer );
scriptData.logicalname = fileNameNoExt;
OSL_TRACE( "\t logicalName = %s", ::rtl::OUStringToOString(
scriptData.logicalname, RTL_TEXTENCODING_ASCII_US ).pData->buffer );
// and now push onto the usual structures
ScriptFunction_hash sfh;
sfh[ scriptData.functionname ] = scriptData;
mh_implementations[ scriptData.language ] = sfh;
m_bInitialised = true;
}
//*************************************************************************
// private method to return the file extension, eg. bsh, js etc
OUString
ScriptStorage::getFileExtension( const OUString & stringUri )
{
OUString fileExtension;
sal_Int32 lastDot = stringUri.lastIndexOf( '.' );
if( lastDot > 0 ) {
sal_Int32 stringUriLength = stringUri.getLength();
fileExtension = stringUri.copy( lastDot +1 , stringUriLength - lastDot - 1 );
}
else
{
fileExtension = OUString::createFromAscii("");
}
return fileExtension;
}
//*************************************************************************
// private method for updating hashmaps
void
ScriptStorage::updateMaps( const Datas_vec & vScriptDatas )
{
Datas_vec::const_iterator it_end = vScriptDatas.end();
// step through the vector of ScripImplInfos returned from parse
for ( Datas_vec::const_iterator it = vScriptDatas.begin() ; it != it_end; ++it )
{
//find the Datas_vec for this logical name
ScriptData_hash::iterator h_it = mh_implementations.find( it->language );
if ( h_it == mh_implementations.end() )
{
//if it's null, need to create a new Datas_vec
OSL_TRACE(
"updateMaps: new language: %s\n", rtl::OUStringToOString(
it->language, RTL_TEXTENCODING_ASCII_US ).pData->buffer );
OSL_TRACE(
"updateMaps: adding functionname: %s\n", rtl::OUStringToOString(
it->functionname, RTL_TEXTENCODING_ASCII_US ).pData->buffer );
ScriptFunction_hash sfh;
sfh[ it->functionname ] = *it;
mh_implementations[ it->language ] = sfh;
}
else
{
OSL_TRACE(
"updateMaps: adding functionname: %s\n", rtl::OUStringToOString(
it->functionname, RTL_TEXTENCODING_ASCII_US ).pData->buffer );
OSL_TRACE( " language name: %s\n",
rtl::OUStringToOString( it->functionname,
RTL_TEXTENCODING_ASCII_US ).pData->buffer );
h_it->second[ it->functionname ] = *it;
}
}
}
//*************************************************************************
// XScriptStorageExport::save
void
ScriptStorage::save()
throw ( RuntimeException )
{
::osl::Guard< osl::Mutex > aGuard( m_mutex );
Reference< io::XActiveDataSource > xSource;
Reference< io::XOutputStream > xOS;
// xScriptInvocation = Reference<XScriptInvocation>(xx, UNO_QUERY_THROW);
Reference< xml::sax::XExtendedDocumentHandler > xHandler;
OUString parcel_suffix = OUString::createFromAscii( SCRIPT_PARCEL );
OUString ou_parcel = OUString(
RTL_CONSTASCII_USTRINGPARAM( SCRIPT_PARCEL_NAME_ONLY ) );
try
{
ScriptData_hash::iterator it_end = mh_implementations.end();
for ( ScriptData_hash::iterator it = mh_implementations.begin() ; it != it_end; ++it )
{
::rtl::OUString logName = it->first;
ScriptFunction_hash::iterator it_sfh_end = it->second.end();
for ( ScriptFunction_hash::iterator it_sfh = it->second.begin();
it_sfh != it_sfh_end ; ++it_sfh )
{
ScriptOutput_hash::const_iterator it_parcels =
mh_parcels.find( it_sfh->second.parcelURI );
if ( it_parcels == mh_parcels.end() )
{
//create new outputstream
OUString parcel_xml_path = it_sfh->second.parcelURI.concat(
parcel_suffix );
m_xSimpleFileAccess->kill( parcel_xml_path );
xOS = m_xSimpleFileAccess->openFileWrite( parcel_xml_path );
OSL_TRACE( "saving: %s\n", rtl::OUStringToOString(
it_sfh->second.parcelURI.concat( OUString::createFromAscii(
"/parcel.xml" ) ),
RTL_TEXTENCODING_ASCII_US ).pData->buffer );
xHandler.set(
m_xMgr->createInstanceWithContext(
OUString::createFromAscii( "com.sun.star.xml.sax.Writer" ),
m_xContext
),
UNO_QUERY_THROW
);
xSource.set( xHandler, UNO_QUERY_THROW );
xSource->setOutputStream( xOS );
writeMetadataHeader( xHandler );
mh_parcels[ it_sfh->second.parcelURI ] = xHandler;
}
else
{
xHandler = it_parcels->second;
}
ScriptElement* pSE = new ScriptElement( it_sfh->second );
// this is to get pSE released correctly
Reference < xml::sax::XAttributeList > xal( pSE );
pSE->dump( xHandler );
}
}
ScriptOutput_hash::const_iterator out_it_end = mh_parcels.end();
for ( ScriptOutput_hash::const_iterator out_it = mh_parcels.begin();
out_it != out_it_end; ++out_it )
{
out_it->second->ignorableWhitespace( ::rtl::OUString() );
out_it->second->endDocument();
xSource.set( out_it->second, UNO_QUERY );
Reference< io::XOutputStream > xOS = xSource->getOutputStream();
xOS->closeOutput();
}
// clear the hash map, as all output streams have been closed.
// need to re-create on next save
mh_parcels.clear();
}
// *** TODO - other exception handling IO etc.
catch ( RuntimeException & re )
{
OSL_TRACE( "caught com::sun::star::uno::RuntimeException in ScriptStorage::save" );
throw RuntimeException(
OUSTR( "ScriptStorage::save RuntimeException: " ).concat(
re.Message ),
Reference< XInterface > () );
}
}
//*************************************************************************
void
ScriptStorage::refresh()
throw (RuntimeException)
{
OSL_TRACE("** => ScriptStorage: in refresh()\n");
// guard against concurrent refreshes
::osl::Guard< ::osl::Mutex > aGuard( m_mutex );
try
{
create();
}
catch ( RuntimeException & re )
{
OSL_TRACE( "caught com::sun::star::uno::RuntimeException in ScriptStorage::refresh" );
throw RuntimeException(
OUSTR( "ScriptStorage::refresh RuntimeException: " ).concat( re.Message ),
Reference< XInterface > () );
}
catch ( Exception & ue )
{
OSL_TRACE( "caught com::sun::star::uno::Exception in ScriptStorage::refresh" );
throw RuntimeException(
OUSTR( "ScriptStorage::refresh Exception: " ).concat( ue.Message ),
Reference< XInterface > () );
}
}
//*************************************************************************
void
ScriptStorage::writeMetadataHeader(
Reference <xml::sax::XExtendedDocumentHandler> & xHandler )
{
xHandler->startDocument();
OUString aDocTypeStr( RTL_CONSTASCII_USTRINGPARAM(
"<!DOCTYPE parcel SYSTEM \"scripting.dtd\">" ) );
xHandler->unknown( aDocTypeStr );
xHandler->ignorableWhitespace( OUString() );
}
//*************************************************************************
Sequence< ::rtl::OUString >
ScriptStorage::getScriptLogicalNames()
throw ( RuntimeException )
{
Sequence< ::rtl::OUString > results;
// comment out the rest, and ultimately remove method
/*ScriptInfo_hash::iterator h_it = mh_implementations.begin();
ScriptInfo_hash::iterator h_itEnd = mh_implementations.end();
if ( h_it == h_itEnd )
{
OSL_TRACE( "ScriptStorage::getImplementations: EMPTY STORAGE");
return results;
}
results.realloc( mh_implementations.size() );
//find the implementations for the given logical name
try
{
::osl::Guard< osl::Mutex > aGuard( m_mutex );
for ( sal_Int32 count = 0; h_it != h_itEnd ; ++h_it )
{
::rtl::OUString logicalName = h_it->first;
OSL_TRACE( "Adding %s at index %d ", ::rtl::OUStringToOString(
logicalName, RTL_TEXTENCODING_ASCII_US ).pData->buffer, count);
results[ count++ ] = logicalName;
}
}
catch ( RuntimeException & re )
{
throw RuntimeException(
OUSTR( "ScriptStorage::getScriptLogicalNames RuntimeException: " ).concat( re.Message ),
Reference< XInterface > () );
}
catch ( Exception & e )
{
throw RuntimeException( OUSTR(
"ScriptStorage::getScriptLogicalNames Exception: " ).concat(
e.Message ), Reference< XInterface > () );
} */
return results;
}
//*************************************************************************
Sequence< Reference< storage::XScriptInfo > >
ScriptStorage::getImplementations( const ::rtl::OUString & queryURI )
throw ( lang::IllegalArgumentException,
RuntimeException )
{
::osl::Guard< osl::Mutex > aGuard( m_mutex );
// format is script:://[function_name]?language=[languge]&location=[location]
// LogicalName is now not used anymore, further more the ScriptURI class
// will be retired also and a new UNO service will be used. Additionally the
// parcel-description will also need to be modified to remove logical name
// ScriprtMetaDataImporter has been modified to ignore the Logical name
// definined in the parcel-desc.xml. As an interim temp solution the Datas_vec
// structure that is returned from ScriptMetDataImporter sets the logicalname
// to the function name. ScriptURI class has been changed in the same way.
//
Sequence< Reference< storage::XScriptInfo > > results;
ScriptURI scriptURI( queryURI );
OSL_TRACE( "getting impl for language %s, function name: %s",
::rtl::OUStringToOString( scriptURI.getLanguage(),
RTL_TEXTENCODING_ASCII_US ).pData->buffer,
::rtl::OUStringToOString( scriptURI.getFunctionName(),
RTL_TEXTENCODING_ASCII_US ).pData->buffer );
ScriptData_hash::iterator h_itEnd = mh_implementations.end();
ScriptData_hash::iterator h_it = mh_implementations.begin();
if ( h_it == h_itEnd )
{
OSL_TRACE( "ScriptStorage::getImplementations: EMPTY STORAGE" );
return results;
}
//find the implementations for the given language
h_it = mh_implementations.find( scriptURI.getLanguage() );
if ( h_it == h_itEnd )
{
OSL_TRACE( "ScriptStorage::getImplementations: no impls found for %s",
::rtl::OUStringToOString( scriptURI.getLanguage(),
RTL_TEXTENCODING_ASCII_US ).pData->buffer );
return results;
}
//find the implementations for the given language
ScriptFunction_hash::const_iterator it_datas = h_it->second.find(
scriptURI.getLogicalName() );
ScriptFunction_hash::const_iterator it_datas_end = h_it->second.end();
if ( it_datas == it_datas_end )
{
OSL_TRACE( "ScriptStorage::getImplementations: no impls found for %s",
::rtl::OUStringToOString( scriptURI.getFunctionName(),
RTL_TEXTENCODING_ASCII_US ).pData->buffer );
return results;
}
results.realloc( 1 );
ScriptData scriptData = it_datas->second;
OSL_TRACE( "ScriptStorage::getImplementations: impls found for %s",
::rtl::OUStringToOString( scriptData.functionname,
RTL_TEXTENCODING_ASCII_US ).pData->buffer );
Reference< storage::XScriptInfo > xScriptInfo =
new ScriptInfo ( scriptData, m_scriptStorageID );
results[ 0 ] = xScriptInfo;
return results;
}
//*************************************************************************
Sequence< Reference< storage::XScriptInfo > > SAL_CALL
ScriptStorage::getAllImplementations() throw ( RuntimeException )
{
::osl::Guard< osl::Mutex > aGuard( m_mutex );
Sequence< Reference< storage::XScriptInfo > > results;
ScriptData_hash::iterator h_itEnd = mh_implementations.end();
ScriptData_hash::iterator h_it = mh_implementations.begin();
if ( h_it == h_itEnd )
{
OSL_TRACE( "ScriptStorage::getImplementations: EMPTY STORAGE" );
return results;
}
//iterate through each logical name and gather each implementation
//for that name
for ( sal_Int32 count = 0; h_it != h_itEnd; ++h_it )
{
results.realloc( h_it->second.size() + count );
OSL_TRACE( "Adding implementations for %s",
::rtl::OUStringToOString( h_it->first,
RTL_TEXTENCODING_ASCII_US ).pData->buffer );
ScriptFunction_hash::const_iterator it_sfh = h_it->second.begin();
ScriptFunction_hash::const_iterator it_sfh_end = h_it->second.end();
OSL_TRACE( "Adding %d to sequence of impls ", h_it->second.size() );
for ( ; it_sfh != it_sfh_end ; ++it_sfh )
{
Reference< storage::XScriptInfo > xScriptInfo = new ScriptInfo (
it_sfh->second, m_scriptStorageID );
results[ count++ ] = xScriptInfo;
}
}
return results;
}
//*************************************************************************
OUString SAL_CALL ScriptStorage::getImplementationName( )
throw( RuntimeException )
{
return ss_implName;
}
//*************************************************************************
sal_Bool SAL_CALL ScriptStorage::supportsService( const OUString& serviceName )
throw( RuntimeException )
{
OUString const * pNames = ss_serviceNames.getConstArray();
for ( sal_Int32 nPos = ss_serviceNames.getLength(); nPos--; )
{
if ( serviceName.equals( pNames[ nPos ] ) )
{
return sal_True;
}
}
return sal_False;
}
//*************************************************************************
Sequence<OUString> SAL_CALL ScriptStorage::getSupportedServiceNames( )
throw( RuntimeException )
{
return ss_serviceNames;
}
} // namespace scripting_impl
namespace scripting_runtimemgr
{
//*************************************************************************
Reference<XInterface> SAL_CALL ss_create(
const Reference< XComponentContext > & xCompC )
{
return ( cppu::OWeakObject * ) new ::scripting_impl::ScriptStorage( xCompC );
}
//*************************************************************************
Sequence<OUString> ss_getSupportedServiceNames( )
SAL_THROW( () )
{
return ::scripting_impl::ss_serviceNames;
}
//*************************************************************************
OUString ss_getImplementationName( )
SAL_THROW( () )
{
return ::scripting_impl::ss_implName;
}
}//end namespace