/*
 * DO NOT EDIT.  THIS FILE IS GENERATED FROM nsICachedNetData.idl
 */

#ifndef __gen_nsICachedNetData_h__
#define __gen_nsICachedNetData_h__

#include "nsrootidl.h"
#include "nsISupports.h"

class nsIURI; /* forward declaration */

class nsIObserver; /* forward declaration */

class nsIChannel; /* forward declaration */

class nsINetDataCache; /* forward declaration */

class nsINetDataCacheRecord; /* forward declaration */

class nsILoadGroup; /* forward declaration */

class nsIStreamListener; /* forward declaration */


/* starting interface:    nsICachedNetData */
#define NS_ICACHEDNETDATA_IID_STR "6aeb2a40-6d43-11d3-90c8-000064657374"

#define NS_ICACHEDNETDATA_IID \
  {0x6aeb2a40, 0x6d43, 0x11d3, \
    { 0x90, 0xc8, 0x00, 0x00, 0x64, 0x65, 0x73, 0x74 }}

/**
 * The nsICachedNetData interface represents a single entry in a database that
 * caches data retrieved from the network. This interface is implemented by the
 * cache manager on top of the low-level nsINetDataCacheRecord and
 * nsINetDataCache interfaces that are implemented by the database.
 *
 * Each cache record may contain both content and metadata.  The content may
 * be, for example, GIF image data or HTML, and it is accessed through
 * nsIChannel's streaming API.  The opaque metadata, which may contain HTTP
 * headers among other things, is stored as a byte array.  Each entry in the
 * cache is indexed by two different keys: a record id number and a key created
 * by combining the URI with a "secondary key", e.g. HTTP post data.
 *
 * @See nsINetDataCacheRecord
 * @See nsINetDataCache
 * @See nsINetDataDiskCache
 * @See nsINetDataCacheManager
 */
class NS_NO_VTABLE nsICachedNetData : public nsISupports {
 public: 

  NS_DEFINE_STATIC_IID_ACCESSOR(NS_ICACHEDNETDATA_IID)

  /**
     * String form of the URI provided as an argument to the call to
     * nsINetDataCacheManager::GetCachedNetData() that created this record.
     */
  /* readonly attribute string uriSpec; */
  NS_IMETHOD GetUriSpec(char * *aUriSpec) = 0;

  /**
     * Getter for the opaque secondary database key provided as an argument to
     * the call to nsINetDataCacheManager::GetCachedNetData() that created this
     * record.
     */
  /* void getSecondaryKey (out unsigned long length, [size_is (length), retval] out string secondaryKey); */
  NS_IMETHOD GetSecondaryKey(PRUint32 *length, char **secondaryKey) = 0;

  /**
     * This flag may be set by a protocol handler to indicate that it supports
     * partial fetching of data.  In that case, the cache manager is permitted
     * to truncate the entry's content to accommodate incoming data for other
     * cache entries rather than deleting it wholesale.
     */
  /* attribute boolean allowPartial; */
  NS_IMETHOD GetAllowPartial(PRBool *aAllowPartial) = 0;
  NS_IMETHOD SetAllowPartial(PRBool aAllowPartial) = 0;

  /**
     * This flag indicates that the write stream supplying content data for the
     * cache did not complete normally and, therefore, the content may be
     * truncated.
     */
  /* readonly attribute boolean partialFlag; */
  NS_IMETHOD GetPartialFlag(PRBool *aPartialFlag) = 0;

  /**
     * This flag can be set and cleared by a protocol handler as a form of
     * self-notification, so as to avoid race conditions in which a protocol
     * handler issues two identical network requests to fill the same cache
     * entry.  The cache manager itself largely ignores this flag.
     */
  /* attribute boolean updateInProgress; */
  NS_IMETHOD GetUpdateInProgress(PRBool *aUpdateInProgress) = 0;
  NS_IMETHOD SetUpdateInProgress(PRBool aUpdateInProgress) = 0;

