/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ /* ***** BEGIN LICENSE BLOCK ***** * Version: NPL 1.1/GPL 2.0/LGPL 2.1 * * The contents of this file are subject to the Netscape Public License * Version 1.1 (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.mozilla.org/NPL/ * * Software distributed under the License is distributed on an "AS IS" basis, * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License * for the specific language governing rights and limitations under the * License. * * The Original Code is Mozilla FastLoad code. * * The Initial Developer of the Original Code is * Netscape Communications Corporation. * Portions created by the Initial Developer are Copyright (C) 2001 * the Initial Developer. All Rights Reserved. * * Contributor(s): * Brendan Eich (original author) * * Alternatively, the contents of this file may be used under the terms of * either the GNU General Public License Version 2 or later (the "GPL"), or * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), * in which case the provisions of the GPL or the LGPL are applicable instead * of those above. If you wish to allow use of your version of this file only * under the terms of either the GPL or the LGPL, and not to allow others to * use your version of this file under the terms of the NPL, indicate your * decision by deleting the provisions above and replace them with the notice * and other provisions required by the GPL or the LGPL. If you do not delete * the provisions above, a recipient may use your version of this file under * the terms of any one of the NPL, the GPL or the LGPL. * * ***** END LICENSE BLOCK ***** */ #include "nsISupports.idl" #include "nsrootidl.idl" interface nsIFastLoadReadControl; interface nsIFile; interface nsIInputStream; interface nsIOutputStream; interface nsIObjectInputStream; interface nsIObjectOutputStream; [scriptable, uuid(715577db-d9c5-464a-a32e-0a40c29b22d4)] interface nsIFastLoadFileIO : nsISupports { readonly attribute nsIInputStream inputStream; readonly attribute nsIOutputStream outputStream; }; [scriptable, uuid(759e475e-0c23-4dbf-b1b8-78c9369e3072)] interface nsIFastLoadService : nsISupports { nsIFile newFastLoadFile(in string aBaseName); nsIObjectInputStream newInputStream(in nsIInputStream aSrcStream); nsIObjectOutputStream newOutputStream(in nsIOutputStream aDestStream); // Flag values for the direction attribute and the aDirectionFlags // parameter to startMuxedDocument. const PRInt32 NS_FASTLOAD_READ = 1; const PRInt32 NS_FASTLOAD_WRITE = 2; attribute nsIObjectInputStream inputStream; attribute nsIObjectOutputStream outputStream; attribute nsIFastLoadFileIO fileIO; readonly attribute PRInt32 direction; /** * These methods associate a URI object with its spec, for faster select * using the object pointer as a key, rather than the spec string. The * selectMuxedDocument method returns the previously selected URI object, * in case a caller needs to reselect the previous after muxing data for * a given URI synchronously. For the non-blocking or "asynchronous" i/o * case, the caller must select the source URI from the FastLoad multiplex * before writing a new burst of data parsed from the slow-loaded source. * * Clients of inputStream and outputStream should try to demultiplex data * from the input stream only if fastLoadService->StartMuxedDocument(uri, * urispec, NS_FASTLOAD_READ) succeeds. If StartMuxedDocument fails with * NS_ERROR_NOT_AVAILABLE, callers should slow-load the documents, muxing * their data to the current output stream. */ void startMuxedDocument(in nsISupports aURI, in string aURISpec, in PRInt32 aDirectionFlags); nsISupports selectMuxedDocument(in nsISupports aURI); void endMuxedDocument(in nsISupports aURI); void addDependency(in nsIFile aFile); PRUint32 computeChecksum(in nsIFile aFile, in nsIFastLoadReadControl aControl); void cacheChecksum(in nsIFile aFile, in nsIObjectOutputStream aStream); [noscript] void getFastLoadReferent(inout nsISupports aPtr); [noscript] void readFastLoadPtr(in nsIObjectInputStream aInputStream, inout nsISupports aPtr); [noscript] void writeFastLoadPtr(in nsIObjectOutputStream aOutputStream, in nsISupports aPtr); /** * Return true if aURISpec identifies a muxed document in the FastLoad * file, false otherwise. */ boolean hasMuxedDocument(in string aURISpec); }; %{C++ #define NS_FASTLOADSERVICE_CLASSNAME "Mozilla FastLoad Service" #define NS_FASTLOADSERVICE_CID \ {0xc943093c,0xac94,0x4bee,{0x84,0x0b,0x8b,0x5a,0x6e,0x31,0x4f,0xa7}} #define NS_FASTLOADSERVICE_CONTRACTID \ "@mozilla.org/fast-load-service;1" #ifndef nsCOMPtr_h___ # include "nsCOMPtr.h" #endif #ifndef __gen_nsIFile_h__ # include "nsIFile.h" #endif #ifndef nsIServiceManager_h___ # include "nsIServiceManager.h" #endif inline const nsGetServiceByCID do_GetFastLoadService(nsresult *aResultCode = 0) { static NS_DEFINE_CID(kFastLoadServiceCID, NS_FASTLOADSERVICE_CID); return nsGetServiceByCID(kFastLoadServiceCID, nsnull, aResultCode); } inline nsresult NS_AddFastLoadDependency(nsIFile* aFile) { nsCOMPtr fastLoadService(do_GetFastLoadService()); if (fastLoadService) { nsresult rv = fastLoadService->AddDependency(aFile); if (NS_FAILED(rv) && rv != NS_ERROR_NOT_AVAILABLE) return rv; } return NS_OK; } %}