fd_data_map.hh

Go to the documentation of this file.

/*
 * Copyright (c) 2016 Zhao DAI <daidodo@gmail.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 3 of the License, or 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, see accompanying file LICENSE.txt
 * or <http://www.gnu.org/licenses/>.
 */

#ifndef DOZERG_FD_DATA_MAP_H_20130228
#define DOZERG_FD_DATA_MAP_H_20130228

#include <vector>
#include <cassert>
#include "mutex.hh"
#include "shared_ptr.hh"

NS_SERVER_BEGIN

template<class T, class Container = std::vector<T> >
struct CFdMap
{
    typedef Container   container_type;
    typedef T           value_type;
    typedef T &         reference;
    typedef const T &   const_reference;
    explicit CFdMap(size_t capacity = 100){map_.reserve(capacity);}
    size_t capacity() const{return map_.capacity();}
    void capacity(size_t sz){map_.reserve(sz);}
    reference operator [](int fd){
        assert(fd >= 0);
        if(size_t(fd) >= map_.size())
            map_.resize(fd + 1);
        return map_[fd];
    }
    const_reference operator [](int fd) const{
        //use value_type() to fix compile error for POD
        static const value_type kDef = value_type();
        if(fd >= 0 && size_t(fd) < map_.size())
            return map_[fd];
        return kDef;
    }
    void clear(){map_.clear();}
private:
    container_type map_;
};

template<class T, class LockT = CSpinLock>
class CFdDataMap
{
public:
    typedef T                       value_type;
    typedef CSharedPtr<value_type>  pointer;
private:
    typedef CFdMap<pointer>     __Map;
    typedef LockT               lock_type;
    typedef CGuard<lock_type>   guard_type;
public:
    explicit CFdDataMap(size_t capacity = 100)
        : map_(capacity)
        , sz_(0)
    {}
    size_t size() const{return sz_;}
    size_t capacity() const{
        guard_type g(lock_);
        return map_.capacity();
    }
    void capacity(size_t c){
        guard_type g(lock_);
        map_.capacity(c);
    }
    void setData(int fd, const pointer & data, pointer * old = NULL){
        if(fd < 0)
            return;
        guard_type g(lock_);
        setAux(fd, data, old);
    }
    pointer getData(int fd) const{
        if(fd < 0)
            return pointer();
        guard_type g(lock_);
        return map_[fd];
    }
    void getData(int fd, pointer * data) const{
        if(NULL == data || fd < 0)
            return;
        guard_type g(lock_);
        *data = map_[fd];
    }
    template<class ForwardIter, class OutputIter>
    void getData(ForwardIter first, ForwardIter last, OutputIter dstFirst) const{
        guard_type g(lock_);
        for(int fd = -1;first != last;++first, ++dstFirst){
            fd = *first;
            if(fd >= 0)
                *dstFirst = map_[fd];
        }
    }
    void clearData(int fd, pointer * old = NULL){
        if(fd < 0)
            return;
        guard_type g(lock_);
        setAux(fd, pointer(), old);
    }
    template<class ForwardIter>
    void clearData(ForwardIter first, ForwardIter last){
        guard_type g(lock_);
        for(int fd = -1;first != last;++first){
            fd = *first;
            if(fd >= 0)
                setAux(fd, pointer(), NULL);
        }
    }
    template<class ForwardIter, class OutputIter>
    void clearData(ForwardIter first, ForwardIter last, OutputIter dstFirst){
        guard_type g(lock_);
        for(int fd = -1;first != last;++first, ++dstFirst){
            fd = *first;
            if(fd >= 0)
                setAux(fd, pointer(), &*dstFirst);
        }
    }
    void clear(){
        guard_type g(lock_);
        map_.clear();
        sz_ = 0;
    }
private:
    //set *old = map_[fd], then set map_[fd] = data
    //Note: old and &data may be equal
    void setAux(int fd, const pointer & data, pointer * old){
        assert(fd >= 0);
        if(fd < int(map_.capacity())){
            pointer & cur = map_[fd];
            sz_ += (data ? 1 : 0) - (cur ? 1 : 0);
            if(NULL != old)
                old->swap(cur);
            if(&data != old)
                cur = data;
        }else{
            if(data){
                map_[fd] = data;
                ++sz_;
            }
            if(NULL != old)
                old->reset();
        }
    }
    //fields:
    __Map map_;
    lock_type lock_;
    volatile size_t sz_;
};

NS_SERVER_END

#endif