ServletMap.h

Go to the documentation of this file.

/***************************************************************************
 *   Copyright (C) 2006 by Ilya A. Volynets-Evenbakh                       *
 *   ilya@total-knowledge.com                                              *
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 *   This program is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
 *   GNU General Public License for more details.                          *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this program; if not, write to the                         *
 *   Free Software Foundation, Inc.,                                       *
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
 ***************************************************************************/
#ifndef _SERVLET_MAP_H_
#define _SERVLET_MAP_H_

#include <map>
#include <string>
#include <algorithm>

namespace container
{

template<class T>
 class ServletMap
{
public:
    typedef std::map<std::string,ServletMap<T>*> subpaths_t;
    typedef std::map<std::string,T*> servletmap_t;
private:
    servletmap_t m_servlets;
    subpaths_t m_subpaths;
    template<class F>
     class Func: public std::unary_function<const std::string&, void>
    {
    private:
        std::string m_base;
        F& m_f;
    public:
        Func(const std::string& base, F& f)
            : m_base(base+'/')
            , m_f(f)
        {}
        void operator ()(const std::pair<std::string,T*>& it)
        {
            m_f(m_base + it.first);
        }
    };
    template<class F>
     class Func2: public std::unary_function<std::pair<std::string, ServletMap*>, void>
    {
    private:
        std::string m_base;
        F& m_f;
    public:
        Func2(const std::string& base, F& f)
            : m_base(base+'/')
            , m_f(f)
        {}
        void operator ()(std::pair<std::string, ServletMap*> it)
        {
            it.second->forEachServletPath(m_f, m_base + it.first);
        }
    };
    class Killer: public std::unary_function<std::pair<std::string, ServletMap<T>*>, void>
    {
    public:
        void operator()(std::pair<std::string, ServletMap<T>*> hit){ delete hit.second; }
    };
public:
    ~ServletMap();
    ServletMap* getPath(std::string path, bool create);
    T* getServletDesc(std::string path);
    void removeDesc(const std::string& path);
    static void splitServPath(const std::string& path, std::string& dir, std::string& name);
    const servletmap_t& getServlets() const { return m_servlets; }
    const subpaths_t& getSubpaths() const { return m_subpaths; }
    template<class F>
     void forEachServletPath(F& func, std::string curpath)
    {
        std::for_each(m_servlets.begin(), m_servlets.end(), Func<F>(curpath, func));
        std::for_each(m_subpaths.begin(), m_subpaths.end(), Func2<F>(curpath, func));
    }
    T*& operator[](const std::string& path)
    {
        std::string dir, name;
        splitServPath(path, dir, name);
        ServletMap<T>* sm = getPath(dir, true);
        if(sm->m_servlets.find(name) == sm->m_servlets.end())
            sm->m_servlets[name] = 0;
        return sm->m_servlets[name];
    }
};

template<class T>
 void ServletMap<T>::splitServPath(const std::string& path, std::string& dir, std::string& name)
{
    std::string::size_type slash = path.rfind('/');
    if(slash == std::string::npos) {
        dir = "/";
        name = path;
    } else {
        dir.assign(path.substr(0, slash));
        name.assign(path.substr(slash + 1));
    }
}

template<class T>
ServletMap<T>* ServletMap<T>::getPath(std::string path, bool create)
{
    if(path[0] == '/')
        path.erase(0,1);
    if(path.empty())
        return this;
    std::string::size_type slash = path.find('/');
    std::string dir;
    std::string rest;
    if(slash == std::string::npos) {
        dir.assign(path);
    } else {
        dir.assign(path.substr(0, slash));
        rest.assign(path.substr(slash+1));
    }
    ServletMap* sp;
    if(m_subpaths.find(dir) == m_subpaths.end()) {
        if(!create) {
            return 0;
        } else {
            sp = new ServletMap<T>;
            m_subpaths[dir] = sp;
        }
    } else {
        sp = m_subpaths[dir];
    }
    return sp->getPath(rest, create);
}

template<class T>
 ServletMap<T>::~ServletMap()
{
    std::for_each(m_subpaths.begin(), m_subpaths.end(), Killer());
}

template<class T>
T* ServletMap<T>::getServletDesc(std::string path)
{
    if(path[0] == '/')
        path.erase(0,1);
    std::string::size_type slash;
    slash = path.find('/');
    std::string name;
    if(slash == std::string::npos)
        name = path;
    else
        name = path.substr(0, slash);
    if(m_servlets.find(name) != m_servlets.end())
        return m_servlets[name];
    if(m_subpaths.find(name) == m_subpaths.end())
        return 0;
    return m_subpaths[name]->getServletDesc(path.substr(slash + 1));
}

template<class T>
 void ServletMap<T>::removeDesc(const std::string& path)
{
    std::string dir, name;
    splitServPath(path, dir, name);
    ServletMap<T>* sm = getPath(dir, false);
    if(sm)
        sm->m_servlets.erase(name);
}

}
#endif /* _SERVLET_MAP_H_ */