| /************************************************************** | |
| * | |
| * 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 ) | |
| : 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 ) | |
| { | |
| OSL_TRACE( "Entering ScriptStorage::initialize\n" ); | |
| // Should not be renitialized | |
| if ( m_bInitialised ) | |
| { | |
| throw RuntimeException( | |
| OUSTR( "ScriptStorage::initialize 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::initialize RuntimeException: " ).concat( re.Message ), | |
| Reference< XInterface > () ); | |
| } | |
| catch ( Exception & ue ) | |
| { | |
| OSL_TRACE( "caught com::sun::star::uno::Exception in ScriptStorage::initialize" ); | |
| throw RuntimeException( | |
| OUSTR( "ScriptStorage::initialize Exception: " ).concat( ue.Message ), | |
| Reference< XInterface > () ); | |
| } | |
| #ifdef _DEBUG | |
| catch ( ... ) | |
| { | |
| OSL_TRACE( "caught unknown Exception in ScriptStorage::initialize" ); | |
| throw RuntimeException( | |
| OUSTR( "ScriptStorage::initialize unknown exception: " ), | |
| Reference< XInterface > () ); | |
| } | |
| #endif | |
| OSL_TRACE( "Parsed the XML\n" ); | |
| m_bInitialised = true; | |
| } | |
| void | |
| ScriptStorage::create() | |
| { | |
| ::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::initialize 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 ) | |
| { | |
| // 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() | |
| { | |
| ::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() | |
| { | |
| 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() | |
| { | |
| 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 ) | |
| { | |
| ::osl::Guard< osl::Mutex > aGuard( m_mutex ); | |
| // format is script:://[function_name]?language=[language]&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 | |
| // ScriptMetaDataImporter has been modified to ignore the Logical name | |
| // defined 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() | |
| { | |
| ::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( ) | |
| { | |
| return ss_implName; | |
| } | |
| //************************************************************************* | |
| sal_Bool SAL_CALL ScriptStorage::supportsService( const OUString& serviceName ) | |
| { | |
| 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( ) | |
| { | |
| 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 |