  /**
     * inUse is set if any existing channels are associated with this cache
     * entry or if the updateInProgess flag is set.  This can be used to
     * prevent writing to a cache entry by a protocol handler if it's being
     * read or written elsewhere.
     */
  /* readonly attribute boolean inUse; */
  NS_IMETHOD GetInUse(PRBool *aInUse) = 0;

  /**
     * Date/time that the document was last stored on the origin server, as
     * supplied by the protocol handler.  This value is used as input to the
     * cache replacement policy, i.e. it is not used for validation.  If the
     * protocol can't supply a last-modified time, this attribute should remain
     * unset.  When unset, the value of this attribute is zero.
     *
     * FIXME: Should use nsIDateTime interface, once it's created
     * instead of PRTime, for improved scriptability ? 
     */
  /* attribute PRTime lastModifiedTime; */
  NS_IMETHOD GetLastModifiedTime(PRTime *aLastModifiedTime) = 0;
  NS_IMETHOD SetLastModifiedTime(PRTime aLastModifiedTime) = 0;

  /**
     * Supplied by the protocol handler, the expirationTime attribute specifies
     * the time until which the document is guaranteed fresh, i.e. the document
     * does not have to be validated with the server and, therefore, any data
     * in cache is definitely usable.  The value of this attribute serves as a
     * hint to the cache replacement policy.  Only one of either staleTime or
     * expirationTime may be set for a single cache record.  When unset, the
     * value of this attribute is zero. 
     */
  /* attribute PRTime expirationTime; */
  NS_IMETHOD GetExpirationTime(PRTime *aExpirationTime) = 0;
  NS_IMETHOD SetExpirationTime(PRTime aExpirationTime) = 0;

  /**
     * Date/time supplied by the protocol handler, at which point the content
     * is *likely* to be stale, i.e. the data in the cache may be out-of-date
     * with respect to the data on the server.  This heuristic date does not
     * necessarily correspond to the HTTP Expires header, as it does not
     * determine when cached network data must be validated with the origin
     * server, but only serves as a hint to the cache replacement policy.  Only
     * one of either staleTime or expirationTime may be set for a single cache
     * record.  When unset, the value of this attribute is zero.
     */
  /* attribute PRTime staleTime; */
  NS_IMETHOD GetStaleTime(PRTime *aStaleTime) = 0;
  NS_IMETHOD SetStaleTime(PRTime aStaleTime) = 0;

  /**
     * Date/time of last access of the data in this cache record, as determined
     * by the cache manager.
     */
  /* readonly attribute PRTime lastAccessTime; */
  NS_IMETHOD GetLastAccessTime(PRTime *aLastAccessTime) = 0;

  /* readonly attribute PRTime lastUpdateTime; */
  NS_IMETHOD GetLastUpdateTime(PRTime *aLastUpdateTime) = 0;

  /**
     * Number of times this record has been accessed since it was first stored.
     */
  /* readonly attribute PRUint16 numberAccesses; */
  NS_IMETHOD GetNumberAccesses(PRUint16 *aNumberAccesses) = 0;

  /**
     * Accessor methods for opaque meta-data which can be read and updated
     * independently of the content data.
     *
     * The aTag argument can be used to accommodate multiple clients of the
     * cache API, each of which wants to store its own private meta-data into
     * the cache.  For example, there could be a "headers" tag that the HTTP
     * protocol handler uses to store http response headers and a "image size"
     * tag used to store the image dimensions of a GIF file.  The aData
     * argument refers to an opaque blob of arbitrary bytes.
     *
     * IMPORTANT: If aData does not contain byte-oriented data, i.e. it's not a
     *            string, the contents of aData must be byte-swapped by the,
     *            caller, so as to make the cache files endian-independent.
     */
  /* void getAnnotation (in string aTag, out PRUint32 aLength, [size_is (aLength), retval] out string aData); */
  NS_IMETHOD GetAnnotation(const char *aTag, PRUint32 *aLength, char **aData) = 0;

