llhttpnode.h

Go to the documentation of this file.

#ifndef LL_LLHTTPNODE_H
#define LL_LLHTTPNODE_H

#include "llmemory.h"
#include "llsd.h"

class LLChainIOFactory;


class LLHTTPNode
{
public:
        LLHTTPNode();
        virtual ~LLHTTPNode();

public: 
                virtual LLSD get() const;
                virtual LLSD put(const LLSD& input) const;
                virtual LLSD post(const LLSD& input) const;

                virtual LLSD del() const;
                virtual LLSD del(const LLSD& context) const;

                class Response : public LLRefCount
                {
                protected:
                        virtual ~Response();

                public:
                        virtual void result(const LLSD&) = 0;
                        virtual void status(S32 code, const std::string& message) = 0;

                        void status(S32 code);
                        void notFound(const std::string& message);
                        void notFound();
                        void methodNotAllowed();
                };

                typedef LLPointer<Response> ResponsePtr;

                virtual void get(ResponsePtr, const LLSD& context) const;
                virtual void put(ResponsePtr, const LLSD& context, const LLSD& input) const;
                virtual void post(ResponsePtr, const LLSD& context, const LLSD& input) const;
                virtual void del(ResponsePtr, const LLSD& context) const;
        

public:
        virtual LLHTTPNode* getChild(const std::string& name, LLSD& context) const;
        virtual bool handles(const LLSD& remainder, LLSD& context) const;
        virtual bool validate(const std::string& name, LLSD& context) const;
        const LLHTTPNode* traverse(const std::string& path, LLSD& context) const;
 
        
        virtual void addNode(const std::string& path, LLHTTPNode* nodeToAdd);

        LLSD allNodePaths() const;

        const LLHTTPNode* rootNode() const;
        const LLHTTPNode* findNode(const std::string& name) const;


        /* @name Description system
                The Description object contains information about a service.
                All subclasses of LLHTTPNode should override description() and use
                the methods of the Description class to set the various properties.
         */
                class Description
                {
                public:
                        void shortInfo(const std::string& s){ mInfo["description"] = s; }
                        void longInfo(const std::string& s)     { mInfo["details"] = s; }

                        // Call this method when the service supports the specified verb.
                        void getAPI() { mInfo["api"].append("GET"); }
                        void putAPI() { mInfo["api"].append("PUT");  }
                        void postAPI() { mInfo["api"].append("POST"); }
                        void delAPI() { mInfo["api"].append("DELETE"); }

                        void input(const std::string& s)        { mInfo["input"] = s; }
                        void output(const std::string& s)       { mInfo["output"] = s; }
                        void source(const char* f, int l)       { mInfo["__file__"] = f;
                                                                                                  mInfo["__line__"] = l; }
                        
                        LLSD getInfo() const { return mInfo; }
                        
                private:
                        LLSD mInfo;
                };
        
        virtual void describe(Description&) const;
        
        
        
        virtual const LLChainIOFactory* getProtocolHandler() const;
private:
        class Impl;
        Impl& impl;
};



class LLSimpleResponse : public LLHTTPNode::Response
{
public:
        static LLPointer<LLSimpleResponse> create();
        
        void result(const LLSD& result);
        void status(S32 code, const std::string& message);

        void print(std::ostream& out) const;

        S32 mCode;
        std::string mMessage;

protected:
        ~LLSimpleResponse();

private:
        LLSimpleResponse() {;} // Must be accessed through LLPointer.
};

std::ostream& operator<<(std::ostream& out, const LLSimpleResponse& resp);




class LLHTTPRegistrar
{
public:
        class NodeFactory
        {
        public:
                virtual ~NodeFactory();
                virtual LLHTTPNode* build() const = 0;
        };

        static void buildAllServices(LLHTTPNode& root);

        static void registerFactory(const std::string& path, NodeFactory& factory);
};

template < class NodeType >
class LLHTTPRegistration
{
public:
        LLHTTPRegistration(const std::string& path)
        {
                LLHTTPRegistrar::registerFactory(path, mFactory);
        }

private:
        class ThisNodeFactory : public LLHTTPRegistrar::NodeFactory
        {
        public:
                virtual LLHTTPNode* build() const { return new NodeType; }
        };
        
        ThisNodeFactory mFactory;       
};

template < class NodeType>
class LLHTTPParamRegistration
{
public:
        LLHTTPParamRegistration(const std::string& path, LLSD params) :
                mFactory(params)
        {
                LLHTTPRegistrar::registerFactory(path, mFactory);
        }

private:
        class ThisNodeFactory : public LLHTTPRegistrar::NodeFactory
        {
        public:
                ThisNodeFactory(LLSD params) : mParams(params) {}
                virtual LLHTTPNode* build() const { return new NodeType(mParams); }
        private:
                LLSD mParams;
        };
        
        ThisNodeFactory mFactory;       
};
        

#endif // LL_LLHTTPNODE_H

---