/Users/giersc_v/projets/zia/api/include/bref/Pipeline.h

Go to the documentation of this file.

#ifndef BREF_API_PIPELINE_H
#define BREF_API_PIPELINE_H

#include "Function.hpp"
#include "IConfHelper.h"
#include "BrefValue.h"
#include "ILogger.h"
#include "HttpRequest.h"
#include "HttpResponse.h"
#include "IpAddress.h"
#include "Buffer.h"
#include "IDisposable.h"

#include <list>
#include <vector>
#include <utility>
#if defined(_WIN32) || defined(__WIN32__) || defined(WIN32)
# include <windows.h>
#endif

namespace bref {
typedef BrefValue ServerConfig;

#if defined(_WIN32) || defined(__WIN32__) || defined(WIN32)
  typedef HANDLE FdType;
#else
  typedef int FdType;
#endif

struct Environment
{
  const ServerConfig &  serverConfig; 
  const IConfHelper &   serverConfigHelper; 
  ILogger              *logger;       
  struct Client
  {
    IpAddress  Ip;
    short      Port;
    SocketType Socket;
  }                     client; 
  Environment(const ServerConfig &  theServerConfig,
              const IConfHelper &   theServerConfigHelper,
              ILogger              *theLogger,
              Client                theClient)
    : serverConfig(theServerConfig)
    , serverConfigHelper(theServerConfigHelper)
    , logger(theLogger)
    , client(theClient)
  { }
};

struct Pipeline
{
  typedef Function<bool (HttpResponse & response,
                         const Environment & environment)> ConnectionRequestHandler;

  typedef Function<ConnectionRequestHandler (const Environment & environment)> ConnectionHook;

  std::list<std::pair<ConnectionHook, float> > connectionHooks;

  typedef Function<bool (SocketType socket,
                         Buffer &   buffer)> OnReceiveRequestHandler;

  typedef Function<OnReceiveRequestHandler (const Environment & environment)> OnReceiveHook;

  std::list<std::pair<OnReceiveHook, float> > onReceiveHooks;

  typedef Function<bool (SocketType     socket,
                         const Buffer & buffer)> OnSendRequestHandler;

  typedef Function<OnSendRequestHandler (const Environment & environment)> OnSendHook;

  std::list<std::pair<OnSendHook, float> > onSendHooks;

  typedef Function<void (HttpResponse & response,
                         const Buffer & inBuffer,
                         Buffer &       outBuffer)> PostReceiveRequestHandler;

  typedef Function<PostReceiveRequestHandler (const Environment & environment)> PostReceiveHook;

  std::list<std::pair<PostReceiveHook, float> > postReceiveHooks;

  typedef Function<Buffer::const_iterator (HttpResponse & response,
                                           const Buffer & buff,
                                           HttpRequest &  request)> ParsingRequestHandler;

  typedef Function<ParsingRequestHandler (Environment &)> ParsingHook;

  std::list<std::pair<ParsingHook, float> > parsingHooks;

  typedef Function<void (HttpResponse & response)> PostParsingRequestHandler;

  typedef Function<PostParsingRequestHandler (const Environment & environment,
                                              HttpRequest &       httpRequest,
                                              HttpResponse &      response)> PostParsingHook;

  std::list<std::pair<PostParsingHook, float> > postParsingHooks;

  class IContentRequestHandler : public IDisposable
  {
  public:
    virtual bool inContent(HttpResponse & response, const Buffer & inBuffer) = 0;

    virtual bool outContent(HttpResponse & response, Buffer & outBuffer) = 0;

  protected:
    virtual ~IContentRequestHandler() {}
  };

  typedef Function<IContentRequestHandler *(const Environment & environment,
                                            const HttpRequest & request,
                                            HttpResponse &      response,
                                            FdType &            fd)> ContentHook;


  std::list<std::pair<ContentHook, float> > contentHooks;

  typedef Function<void (HttpResponse & reponse,
                         const Buffer & inBuffer,
                         Buffer &       outBuffer)> PostContentRequestHandler;

  typedef Function<PostContentRequestHandler (const Environment & environment,
                                              const HttpRequest & request,
                                              HttpResponse &      response)> PostContentHook;

  std::list<std::pair<PostContentHook, float> > postContentHooks;


  typedef Function<void (HttpResponse & response,
                         const Buffer & inBuffer,
                         Buffer &       outBuffer)> TransformRequestHandler;

  typedef Function<TransformRequestHandler (const Environment & environment,
                                            const HttpRequest & request,
                                            HttpResponse &      response)> TransformHook;

  std::list<std::pair<TransformHook, float> > transformHooks;

  typedef Function<void (HttpResponse & response,
                         const Buffer & inBuffer,
                         Buffer &       outBuffer)> PreSendRequestHandler;

  typedef Function<PreSendRequestHandler (const Environment & environment,
                                          const HttpRequest & request,
                                          HttpResponse &      response)> PreSendHook;

  std::list<std::pair<PreSendHook, float> > preSendHooks;

};

} // ! bref

#endif /* !BREF_API_PIPELINE_H */