llservice.h

Go to the documentation of this file.

#ifndef LL_LLSERVICE_H
#define LL_LLSERVICE_H

#include <string>
#include <map>
//#include <boost/intrusive_ptr.hpp>
//#include <boost/shared_ptr.hpp>

//#include "llframetimer.h"
#include "lliopipe.h"
#include "llchainio.h"

#if 0
class LLServiceCreator;
namespace boost
{
        void intrusive_ptr_add_ref(LLServiceCreator* p);
        void intrusive_ptr_release(LLServiceCreator* p);
};
#endif

#if 0
class LLServiceCreator
{
public:
        typedef boost::intrusive_ptr<LLService> service_t;
        virtual ~LLServiceCreator() {}
        virtual service_t activate() = 0;
        virtual void discard() = 0;

protected:
        LLServiceCreator() : mReferenceCount(0)
        {
        }

private:
        friend void boost::intrusive_ptr_add_ref(LLServiceCreator* p);
        friend void boost::intrusive_ptr_release(LLServiceCreator* p);
        U32 mReferenceCount;
};
#endif

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

class LLService : public LLIOPipe
{
public:
        //typedef boost::intrusive_ptr<LLServiceCreator> creator_t;
        //typedef boost::intrusive_ptr<LLService> service_t;
        typedef boost::shared_ptr<LLChainIOFactory> creator_t;

        static bool registerCreator(const std::string& name, creator_t fn);

        static LLIOPipe* activate(
                const std::string& name,
                LLPumpIO::chain_t& chain,
                LLSD context);

        static bool discard(const std::string& name);

protected:
        // The creation factory static data.
        typedef std::map<std::string, creator_t> creators_t;
        static creators_t sCreatorFunctors;

protected:
        // construction & destruction. since this class is an abstract
        // base class, it is up to Service implementations to actually
        // deal with construction and not a public method. How that
        // construction takes place will be handled by the service
        // creators.
        LLService();
        virtual ~LLService();

protected:
        // This frame timer records how long this service has
        // existed. Useful for derived services to give themselves a
        // lifetime and expiration.
        // *NOTE: Phoenix - This functionaity has been moved to the
        // pump. 2005-12-13
        //LLFrameTimer mTimer;

        // Since services are designed in an 'ask now, respond later'
        // idiom which probably crosses thread boundaries, almost all
        // services will need a handle to a response pipe. It will usually
        // be the job of the service author to derive a useful
        // implementation of response, and up to the service subscriber to
        // further derive that class to do something useful when the
        // response comes in.
        LLIOPipe::ptr_t mResponse;
};


#endif // LL_LLSERVICE_H

---