EIC code displayed by LXR master/​include/​thrift/​TProcessor.h	Source navigation Diff markup Identifier search General search
	Version: master test Revert   Change

File indexing completed on 2026-04-17 08:35:04

 /*
  * Licensed to the Apache Software Foundation (ASF) under one
  * or more contributor license agreements. See the NOTICE file
  * distributed with this work for additional information
  * regarding copyright ownership. The ASF licenses this file
  * to you under the Apache License, Version 2.0 (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.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing,
  * software distributed under the License is distributed on an
  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  * KIND, either express or implied. See the License for the
  * specific language governing permissions and limitations
  * under the License.
  */
 
 #ifndef _THRIFT_TPROCESSOR_H_
 #define _THRIFT_TPROCESSOR_H_ 1
 
 #include <string>
 #include <thrift/protocol/TProtocol.h>
 
 namespace apache {
 namespace thrift {
 
 /**
  * Virtual interface class that can handle events from the processor. To
  * use this you should subclass it and implement the methods that you care
  * about. Your subclass can also store local data that you may care about,
  * such as additional "arguments" to these methods (stored in the object
  * instance's state).
  */
 class TProcessorEventHandler {
 public:
   virtual ~TProcessorEventHandler() = default;
 
   /**
    * Called before calling other callback methods.
    * Expected to return some sort of context object.
    * The return value is passed to all other callbacks
    * for that function invocation.
    */
   virtual void* getContext(const char* fn_name, void* serverContext) {
     (void)fn_name;
     (void)serverContext;
     return nullptr;
   }
 
   /**
    * Expected to free resources associated with a context.
    */
   virtual void freeContext(void* ctx, const char* fn_name) {
     (void)ctx;
     (void)fn_name;
   }
 
   /**
    * Called before reading arguments.
    */
   virtual void preRead(void* ctx, const char* fn_name) {
     (void)ctx;
     (void)fn_name;
   }
 
   /**
    * Called between reading arguments and calling the handler.
    */
   virtual void postRead(void* ctx, const char* fn_name, uint32_t bytes) {
     (void)ctx;
     (void)fn_name;
     (void)bytes;
   }
 
   /**
    * Called between calling the handler and writing the response.
    */
   virtual void preWrite(void* ctx, const char* fn_name) {
     (void)ctx;
     (void)fn_name;
   }
 
   /**
    * Called after writing the response.
    */
   virtual void postWrite(void* ctx, const char* fn_name, uint32_t bytes) {
     (void)ctx;
     (void)fn_name;
     (void)bytes;
   }
 
   /**
    * Called when an async function call completes successfully.
    */
   virtual void asyncComplete(void* ctx, const char* fn_name) {
     (void)ctx;
     (void)fn_name;
   }
 
   /**
    * Called if the handler throws an undeclared exception.
    */
   virtual void handlerError(void* ctx, const char* fn_name) {
     (void)ctx;
     (void)fn_name;
   }
 
 protected:
   TProcessorEventHandler() = default;
 };
 
 /**
  * A helper class used by the generated code to free each context.
  */
 class TProcessorContextFreer {
 public:
   TProcessorContextFreer(TProcessorEventHandler* handler, void* context, const char* method)
     : handler_(handler), context_(context), method_(method) {}
   ~TProcessorContextFreer() {
     if (handler_ != nullptr)
       handler_->freeContext(context_, method_);
   }
   void unregister() { handler_ = nullptr; }
 
 private:
   apache::thrift::TProcessorEventHandler* handler_;
   void* context_;
   const char* method_;
 };
 
 /**
  * A processor is a generic object that acts upon two streams of data, one
  * an input and the other an output. The definition of this object is loose,
  * though the typical case is for some sort of server that either generates
  * responses to an input stream or forwards data from one pipe onto another.
  *
  */
 class TProcessor {
 public:
   virtual ~TProcessor() = default;
 
   virtual bool process(std::shared_ptr<protocol::TProtocol> in,
                        std::shared_ptr<protocol::TProtocol> out,
                        void* connectionContext) = 0;
 
   bool process(std::shared_ptr<apache::thrift::protocol::TProtocol> io, void* connectionContext) {
     return process(io, io, connectionContext);
   }
 
   std::shared_ptr<TProcessorEventHandler> getEventHandler() const { return eventHandler_; }
 
   void setEventHandler(std::shared_ptr<TProcessorEventHandler> eventHandler) {
     eventHandler_ = eventHandler;
   }
 
 protected:
   TProcessor() = default;
 
   std::shared_ptr<TProcessorEventHandler> eventHandler_;
 };
 
 /**
  * This is a helper class to allow std::shared_ptr to be used with handler
  * pointers returned by the generated handler factories.
  *
  * The handler factory classes generated by the thrift compiler return raw
  * pointers, and factory->releaseHandler() must be called when the handler is
  * no longer needed.
  *
  * A ReleaseHandler object can be instantiated and passed as the second
  * parameter to a shared_ptr, so that factory->releaseHandler() will be called
  * when the object is no longer needed, instead of deleting the pointer.
  */
 template <typename HandlerFactory_>
 class ReleaseHandler {
 public:
   ReleaseHandler(const std::shared_ptr<HandlerFactory_>& handlerFactory)
     : handlerFactory_(handlerFactory) {}
 
   void operator()(typename HandlerFactory_::Handler* handler) {
     if (handler) {
       handlerFactory_->releaseHandler(handler);
     }
   }
 
 private:
   std::shared_ptr<HandlerFactory_> handlerFactory_;
 };
 
 struct TConnectionInfo {
   // The input and output protocols
   std::shared_ptr<protocol::TProtocol> input;
   std::shared_ptr<protocol::TProtocol> output;
   // The underlying transport used for the connection
   // This is the transport that was returned by TServerTransport::accept(),
   // and it may be different than the transport pointed to by the input and
   // output protocols.
   std::shared_ptr<transport::TTransport> transport;
 };
 
 class TProcessorFactory {
 public:
   virtual ~TProcessorFactory() = default;
 
   /**
    * Get the TProcessor to use for a particular connection.
    *
    * This method is always invoked in the same thread that the connection was
    * accepted on.  This generally means that this call does not need to be
    * thread safe, as it will always be invoked from a single thread.
    */
   virtual std::shared_ptr<TProcessor> getProcessor(const TConnectionInfo& connInfo) = 0;
 };
 
 class TSingletonProcessorFactory : public TProcessorFactory {
 public:
   TSingletonProcessorFactory(std::shared_ptr<TProcessor> processor) : processor_(processor) {}
 
   std::shared_ptr<TProcessor> getProcessor(const TConnectionInfo&) override { return processor_; }
 
 private:
   std::shared_ptr<TProcessor> processor_;
 };
 }
 } // apache::thrift
 
 #endif // #ifndef _THRIFT_TPROCESSOR_H_

This page was automatically generated by the 2.3.7 LXR engine. The LXR team