lliopipe.h

Go to the documentation of this file.

#ifndef LL_LLIOPIPE_H
#define LL_LLIOPIPE_H

#include <boost/intrusive_ptr.hpp>
#include <boost/shared_ptr.hpp>
#include "apr-1/apr_poll.h"

#include "llsd.h"

class LLIOPipe;
class LLPumpIO;
class LLBufferArray;
class LLChannelDescriptors;

// Debugging schmutz for deadlocks
#define LL_DEBUG_PUMPS
#ifdef LL_DEBUG_PUMPS
void pump_debug(const char *file, S32 line);
#define PUMP_DEBUG pump_debug(__FILE__, __LINE__);
#define END_PUMP_DEBUG pump_debug("none", 0);
#endif


namespace boost
{
        void intrusive_ptr_add_ref(LLIOPipe* p);
        void intrusive_ptr_release(LLIOPipe* p);
};

class LLIOPipe
{
public:
        typedef boost::intrusive_ptr<LLIOPipe> ptr_t;

        typedef boost::shared_ptr<LLBufferArray> buffer_ptr_t;

        enum EStatus
        {
                // Processing occurred normally, future calls will be accepted.
                STATUS_OK = 0,

                // Processing occured normally, but stop unsolicited calls to
                // process.
                STATUS_STOP = 1,

                // This pipe is done with the processing. Future calls to
                // process will be accepted as long as new data is available.
                STATUS_DONE = 2,

                // This pipe is requesting that it become the head in a process.
                STATUS_BREAK = 3,

                // This pipe is requesting that it become the head in a process.
                STATUS_NEED_PROCESS = 4,

                // Keep track of the highest number of success codes here.
                STATUS_SUCCESS_COUNT = 5,

                // A generic error code.
                STATUS_ERROR = -1,

                // This method has not yet been implemented. This usually
                // indicates the programmer working on the pipe is not yet
                // done.
                STATUS_NOT_IMPLEMENTED = -2,

                // This indicates that a pipe precondition was not met. For
                // example, many pipes require an element to appear after them
                // in a chain (ie, mNext is not null) and will return this in
                // response to method calls. To recover from this, it will
                // require the caller to adjust the pipe state or may require
                // a dev to adjust the code to satisfy the preconditions.
                STATUS_PRECONDITION_NOT_MET = -3,

                // This means we could not connect to a remote host.
                STATUS_NO_CONNECTION = -4,

                // This means we could not connect to a remote host.
                STATUS_EXPIRED = -5,

                // Keep track of the count of codes here.
                STATUS_ERROR_COUNT = 5,
        };

        inline static bool isError(EStatus status)
        {
                return ((S32)status < 0);
        }

        inline static bool isSuccess(EStatus status)
        {
                return ((S32)status >= 0);
        }

        static std::string lookupStatusString(EStatus status);

        EStatus process(
                const LLChannelDescriptors& channels,
                buffer_ptr_t& buffer,
                bool& eos,
                LLSD& context,
                LLPumpIO* pump);

        virtual EStatus handleError(EStatus status, LLPumpIO* pump);

        virtual ~LLIOPipe();

protected:
        LLIOPipe();

        virtual EStatus process_impl(
                const LLChannelDescriptors& channels,
                buffer_ptr_t& buffer,
                bool& eos,
                LLSD& context,
                LLPumpIO* pump) = 0;

private:
        friend void boost::intrusive_ptr_add_ref(LLIOPipe* p);
        friend void boost::intrusive_ptr_release(LLIOPipe* p);
        U32 mReferenceCount;
};

namespace boost
{
        inline void intrusive_ptr_add_ref(LLIOPipe* p)
        {
                ++p->mReferenceCount;
        }
        inline void intrusive_ptr_release(LLIOPipe* p)
        {
                if(p && 0 == --p->mReferenceCount)
                {
                        delete p;
                }
        }
};


#if 0

class LLIOBoiler : public LLIOPipe
{
public:
        LLIOBoiler();
        virtual ~LLIOBoiler();

protected:
        /* @name LLIOPipe virtual implementations
         */

        virtual EStatus process_impl(
                const LLChannelDescriptors& channels,
                buffer_ptr_t& buffer,
                bool& eos,
                LLSD& context,
                LLPumpIO* pump);
};

// virtual
LLIOPipe::EStatus process_impl(
        const LLChannelDescriptors& channels,
        buffer_ptr_t& buffer,
        bool& eos,
        LLSD& context,
        LLPumpIO* pump)
{
        return STATUS_NOT_IMPLEMENTED;
}

#endif // #if 0 - use this block as a boilerplate

#endif // LL_LLIOPIPE_H

---