  /* void setAnnotation (in string aTag, in PRUint32 aLength, [size_is (aLength)] in string aData); */
  NS_IMETHOD SetAnnotation(const char *aTag, PRUint32 aLength, const char *aData) = 0;

  /**
     * As a getter, return the number of content bytes stored in the cache,
     * i.e. via the nsIChannel streaming APIs.  This may be less than the
     * complete content length if a partial cache fill occurred.  The cached
     * content can be truncated by setting the value of this attribute.  The
     * value of the attribute represents a logical, not a physical, length.  If
     * compression has been used, the content may consume less storage than
     * indicated by this attribute.
     *
     * When this attribute is set to zero the associated cache disk file, if
     * any, should be deleted.
     */
  /* attribute PRUint32 storedContentLength; */
  NS_IMETHOD GetStoredContentLength(PRUint32 *aStoredContentLength) = 0;
  NS_IMETHOD SetStoredContentLength(PRUint32 aStoredContentLength) = 0;

  /**
	 * Length of stored content, which may be less than storage consumed if
     * compression is used
	 */
  /* readonly attribute PRUint32 logicalLength; */
  NS_IMETHOD GetLogicalLength(PRUint32 *aLogicalLength) = 0;

  /**
	 * Opaque security info associated with the cache entry; it can't be serialized
	 * to disk, so it'll only make sense with memory cache
	 */
  /* attribute nsISupports securityInfo; */
  NS_IMETHOD GetSecurityInfo(nsISupports * *aSecurityInfo) = 0;
  NS_IMETHOD SetSecurityInfo(nsISupports * aSecurityInfo) = 0;

  /** 
     * Notify any observers associated with this cache entry of the deletion
     * request.  If all observers drop their reference to the cache entry,
     * proceed to delete the underlying cache database record and associated
     * content storage.
     */
  /* void delete (); */
  NS_IMETHOD Delete(void) = 0;

  /**
     * Flush any changes in this entry's data to the cache database.  This
     * method will automatically be called when the last reference to the cache
     * is dropped, but it can also be called explicitly for a synchronous
     * effect.
     */
  /* void commit (); */
  NS_IMETHOD Commit(void) = 0;

  /**
     * Parent container cache for this entry.
     */
  /* readonly attribute nsINetDataCache cache; */
  NS_IMETHOD GetCache(nsINetDataCache * *aCache) = 0;

  /**
     * Create a channel for reading or writing a stream of content into the
     * entry.  It is expected that many of the nsIChannel methods return
     * NS_NOT_IMPLEMENTED, including:
     *
     *    + GetURI()
     *    + GetContentType()
     *    + GetContentLength()
     *
     * Though nsIChannel provides for both async and synchronous I/O APIs, both
     * may not be implemented.  Only AsyncRead() and OpenOutputStream() is
     * required.  
     */
  /* nsIChannel newChannel (in nsILoadGroup aLoadGroup); */
  NS_IMETHOD NewChannel(nsILoadGroup *aLoadGroup, nsIChannel **_retval) = 0;

  /**
     * This method can be used by a caching protocol handler to store data in
     * the cache by forking an asynchronous read stream so that it is
     * simultaneously sent to a requester and written into the cache.  This
     * method implicitly sets the updateInProgress flag, if it has not already
     * been set.
     */
  /* nsIStreamListener interceptAsyncRead (in nsIStreamListener aOriginalListener, in PRUint32 aStartOffset); */
  NS_IMETHOD InterceptAsyncRead(nsIStreamListener *aOriginalListener, PRUint32 aStartOffset, nsIStreamListener **_retval) = 0;

};

