Connection.hxx

Go to the documentation of this file.

 
#ifndef _BLE_CONNECTION_HXX_
#define _BLE_CONNECTION_HXX_
 
#include <functional>
#include <vector>
#include <cstring>
 
#include "ble/Defs.hxx"
#include "utils/Singleton.hxx"
 
namespace ble
{
 
// Forward declaration.
class Connections;
 
class Connection
{
public:
    Defs::ConnHandle get_handle()
    {
        return handle_;
    }
 
    void get_addr(Defs::Addr addr, Defs::AddrType *addr_type)
    {
        memcpy(addr, addr_, Defs::ADDR_LEN);
        if (addr_type)
        {
            *addr_type = addrType_;
        }
    }
 
    ~Connection()
    {
    }
 
private:
    Connection(Defs::ConnHandle handle, Defs::Addr addr,
               Defs::AddrType addr_type, bool central)
        : handle_(handle)
        , addrType_(addr_type)
        , central_(central)
    {
        memcpy(addr_, addr, Defs::ADDR_LEN);
    }
 
    Defs::ConnHandle handle_; 
    Defs::Addr addr_; 
    Defs::AddrType addrType_; 
    bool central_; 
 
    friend class Connections;
};
 
class Connections : public Singleton<Connections>
{
public:
    Connections()
    {
    }
 
    void register_connection(Defs::ConnHandle handle, Defs::Addr addr,
                             Defs::AddrType addr_type, bool central)
    {
        connections_.emplace_back(Connection(handle, addr, addr_type, central));
    }
 
    void register_disconnect_callback(
        std::function<void(Connection *connection)> callback)
    {
        callbacks_.emplace_back(callback);
    }
 
    void disconnect(Connection *conn)
    {
        // Execute all of the registered disconnect callbacks.
        for (auto &e : callbacks_)
        {
            e(conn);
        }
        // Remove the connection instance from the container.
        for (auto it = connections_.begin(); it != connections_.end(); ++it)
        {
            if (&(*it) == conn)
            {
                connections_.erase(it);
                // Should only be one entry per connection in the container.
                return;
            }
        }      
    }
 
    void disconnect(Defs::ConnHandle handle)
    {
        // Remove the connection instance from the container.
        for (auto it = connections_.begin(); it != connections_.end(); ++it)
        {
            if (it->get_handle() == handle)
            {
                // Execute all of the registered disconnect callbacks.
                for (auto &e : callbacks_)
                {
                    e(&(*it));
                }
                connections_.erase(it);
                // Should only be one entry per connection in the container.
                return;
            }
        }      
    }
 
    Connection *lookup_by_address(Defs::Addr addr, Defs::AddrType addr_type)
    {
        for (auto &e : connections_)
        {
            if (!memcmp(e.addr_, addr, Defs::ADDR_LEN) &&
                e.addrType_ == addr_type)
            {
                // Match.
                return &e;
            }
        }
        return nullptr;
    }
 
    Connection *lookup_by_handle(Defs::ConnHandle handle)
    {
        for (auto &e : connections_)
        {
            if (e.handle_ == handle)
            {
                // Match.
                return &e;
            }
        }
        return nullptr;
    }
 
    size_t get_active_count()
    {
        return connections_.size();
    }
 
private:
    std::vector<Connection> connections_;
    std::vector<std::function<void(Connection *connection)>> callbacks_;
};
 
} // namespace ble
 
#endif // _BLE_CONNECTION_HXX_