parking_lots.h

Go to the documentation of this file.

// Copyright (C) 2018 Internet Systems Consortium, Inc. ("ISC")
//
// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at http://mozilla.org/MPL/2.0/.
 
#ifndef PARKING_LOTS_H
#define PARKING_LOTS_H
 
#include <exceptions/exceptions.h>
#include <boost/any.hpp>
#include <boost/make_shared.hpp>
#include <boost/shared_ptr.hpp>
#include <functional>
#include <list>
#include <map>
 
#include <iostream>
 
namespace isc {
namespace hooks {
 
class ParkingLot {
public:
 
    template<typename T>
    void park(T parked_object, std::function<void()> unpark_callback) {
        auto it = find(parked_object);
        if (it == parking_.end() || it->refcount_ <= 0) {
            isc_throw(InvalidOperation, "unable to park an object because"
                      " reference count for this object hasn't been increased."
                      " Call ParkingLot::reference() first");
        } else {
            it->update(parked_object, unpark_callback);
        }
    }
 
    template<typename T>
    void reference(T parked_object) {
        auto it = find(parked_object);
        if (it == parking_.end()) {
            ParkingInfo parking_info(parked_object);
            parking_.push_back(parking_info);
 
        } else {
            ++it->refcount_;
        }
    }
 
    template<typename T>
    bool unpark(T parked_object, bool force = false) {
        auto it = find(parked_object);
        if (it != parking_.end()) {
            if (force) {
                it->refcount_ = 0;
 
            } else {
                --it->refcount_;
            }
 
            if (it->refcount_ <= 0) {
                // Unpark the packet and invoke the callback.
                std::function<void()> cb = it->unpark_callback_;
                parking_.erase(it);
                cb();
            }
 
            // Parked object found, so return true to indicate that the
            // operation was successful. It doesn't necessarily mean
            // that the object was unparked, but at least the reference
            // count was decreased.
            return (true);
        }
 
        // No such parked object.
        return (false);
    }
 
    template<typename T>
    bool drop(T parked_object) {
        auto it = find(parked_object);
        if (it != parking_.end()) {
            // Parked object found.
            parking_.erase(it);
            return (true);
        }
 
        // No such object.
        return (false);
    }
 
private:
 
    struct ParkingInfo {
        boost::any parked_object_;               
        std::function<void()> unpark_callback_;  
        int refcount_;                           
 
        ParkingInfo(const boost::any& parked_object,
                    std::function<void()> callback = 0)
            : parked_object_(parked_object), unpark_callback_(callback),
              refcount_(1) {
        }
 
        void update(const boost::any& parked_object,
                    std::function<void()> callback) {
            parked_object_ = parked_object;
            unpark_callback_ = callback;
        }
    };
 
    typedef std::list<ParkingInfo> ParkingInfoList;
    typedef ParkingInfoList::iterator ParkingInfoListIterator;
 
    ParkingInfoList parking_;
 
    template<typename T>
    ParkingInfoListIterator find(T parked_object) {
        for (auto it = parking_.begin(); it != parking_.end(); ++it) {
            if (boost::any_cast<T>(it->parked_object_) == parked_object) {
                return (it);
            }
        }
        return (parking_.end());
    }
};
 
typedef boost::shared_ptr<ParkingLot> ParkingLotPtr;
 
class ParkingLotHandle {
public:
 
    ParkingLotHandle(const ParkingLotPtr& parking_lot)
        : parking_lot_(parking_lot) {
    }
 
    template<typename T>
    void reference(T parked_object) {
        parking_lot_->reference(parked_object);
    }
 
    template<typename T>
    bool unpark(T parked_object) {
        return (parking_lot_->unpark(parked_object));
    }
 
    template<typename T>
    bool drop(T parked_object) {
        return (parking_lot_->drop(parked_object));
    }
 
private:
 
    ParkingLotPtr parking_lot_;
 
};
 
typedef boost::shared_ptr<ParkingLotHandle> ParkingLotHandlePtr;
 
class ParkingLots {
public:
 
    void clear() {
        parking_lots_.clear();
    }
 
    ParkingLotPtr getParkingLotPtr(const int hook_index) {
        if (parking_lots_.count(hook_index) == 0) {
            parking_lots_[hook_index] = boost::make_shared<ParkingLot>();
        }
        return (parking_lots_[hook_index]);
    }
 
private:
 
    std::map<int, ParkingLotPtr> parking_lots_;
 
};
 
typedef boost::shared_ptr<ParkingLots> ParkingLotsPtr;
 
} // end of namespace hooks
} // end of namespace isc
 
#endif