/* Use this macro when declaring classes that implement this interface. */
#define NS_DECL_NSICACHEDNETDATA \
  NS_IMETHOD GetUriSpec(char * *aUriSpec); \
  NS_IMETHOD GetSecondaryKey(PRUint32 *length, char **secondaryKey); \
  NS_IMETHOD GetAllowPartial(PRBool *aAllowPartial); \
  NS_IMETHOD SetAllowPartial(PRBool aAllowPartial); \
  NS_IMETHOD GetPartialFlag(PRBool *aPartialFlag); \
  NS_IMETHOD GetUpdateInProgress(PRBool *aUpdateInProgress); \
  NS_IMETHOD SetUpdateInProgress(PRBool aUpdateInProgress); \
  NS_IMETHOD GetInUse(PRBool *aInUse); \
  NS_IMETHOD GetLastModifiedTime(PRTime *aLastModifiedTime); \
  NS_IMETHOD SetLastModifiedTime(PRTime aLastModifiedTime); \
  NS_IMETHOD GetExpirationTime(PRTime *aExpirationTime); \
  NS_IMETHOD SetExpirationTime(PRTime aExpirationTime); \
  NS_IMETHOD GetStaleTime(PRTime *aStaleTime); \
  NS_IMETHOD SetStaleTime(PRTime aStaleTime); \
  NS_IMETHOD GetLastAccessTime(PRTime *aLastAccessTime); \
  NS_IMETHOD GetLastUpdateTime(PRTime *aLastUpdateTime); \
  NS_IMETHOD GetNumberAccesses(PRUint16 *aNumberAccesses); \
  NS_IMETHOD GetAnnotation(const char *aTag, PRUint32 *aLength, char **aData); \
  NS_IMETHOD SetAnnotation(const char *aTag, PRUint32 aLength, const char *aData); \
  NS_IMETHOD GetStoredContentLength(PRUint32 *aStoredContentLength); \
  NS_IMETHOD SetStoredContentLength(PRUint32 aStoredContentLength); \
  NS_IMETHOD GetLogicalLength(PRUint32 *aLogicalLength); \
  NS_IMETHOD GetSecurityInfo(nsISupports * *aSecurityInfo); \
  NS_IMETHOD SetSecurityInfo(nsISupports * aSecurityInfo); \
  NS_IMETHOD Delete(void); \
  NS_IMETHOD Commit(void); \
  NS_IMETHOD GetCache(nsINetDataCache * *aCache); \
  NS_IMETHOD NewChannel(nsILoadGroup *aLoadGroup, nsIChannel **_retval); \
  NS_IMETHOD InterceptAsyncRead(nsIStreamListener *aOriginalListener, PRUint32 aStartOffset, nsIStreamListener **_retval); 

