anchor.diff:          Serializer.Serialize(stream, message)
           stream.ToArray()
       
  -    /// Helper method to deserialize cluster messages
  +    /// Helper method to De-serialize cluster messages
       let ProtoDeserialize<'T>(message : byte []) = 
           use stream = new MemoryStream(message)
           Serializer.Deserialize<'T>(stream)
  +    
  +    /// <summary>
  +    /// Formatter interface for supporting multiple formats in the HTTP engine
  +    /// </summary>
  +    type IFormatter = 
  +        abstract SupportedHeaders : unit -> string []
  +        abstract Serialize : body:obj * stream:Stream -> unit
  +        abstract DeSerialize<'T> : stream:Stream -> 'T
  +    
  +    [<Sealed>]
  +    type JilJsonFormatter() = 
  +        let options = new Jil.Options(false, false, true, Jil.DateTimeFormat.ISO8601, false)
  +        interface IFormatter with
  +            
  +            member x.DeSerialize<'T>(stream : Stream) = 
  +                use reader = new StreamReader(stream) :> TextReader
  +                Jil.JSON.Deserialize<'T>(reader, options)
  +            
  +            member x.Serialize(body : obj, stream : Stream) : unit = 
  +                use writer = new StreamWriter(stream)
  +                Jil.JSON.Serialize(body, writer, options)
  +                writer.Flush()
  +            
  +            member x.SupportedHeaders() : string [] = 
  +                [| "application/json"; "text/json"; "application/json;charset=utf-8"; "application/json; charset=utf-8" |]
  +    
  +    [<Sealed>]
  +    type ProtoBufferFormatter() = 
  +        interface IFormatter with
  +            member x.DeSerialize<'T>(stream : Stream) = ProtoBuf.Serializer.Deserialize<'T>(stream)
  +            member x.Serialize(body : obj, stream : Stream) : unit = ProtoBuf.Serializer.Serialize(stream, body)
  +            member x.SupportedHeaders() : string [] = [| "application/x-protobuf"; "application/octet-stream" |]
  +    
  +    let private Formatters = new ConcurrentDictionary<string, IFormatter>(StringComparer.OrdinalIgnoreCase)
  +    let protoFormatter = new ProtoBufferFormatter() :> IFormatter
  +    let jsonFormatter = new JilJsonFormatter() :> IFormatter
  +    
  +    protoFormatter.SupportedHeaders() |> Array.iter (fun x -> Formatters.TryAdd(x, protoFormatter) |> ignore)
  +    jsonFormatter.SupportedHeaders() |> Array.iter (fun x -> Formatters.TryAdd(x, jsonFormatter) |> ignore)
       
       /// Get request format from the request object
       /// Defaults to json
  
positive.code:         if String.IsNullOrWhiteSpace(request.ContentType) then "application/json"
          else request.ContentType
      
      /// Get response format from the owin context
      /// Defaults to json
      let private GetResponseFormat(owin : IOwinContext) = 
          if owin.Request.Accept = null then "application/json"
  
negative.code:             | _ -> Choice2Of2(Errors.HTTP_UNSUPPORTED_CONTENT_TYPE |> GenerateOperationMessage)
          else Choice2Of2(Errors.HTTP_NO_BODY_DEFINED |> GenerateOperationMessage)
      
      let Created = HttpStatusCode.Created
      let Accepted = HttpStatusCode.Accepted
      let Ok = HttpStatusCode.OK
      let NotFound = HttpStatusCode.NotFound
      let BadRequest = HttpStatusCode.BadRequest
      let Conflict = HttpStatusCode.Conflict
      let CREATED (value : obj) (owin : IOwinContext) = WriteResponse HttpStatusCode.Created value owin
      let ACCEPTED (value : obj) (owin : IOwinContext) = WriteResponse HttpStatusCode.Accepted value owin
      let OK (value : obj) (owin : IOwinContext) = WriteResponse HttpStatusCode.OK value owin
  