ServletRequestWrapper.h

Go to the documentation of this file.

/*
* Copyright 2004 The Apache Software Foundation
*
* Licensed 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 _SERVLET_REQUEST_WRAPPER_H_
#define _SERVLET_REQUEST_WRAPPER_H_

#include <servlet/ServletRequest.h>
#include <servlet/IllegalArgumentException.h>

namespace servlet
{
class ServletRequestWrapper: virtual public ServletRequest {
private:
    ServletRequest* request;
public:
    ServletRequestWrapper(ServletRequest* request)
        : request(request)
    {}
    ServletRequest* getRequest() {
        return request;
    }
    const ServletRequest* getRequest() const {
        return request;
    }
    
    void setRequest(ServletRequest* request) {
        if (request == 0) {
            throw IllegalArgumentException("Request cannot be null");
        }
        this->request = request;
    }

    virtual boost::shared_ptr<void> getAttribute(const std::string& name) {
        return request->getAttribute(name);
    }
    
        virtual bool hasAttribute(const std::string& name) const {
        return request->hasAttribute(name);
    }

    virtual std::auto_ptr< std::vector<std::string> > getAttributeNames() const {
        return request->getAttributeNames();
    }    
    
    
    
    virtual std::string getCharacterEncoding() const {
        return request->getCharacterEncoding();
    }

    virtual void setCharacterEncoding(const std::string& enc) {
        request->setCharacterEncoding(enc);
    }

    virtual int getContentLength() const {
        return request->getContentLength();
    }

    virtual std::string getContentType() const {
        return request->getContentType();
    }

    virtual std::istream& getInputStream() {
        return request->getInputStream();
    }

    virtual std::string getParameter(const std::string& name) const {
        return request->getParameter(name);
    }
    
    virtual std::auto_ptr< std::multimap<std::string,std::string> > getParameterMap() const {
        return request->getParameterMap();
    }

    virtual std::auto_ptr< std::vector<std::string> > getParameterNames() const {
        return request->getParameterNames();
    }

    virtual std::auto_ptr< std::vector<std::string> > getParameterValues(const std::string& name) const {
        return request->getParameterValues(name);
    }

    virtual std::string getProtocol() const {
        return request->getProtocol();
    }

    virtual std::string getScheme() const {
        return request->getScheme();
    }

    virtual std::string getServerName() const {
        return request->getServerName();
    }

    virtual int getServerPort() const {
        return request->getServerPort();
    }

    virtual std::string getRemoteAddr() const {
        return request->getRemoteAddr();
    }

    virtual std::string getRemoteHost() const {
        return request->getRemoteHost();
    }

    virtual void setAttribute(const std::string& name, boost::shared_ptr<void> t) {
        request->setAttribute(name, t);
    }

    virtual void removeAttribute(const std::string& name) {
        request->removeAttribute(name);
    }

    virtual bool isSecure() const {
        return request->isSecure();
    }

    virtual RequestDispatcher* getRequestDispatcher(const std::string& path) {
        return request->getRequestDispatcher(path);
    }


    virtual int getRemotePort() const {
        return request->getRemotePort();
    }


    virtual std::string getLocalName() const {
        return request->getLocalName();
    }

    virtual std::string getLocalAddr() const {
        return request->getLocalAddr();
    }

    virtual int getLocalPort() const {
        return request->getLocalPort();
    }
};

}

#endif