/* Use this macro to declare functions that forward the behavior of this interface to another object. */
#define NS_FORWARD_NSICACHEDNETDATA(_to) \
  NS_IMETHOD GetUriSpec(char * *aUriSpec) { return _to ## GetUriSpec(aUriSpec); } \
  NS_IMETHOD GetSecondaryKey(PRUint32 *length, char **secondaryKey) { return _to ## GetSecondaryKey(length, secondaryKey); } \
  NS_IMETHOD GetAllowPartial(PRBool *aAllowPartial) { return _to ## GetAllowPartial(aAllowPartial); } \
  NS_IMETHOD SetAllowPartial(PRBool aAllowPartial) { return _to ## SetAllowPartial(aAllowPartial); } \
  NS_IMETHOD GetPartialFlag(PRBool *aPartialFlag) { return _to ## GetPartialFlag(aPartialFlag); } \
  NS_IMETHOD GetUpdateInProgress(PRBool *aUpdateInProgress) { return _to ## GetUpdateInProgress(aUpdateInProgress); } \
  NS_IMETHOD SetUpdateInProgress(PRBool aUpdateInProgress) { return _to ## SetUpdateInProgress(aUpdateInProgress); } \
  NS_IMETHOD GetInUse(PRBool *aInUse) { return _to ## GetInUse(aInUse); } \
  NS_IMETHOD GetLastModifiedTime(PRTime *aLastModifiedTime) { return _to ## GetLastModifiedTime(aLastModifiedTime); } \
  NS_IMETHOD SetLastModifiedTime(PRTime aLastModifiedTime) { return _to ## SetLastModifiedTime(aLastModifiedTime); } \
  NS_IMETHOD GetExpirationTime(PRTime *aExpirationTime) { return _to ## GetExpirationTime(aExpirationTime); } \
  NS_IMETHOD SetExpirationTime(PRTime aExpirationTime) { return _to ## SetExpirationTime(aExpirationTime); } \
  NS_IMETHOD GetStaleTime(PRTime *aStaleTime) { return _to ## GetStaleTime(aStaleTime); } \
  NS_IMETHOD SetStaleTime(PRTime aStaleTime) { return _to ## SetStaleTime(aStaleTime); } \
  NS_IMETHOD GetLastAccessTime(PRTime *aLastAccessTime) { return _to ## GetLastAccessTime(aLastAccessTime); } \
  NS_IMETHOD GetLastUpdateTime(PRTime *aLastUpdateTime) { return _to ## GetLastUpdateTime(aLastUpdateTime); } \
  NS_IMETHOD GetNumberAccesses(PRUint16 *aNumberAccesses) { return _to ## GetNumberAccesses(aNumberAccesses); } \
  NS_IMETHOD GetAnnotation(const char *aTag, PRUint32 *aLength, char **aData) { return _to ## GetAnnotation(aTag, aLength, aData); } \
  NS_IMETHOD SetAnnotation(const char *aTag, PRUint32 aLength, const char *aData) { return _to ## SetAnnotation(aTag, aLength, aData); } \
  NS_IMETHOD GetStoredContentLength(PRUint32 *aStoredContentLength) { return _to ## GetStoredContentLength(aStoredContentLength); } \
  NS_IMETHOD SetStoredContentLength(PRUint32 aStoredContentLength) { return _to ## SetStoredContentLength(aStoredContentLength); } \
  NS_IMETHOD GetLogicalLength(PRUint32 *aLogicalLength) { return _to ## GetLogicalLength(aLogicalLength); } \
  NS_IMETHOD GetSecurityInfo(nsISupports * *aSecurityInfo) { return _to ## GetSecurityInfo(aSecurityInfo); } \
  NS_IMETHOD SetSecurityInfo(nsISupports * aSecurityInfo) { return _to ## SetSecurityInfo(aSecurityInfo); } \
  NS_IMETHOD Delete(void) { return _to ## Delete(); } \
  NS_IMETHOD Commit(void) { return _to ## Commit(); } \
  NS_IMETHOD GetCache(nsINetDataCache * *aCache) { return _to ## GetCache(aCache); } \
  NS_IMETHOD NewChannel(nsILoadGroup *aLoadGroup, nsIChannel **_retval) { return _to ## NewChannel(aLoadGroup, _retval); } \
  NS_IMETHOD InterceptAsyncRead(nsIStreamListener *aOriginalListener, PRUint32 aStartOffset, nsIStreamListener **_retval) { return _to ## InterceptAsyncRead(aOriginalListener, aStartOffset, _retval); } 

#if 0
/* Use the code below as a template for the implementation class for this interface. */

/* Header file */
class nsCachedNetData : public nsICachedNetData
{
public:
  NS_DECL_ISUPPORTS
  NS_DECL_NSICACHEDNETDATA

  nsCachedNetData();
  virtual ~nsCachedNetData();
  /* additional members */
};

/* Implementation file */
NS_IMPL_ISUPPORTS1(nsCachedNetData, nsICachedNetData)

nsCachedNetData::nsCachedNetData()
{
  NS_INIT_ISUPPORTS();
  /* member initializers and constructor code */
}

nsCachedNetData::~nsCachedNetData()
{
  /* destructor code */
}

/* readonly attribute string uriSpec; */
NS_IMETHODIMP nsCachedNetData::GetUriSpec(char * *aUriSpec)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void getSecondaryKey (out unsigned long length, [size_is (length), retval] out string secondaryKey); */
NS_IMETHODIMP nsCachedNetData::GetSecondaryKey(PRUint32 *length, char **secondaryKey)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* attribute boolean allowPartial; */
NS_IMETHODIMP nsCachedNetData::GetAllowPartial(PRBool *aAllowPartial)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP nsCachedNetData::SetAllowPartial(PRBool aAllowPartial)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* readonly attribute boolean partialFlag; */
NS_IMETHODIMP nsCachedNetData::GetPartialFlag(PRBool *aPartialFlag)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* attribute boolean updateInProgress; */
NS_IMETHODIMP nsCachedNetData::GetUpdateInProgress(PRBool *aUpdateInProgress)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP nsCachedNetData::SetUpdateInProgress(PRBool aUpdateInProgress)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* readonly attribute boolean inUse; */
NS_IMETHODIMP nsCachedNetData::GetInUse(PRBool *aInUse)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* attribute PRTime lastModifiedTime; */
NS_IMETHODIMP nsCachedNetData::GetLastModifiedTime(PRTime *aLastModifiedTime)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP nsCachedNetData::SetLastModifiedTime(PRTime aLastModifiedTime)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* attribute PRTime expirationTime; */
NS_IMETHODIMP nsCachedNetData::GetExpirationTime(PRTime *aExpirationTime)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP nsCachedNetData::SetExpirationTime(PRTime aExpirationTime)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* attribute PRTime staleTime; */
NS_IMETHODIMP nsCachedNetData::GetStaleTime(PRTime *aStaleTime)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP nsCachedNetData::SetStaleTime(PRTime aStaleTime)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* readonly attribute PRTime lastAccessTime; */
NS_IMETHODIMP nsCachedNetData::GetLastAccessTime(PRTime *aLastAccessTime)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* readonly attribute PRTime lastUpdateTime; */
NS_IMETHODIMP nsCachedNetData::GetLastUpdateTime(PRTime *aLastUpdateTime)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* readonly attribute PRUint16 numberAccesses; */
NS_IMETHODIMP nsCachedNetData::GetNumberAccesses(PRUint16 *aNumberAccesses)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void getAnnotation (in string aTag, out PRUint32 aLength, [size_is (aLength), retval] out string aData); */
NS_IMETHODIMP nsCachedNetData::GetAnnotation(const char *aTag, PRUint32 *aLength, char **aData)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void setAnnotation (in string aTag, in PRUint32 aLength, [size_is (aLength)] in string aData); */
NS_IMETHODIMP nsCachedNetData::SetAnnotation(const char *aTag, PRUint32 aLength, const char *aData)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* attribute PRUint32 storedContentLength; */
NS_IMETHODIMP nsCachedNetData::GetStoredContentLength(PRUint32 *aStoredContentLength)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP nsCachedNetData::SetStoredContentLength(PRUint32 aStoredContentLength)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* readonly attribute PRUint32 logicalLength; */
NS_IMETHODIMP nsCachedNetData::GetLogicalLength(PRUint32 *aLogicalLength)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* attribute nsISupports securityInfo; */
NS_IMETHODIMP nsCachedNetData::GetSecurityInfo(nsISupports * *aSecurityInfo)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP nsCachedNetData::SetSecurityInfo(nsISupports * aSecurityInfo)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void delete (); */
NS_IMETHODIMP nsCachedNetData::Delete()
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void commit (); */
NS_IMETHODIMP nsCachedNetData::Commit()
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* readonly attribute nsINetDataCache cache; */
NS_IMETHODIMP nsCachedNetData::GetCache(nsINetDataCache * *aCache)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* nsIChannel newChannel (in nsILoadGroup aLoadGroup); */
NS_IMETHODIMP nsCachedNetData::NewChannel(nsILoadGroup *aLoadGroup, nsIChannel **_retval)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* nsIStreamListener interceptAsyncRead (in nsIStreamListener aOriginalListener, in PRUint32 aStartOffset); */
NS_IMETHODIMP nsCachedNetData::InterceptAsyncRead(nsIStreamListener *aOriginalListener, PRUint32 aStartOffset, nsIStreamListener **_retval)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* End of implementation class template. */
#endif


#endif /* __gen_nsICachedNetData_h__ */
