parking_lots.h

Go to the documentation of this file.

// Copyright (C) 2018-2021 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 <iostream>
#include <sstream>
#include <list>
#include <unordered_map>
#include <mutex>
#include <thread>

namespace isc {
namespace hooks {

class ParkingLot {
public:
    template<typename T>
    void park(T parked_object, std::function<void()> unpark_callback) {
        std::lock_guard<std::mutex> lock(mutex_);
        auto it = find(parked_object);
        if (it != parking_.end()) {
            isc_throw(InvalidOperation, "object is already parked!");
        }

        // Add the object to the parking lot. At this point refcount = 0.
        ParkingInfo pinfo(parked_object, unpark_callback);
        parking_[makeKey(parked_object)] = pinfo;
    }

    template<typename T>
    int reference(T parked_object) {
        std::lock_guard<std::mutex> lock(mutex_);
        auto it = find(parked_object);
        if (it == parking_.end()) {
            isc_throw(InvalidOperation, "cannot reference an object"
                      " that has not been parked.");
        }

        // Bump and return the reference count
        return (++it->second.refcount_);
    }

    template<typename T>
    int dereference(T parked_object) {
        std::lock_guard<std::mutex> lock(mutex_);
        auto it = find(parked_object);
        if (it == parking_.end()) {
            isc_throw(InvalidOperation, "cannot dereference an object"
                      " that has not been parked.");
        }

        // Decrement and return the reference count.
        return (--it->second.refcount_);
    }

    template<typename T>
    bool unpark(T parked_object, bool force = false) {
        // Initialize as the empty function.
        std::function<void()> cb;
        {
            std::lock_guard<std::mutex> lock(mutex_);
            auto it = find(parked_object);
            if (it == parking_.end()) {
                // No such parked object.
                return (false);
            }

            if (force) {
                it->second.refcount_ = 0;
            } else {
                --it->second.refcount_;
            }

            if (it->second.refcount_ <= 0) {
                // Unpark the packet and set the callback.
                cb = it->second.unpark_callback_;
                parking_.erase(it);
            }
        }

        // Invoke the callback if not empty.
        if (cb) {
            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);
    }

    template<typename T>
    bool drop(T parked_object) {
        std::lock_guard<std::mutex> lock(mutex_);
        auto it = find(parked_object);
        if (it != parking_.end()) {
            // Parked object found.
            parking_.erase(it);
            return (true);
        }

        // No such object.
        return (false);
    }

public:

    struct ParkingInfo {
        boost::any parked_object_;

        std::function<void()> unpark_callback_;

        int refcount_;

        ParkingInfo() : refcount_(0) {}

        ParkingInfo(const boost::any& parked_object,
                    std::function<void()> callback = 0)
            : parked_object_(parked_object), unpark_callback_(callback),
              refcount_(0) {}

        void update(const boost::any& parked_object,
                    std::function<void()> callback) {
            parked_object_ = parked_object;
            unpark_callback_ = callback;
        }
    };

private:

    typedef std::unordered_map<std::string, ParkingInfo> ParkingInfoList;

    typedef ParkingInfoList::iterator ParkingInfoListIterator;

    ParkingInfoList parking_;

    template<typename T>
    std::string makeKey(T parked_object) {
        std::stringstream ss;
        ss << boost::any_cast<T>(parked_object);
        return (ss.str());
    }

    template<typename T>
    ParkingInfoListIterator find(T parked_object) {
        return (parking_.find(makeKey(parked_object)));
    }

    std::mutex mutex_;
};

typedef boost::shared_ptr<ParkingLot> ParkingLotPtr;

class ParkingLotHandle {
public:

    ParkingLotHandle(const ParkingLotPtr& parking_lot)
        : parking_lot_(parking_lot) {
    }

    template<typename T>
    int reference(T parked_object) {
        return (parking_lot_->reference(parked_object));
    }

    template<typename T>
    int dereference(T parked_object) {
        return (parking_lot_->dereference(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() {
        std::lock_guard<std::mutex> lock(mutex_);
        parking_lots_.clear();
    }

    ParkingLotPtr getParkingLotPtr(const int hook_index) {
        std::lock_guard<std::mutex> lock(mutex_);
        if (parking_lots_.count(hook_index) == 0) {
            parking_lots_[hook_index] = boost::make_shared<ParkingLot>();
        }
        return (parking_lots_[hook_index]);
    }

private:

    std::unordered_map<int, ParkingLotPtr> parking_lots_;

    std::mutex mutex_;
};

typedef boost::shared_ptr<ParkingLots> ParkingLotsPtr;

} // end of namespace hooks
} // end of namespace isc

#endif