diff --git a/netwerk/core/public/Makefile.in b/netwerk/core/public/Makefile.in new file mode 100644 index 000000000000..351eb6b63a69 --- /dev/null +++ b/netwerk/core/public/Makefile.in @@ -0,0 +1,39 @@ +# +# 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.org code. +# +# The Initial Developer of the Original Code is Netscape +# Communications Corporation. Portions created by Netscape are +# Copyright (C) 1998 Netscape Communications Corporation. All +# Rights Reserved. +# +# Contributor(s): +# + +DEPTH = ../../.. +topsrcdir = @top_srcdir@ +srcdir = @srcdir@ +VPATH = @srcdir@ + +include $(DEPTH)/config/autoconf.mk + +MODULE = necko + +XPIDLSRCS = \ + nsISimpleFailure.idl \ + nsICompletionEventListener.idl \ + nsIInputStream2.idl \ + nsIOutputStream2.idl \ + $(NULL) + +include $(topsrcdir)/config/rules.mk + diff --git a/netwerk/core/public/makefile.win b/netwerk/core/public/makefile.win new file mode 100644 index 000000000000..18baf43823fc --- /dev/null +++ b/netwerk/core/public/makefile.win @@ -0,0 +1,39 @@ +#!gmake +# +# 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.org code. +# +# The Initial Developer of the Original Code is Netscape +# Communications Corporation. Portions created by Netscape are +# Copyright (C) 1998 Netscape Communications Corporation. All +# Rights Reserved. +# +# Contributor(s): + +MODULE = necko + +DEPTH = ..\..\.. +include <$(DEPTH)/config/config.mak> + +XPIDLSRCS = \ + .\nsISimpleFailure.idl \ + .\nsICompletionEventListener.idl\ + .\nsIInputStream2.idl \ + .\nsIOutputStream2.idl \ + $(NULL) + +include <$(DEPTH)/config/rules.mak> + +$(DEPTH)\netwerk\dist\include: + -mkdir $(DEPTH)\netwerk\dist + -mkdir $(DEPTH)\netwerk\dist\include + diff --git a/netwerk/core/public/nsICompletionEventListener.idl b/netwerk/core/public/nsICompletionEventListener.idl new file mode 100644 index 000000000000..1560c461080d --- /dev/null +++ b/netwerk/core/public/nsICompletionEventListener.idl @@ -0,0 +1,40 @@ +/** + * Goals: + * + * (1) Model streams after NSPR I/O, thus making implementation easy and transparent + * (2) Allow both - blocking and non-blocking operations within the same API framework + * and in doing so streamlining the way application is developed + * (3) All stream implenetations become uniformed in both - blocking and non0blocking + * modes, thus taking partially the functionality of nsIOChannel's and allow simple + * transparent chaining of streams without encouraging excessive buffering + * + * This model will not support NT-style overlapped I/O; there's no good expression for it + * within NSPR either - do we need it? + * + * Changes: + * gagan: streams will not inherit from nsI*Stream to not confuse them with existing + * streams as behavior is a bit different + * ruslan: streams will not have a common base class and Close () operation - this will + * have to be done in the destructor + * ruslan: output stream will not have Flush () operation - this will need to be moved + * into some new BufferedWriter interface + */ + +/** + * this event object is always assumed to be called via proxy on the originating thread's + * event queue + */ + +#include "nsISupports.idl" + +[scriptable, uuid(717fa26d-8ce4-40a9-9e7c-71958bf86ddd)] +interface nsICompletionEventListener : nsISupports +{ + /** + * we don't want any parameters in this method on purpose to avoid dealing with + * their lifecycles; it is listener's responisbility to maintain a reference to + * a stream and then check for errors if needed + */ + void OnComplete (); +}; + diff --git a/netwerk/core/public/nsIInputStream2.idl b/netwerk/core/public/nsIInputStream2.idl new file mode 100644 index 000000000000..766fe38fa9a1 --- /dev/null +++ b/netwerk/core/public/nsIInputStream2.idl @@ -0,0 +1,80 @@ +/** + * Goals: + * + * (1) Model streams after NSPR I/O, thus making implementation easy and transparent + * (2) Allow both - blocking and non-blocking operations within the same API framework + * and in doing so streamlining the way application is developed + * (3) All stream implenetations become uniformed in both - blocking and non0blocking + * modes, thus taking partially the functionality of nsIOChannel's and allow simple + * transparent chaining of streams without encouraging excessive buffering + * + * This model will not support NT-style overlapped I/O; there's no good expression for it + * within NSPR either - do we need it? + * + * Changes: + * gagan: streams will not inherit from nsI*Stream to not confuse them with existing + * streams as behavior is a bit different + * ruslan: streams will not have a common base class and Close () operation - this will + * have to be done in the destructor + * ruslan: output stream will not have Flush () operation - this will need to be moved + * into some new BufferedWriter interface + */ + +#include "nsISupports.idl" +#include "nsISimpleFailure.idl" +#include "nsICompletionEventListener.idl" + +/** + * Quesion? Should we inherit from nsIInputStream and nsIOutputStream or these should be complete + * replacements since the semantic of Read/Write/Etc. is a bit different? + */ +[scriptable, uuid(aedae738-3041-4418-b808-40db58a9e7b9)] +interface nsIInputStream2 : nsISupports +{ + /** + * Read data from the stream. + * @param aBuf the buffer into which the data is read + * @param aCount the maximum number of bytes to read + * @return aReadCount out parameter to hold the number of + * bytes read, eof if 0. if an error occurs, the + * read count will be undefined + * @comment in case of non-blocking call Read may return WOULD_BLOCK + * error code and the appropriate listener will be called upon + * completion. The consumer then still will have to call Read + * again to retreive the actual data + */ + + [noscript] unsigned long Read (in charPtr buf, in unsigned long count); + + /** + * Optional attribute which defines expected data length of the input + * stream. It's purpose in life is to aid i/o layers whith the length + * of the stream externally prescribed + */ + attribute long Length; + + /** + * a number of bytes read from the stream + */ + readonly attribute unsigned long Count; + + /** + * This attribute determines whether Read would block or not. In case of + * a non-blocking stream - completion listener will be called only when + * Read returns WOULD_BLOCK. Stream implementations are expected to be + * able to switch between blocking and non-blocking modes on the fly + */ + attribute boolean Blocking; + + /** + * Optional completion listener: the listener will only be used when Read + * returns WOULD_BLOCK. There is no guarantee that the number of Reads will + * match the number of times the listener is invoked. + * In all cases the subsequent Read call must be made to retrieve the actuall + * data or an error code. The listener will always be called via Proxy object + */ + attribute nsICompletionEventListener Listener; + + readonly attribute nsISimpleFailure StreamError; +}; + diff --git a/netwerk/core/public/nsIOutputStream2.idl b/netwerk/core/public/nsIOutputStream2.idl new file mode 100644 index 000000000000..2b544ec957c9 --- /dev/null +++ b/netwerk/core/public/nsIOutputStream2.idl @@ -0,0 +1,66 @@ +/** + * Goals: + * + * (1) Model streams after NSPR I/O, thus making implementation easy and transparent + * (2) Allow both - blocking and non-blocking operations within the same API framework + * and in doing so streamlining the way application is developed + * (3) All stream implenetations become uniformed in both - blocking and non0blocking + * modes, thus taking partially the functionality of nsIOChannel's and allow simple + * transparent chaining of streams without encouraging excessive buffering + * + * This model will not support NT-style overlapped I/O; there's no good expression for it + * within NSPR either - do we need it? + * + * Changes: + * gagan: streams will not inherit from nsI*Stream to not confuse them with existing + * streams as behavior is a bit different + * ruslan: streams will not have a common base class and Close () operation - this will + * have to be done in the destructor + * ruslan: output stream will not have Flush () operation - this will need to be moved + * into some new BufferedWriter interface + */ + +#include "nsISupports.idl" +#include "nsISimpleFailure.idl" +#include "nsICompletionEventListener.idl" + +[scriptable, uuid(295c8dfa-7031-4615-a6c9-ddb692901035)] +interface nsIOutputStream2 : nsISupports +{ + /** Write data into the stream. + * @param aBuf the buffer from which the data is read + * @param aCount the maximum number of bytes to write + * @return aWriteCount out parameter to hold the number of + * bytes written. if an error occurs, the writecount + * is undefined + */ + unsigned long Write(in string buf, in unsigned long count); + + /** + * Optional attribute which defines expected data length of the output + * stream. It's purpose in life is to aid i/o layers whith the length + * of the stream externally prescribed + */ + attribute long Length; + + /** + * a number of bytes written into the stream + */ + readonly attribute unsigned long Count; + + /** + * This attribute determines whether Read would block or not. In case of + * a non-blocking stream - completion listener will be called only when + * Write returns WOULD_BLOCK. Stream implementations are expected to be + * able to switch between blocking and non-blocking modes on the fly + */ + attribute boolean Blocking; + + /** + * Optional completion listener: the listener will only be used when Write + * or Flush returns WOULD_BLOCK. + */ + attribute nsICompletionEventListener Listener; + + readonly attribute nsISimpleFailure StreamError; +}; diff --git a/netwerk/core/public/nsISimpleFailure.idl b/netwerk/core/public/nsISimpleFailure.idl new file mode 100644 index 000000000000..99c51c15db7b --- /dev/null +++ b/netwerk/core/public/nsISimpleFailure.idl @@ -0,0 +1,36 @@ +/** + * Goals: + * + * (1) Model streams after NSPR I/O, thus making implementation easy and transparent + * (2) Allow both - blocking and non-blocking operations within the same API framework + * and in doing so streamlining the way application is developed + * (3) All stream implenetations become uniformed in both - blocking and non0blocking + * modes, thus taking partially the functionality of nsIOChannel's and allow simple + * transparent chaining of streams without encouraging excessive buffering + * + * This model will not support NT-style overlapped I/O; there's no good expression for it + * within NSPR either - do we need it? + * + * Changes: + * gagan: streams will not inherit from nsI*Stream to not confuse them with existing + * streams as behavior is a bit different + * ruslan: streams will not have a common base class and Close () operation - this will + * have to be done in the destructor + * ruslan: output stream will not have Flush () operation - this will need to be moved + * into some new BufferedWriter interface + */ + +#include "nsISupports.idl" + +/** + * Since we don't support exceptions - this is essentially an exception object to report + * extended I/O errors up stream; it can have furher dependency on a common error-reporting + * structure, such as GenericFailure for example + */ +[scriptable, uuid(2a5dd631-494f-4693-a2e1-15bbcc80846e)] +interface nsISimpleFailure : nsISupports +{ + readonly attribute unsigned long osErrorCode; + readonly attribute unsigned long errorCode; + readonly attribute string message; +};