Filtering and layering functionality onto a TCP byte stream

class IFilterStreamSocketConnections
{
   public :
  
      /// Called once before any other method on this interface is called. 
      /// The sink interface should be used to pass calls onto the next filter
      /// in the chain and the manager interface should be used to generate
      /// new read and write events.
  
      virtual void InitialiseFilter(
         IFilterStreamSocketConnections &sink,
         IManageStreamSocketConnectionFilters &manager) = 0;
  
      /// The type of connection that is being filtered.
   
      enum ConnectType
      {
         ConnectTypeSync,
         ConnectTypeSyncNoThrow,
         ConnectTypeAsync
      };
  
      /// Called before an outbound connection is attempted but after the 
      /// socket is allocated. This call can be used to block or reroute 
      /// connections or to "plug" connect data into the socket's user data.
  
      virtual CSmartStreamSocket FilterConnect(
         const ConnectType connectType,
         IStreamSocketEx &socket,
         const IFullAddress &address,
         const void *pUserData,
         const void *pServerData) = 0;
  
      /// Called when a connection (inbound or outbound) is established. You
      /// can determine which direction the connection is (if that's important)
      /// by calling GetConnectionDirection() on the socket.
  
      virtual void FilterConnectionEstablished(
         IStreamSocketEx &socket,
         const IAddress &address) = 0;
  
      /// Called when a read is requested. The buffer is optional, if no buffer
      /// is passed with the call then one will be allocated just before the 
      /// read is issued. Filters can prevent the application (and filters 
      /// above) from issuing reads by simply not passing these calls on to
      /// the next filter in the chain. If a filter wishes to generate its own
      /// reads then it should use IManageStreamSocketConnectionFilters rather
      /// than calling this function with its own buffers.
  
      virtual void FilterReadRequest(
         IStreamSocketEx &socket,
         JetByteTools::IO::IBuffer *pBuffer) = 0;
  
      /// Called when a read has completed. The filter can manipulate the data
      /// in any way that they like, this includes using the data for their own
      /// purposes and swallowing read completions and also generating their
      /// own read completions via the IManageStreamSocketConnectionFilters
      /// interface.
  
      virtual void FilterReadCompleted(
         IStreamSocketEx &socket,
         JetByteTools::IO::IBuffer &buffer) = 0;
  
      /// Called when a read has completed with an error. The filter can manipulate 
      /// the data in any way that they like, this includes using the data for 
      /// their own purposes and swallowing read completions and also generating 
      /// their own read completions via the IManageStreamSocketConnectionFilters
      /// interface. Note that fiddling around with completion errors is probably
      /// unwise...
  
      virtual void FilterReadCompletionError(
         IStreamSocketEx &socket,
         JetByteTools::IO::IBuffer &buffer,
         const DWORD lastError) = 0;
  
      /// Called when a write is requested. Filters can prevent the application 
      /// (and filters above) from issuing reads by simply not passing these 
      /// calls on to the next filter in the chain. If a filter wishes to 
      /// generate its own reads then it should use 
      /// IManageStreamSocketConnectionFilters rather than calling this function 
      /// with its own buffers.
  
      virtual void FilterWriteRequest(
         IStreamSocketEx &socket,
         JetByteTools::IO::IBuffer &buffer) = 0;
  
      /// Called when a write has completed. The filter can manipulate the data
      /// in any way that they like, this includes using the data for their own
      /// purposes and swallowing write completions and also generating their
      /// own write completions via the IManageStreamSocketConnectionFilters
      /// interface.
  
      virtual void FilterWriteCompleted(
         IStreamSocketEx &socket,
         JetByteTools::IO::IBuffer &buffer) = 0;
  
      /// Called when a write has completed with an error. The filter can manipulate
      /// the data in any way that they like, this includes using the data for 
      /// their own purposes and swallowing write completions and also generating
      /// their own write completions via the IManageStreamSocketConnectionFilters
      /// interface. Note that fiddling around with completion errors is probably
      /// unwise...
  
      virtual void FilterWriteCompletionError(
         IStreamSocketEx &socket,
         JetByteTools::IO::IBuffer &buffer,
         const DWORD lastError) = 0;
  
      /// Called after IStreamSocketConnectionManagerCallback::OnSocketReleased() 
      /// callback and before the socket is passed to the allocator. This can
      /// be used to remove any user data that was added by the filter in a
      /// FilterConnect() call.
  
      virtual void FilterSocketReleased(
         JetByteTools::Win32::IIndexedOpaqueUserData &userData) = 0;
     
   protected :
   
      /// We never delete instances of this interface; you must manage the 
      /// lifetime of the class that implements it.
  
      ~IFilterStreamSocketConnections() {}
};

class IManageStreamSocketConnectionFilters
{
   public :
  
      /// Generate a read completion that uses the socket's sequence counter
      /// and pass it to the supplied filter.
  
      virtual void ReadCompleted(
         IStreamSocketEx &socket,
         JetByteTools::IO::IBuffer *pBuffer,
         IFilterStreamSocketConnections &nextFilter) = 0;
  
      /// Generate a read completion that uses the specified sequence counter
      /// and pass it to the supplied filter.
  
      virtual void ReadCompleted(
         const size_t sequenceId,
         IStreamSocketEx &socket,
         JetByteTools::IO::IBuffer *pBuffer,
         IFilterStreamSocketConnections &nextFilter) = 0;
  
      /// Generate a write request that uses the socket's sequence counter
      /// and pass it to the supplied filter.
  
      virtual void RequestWrite(
         IStreamSocketEx &socket,
         JetByteTools::IO::IBuffer &buffer,
         IFilterStreamSocketConnections &nextFilter) = 0;
  
      /// Generate a write request that uses the specified sequence counter
      /// and pass it to the supplied filter.
  
      virtual void RequestWrite(
         const size_t sequenceId,
         IStreamSocketEx &socket,
         JetByteTools::IO::IBuffer &buffer,
         IFilterStreamSocketConnections &nextFilter) = 0;
  
   protected :
  
      /// We never delete instances of this interface; you must manage the 
      /// lifetime of the class that implements it.
  
      ~IManageStreamSocketConnectionFilters() {}
};