NetworkTable.cpp

/*----------------------------------------------------------------------------*/
/* Copyright (c) FIRST 2011. All Rights Reserved.                             */
/* Open Source Software - may be modified and shared by FRC teams. The code   */
/* must be accompanied by the FIRST BSD license file in $(WIND_BASE)/WPILib.  */
/*----------------------------------------------------------------------------*/

#include "NetworkTables/NetworkTable.h"

#include "NetworkTables/BooleanEntry.h"
#include "NetworkTables/Buffer.h"
#include "NetworkTables/Connection.h"
#include "NetworkTables/ConnectionManager.h"
#include "NetworkTables/DoubleEntry.h"
#include "NetworkTables/Entry.h"
#include "NetworkTables/IntegerEntry.h"
#include "NetworkTables/Key.h"
#include "NetworkTables/NetworkQueue.h"
#include "NetworkTables/NetworkTableChangeListener.h"
#include "NetworkTables/NetworkTableAdditionListener.h"
#include "NetworkTables/NetworkTableConnectionListener.h"
#include "NetworkTables/StringEntry.h"
#include "NetworkTables/TableEntry.h"
#include "Synchronized.h"
#include "WPIErrors.h"

NetworkTable::TableNameMap NetworkTable::_tableNameMap;
NetworkTable::TableIdMap NetworkTable::_tableIdMap;
UINT32 NetworkTable::_currentId = 1;
bool NetworkTable::_initialized = false;
SEM_ID NetworkTable::_staticMemberMutex = semMCreate(SEM_Q_PRIORITY | SEM_INVERSION_SAFE | SEM_DELETE_SAFE);

NetworkTable::NetworkTable() :
        m_dataLock(NULL),
        m_listenerLock(NULL),
        m_id(GrabId()),
        m_transaction(NULL),
        m_transactionCount(0),
        m_hasChanged(NULL),
        m_hasAdded(NULL)
{
        m_dataLock = semMCreate(SEM_Q_PRIORITY | SEM_INVERSION_SAFE | SEM_DELETE_SAFE);
        m_listenerLock = semMCreate(SEM_Q_PRIORITY | SEM_INVERSION_SAFE | SEM_DELETE_SAFE);
        m_transaction = new NetworkTables::NetworkQueue();
        m_hasChanged = new NetworkTables::NetworkQueue();
        m_hasAdded = new NetworkTables::NetworkQueue();
}

NetworkTable::~NetworkTable()
{
        delete m_hasAdded;
        delete m_hasChanged;
        delete m_transaction;
        semTake(m_listenerLock, WAIT_FOREVER);
        m_connectionListeners.clear();
        m_additionListeners.clear();
        m_listeners.clear();
        m_listenToAllListeners.clear();
        semDelete(m_listenerLock);
        semTake(m_dataLock, WAIT_FOREVER);
        m_connections.clear();
        m_data.clear();
        semDelete(m_dataLock);
}

void NetworkTable::Initialize()
{
        if (!_initialized)
        {
                _initialized = true;
                NetworkTables::ConnectionManager::GetInstance();
        }
}

NetworkTable *NetworkTable::GetTable(const char *tableName)
{
        Initialize();
        Synchronized sync(_staticMemberMutex);
        // Insert will add a new element if the key is not found
        //  or will return the existing key if it is found.
        std::pair<TableNameMap::iterator, bool> ret =
                _tableNameMap.insert(TableNameMap::value_type(tableName, NULL));
        if (ret.second)
                // Key not found.  Create a table.
                ret.first->second = new NetworkTable();
        return ret.first->second;
}

NetworkTable *NetworkTable::GetTable(int id)
{
        Synchronized sync(_staticMemberMutex);
        // Don't check if the id is in the map(assume it is)
        // If it's not, we will get the ID mapped to an uninitialized pointer (bad)
        // TODO: Validate success and error if not found
        return _tableIdMap[id];
}

std::vector<const char *> NetworkTable::GetKeys()
{
        Synchronized sync(m_dataLock);
        std::vector<const char *> keys;
        keys.reserve(m_data.size());
        DataMap::iterator it = m_data.begin();
        DataMap::iterator end = m_data.end();
        for (; it != end; it++)
                if (it->second->HasEntry())
                        keys.push_back(it->second->GetName().c_str());
        return keys;
}

void NetworkTable::BeginTransaction()
{
        Synchronized sync(m_dataLock);
        m_transactionCount++;
}

void NetworkTable::EndTransaction()
{
        Synchronized sync(m_dataLock);
        if (m_transactionCount == 0)
        {
                wpi_setWPIErrorWithContext(NetworkTablesCorrupt, "EndTransaction() called too many times");
                return;
        }
        else if (--m_transactionCount == 0)
        {
                ProcessTransaction(true, m_transaction);
        }
}

void NetworkTable::AddChangeListener(const char *keyName, NetworkTableChangeListener *listener)
{
        Synchronized sync(m_listenerLock);
        std::set<NetworkTableChangeListener *> emptyList;
        std::pair<ListenersMap::iterator, bool> listenersForKey =
                m_listeners.insert(ListenersMap::value_type(keyName, emptyList));
        listenersForKey.first->second.insert(listener);
}

void NetworkTable::AddChangeListenerAny(NetworkTableChangeListener *listener)
{
        Synchronized sync(m_listenerLock);
        m_listenToAllListeners.insert(listener);
}

void NetworkTable::RemoveChangeListener(const char *keyName,
        NetworkTableChangeListener *listener)
{
        Synchronized sync(m_listenerLock);
        ListenersMap::iterator listenersForKey = m_listeners.find(keyName);
        if (listenersForKey != m_listeners.end())
                listenersForKey->second.erase(listener);
}

void NetworkTable::RemoveChangeListenerAny(NetworkTableChangeListener *listener)
{
        Synchronized sync(m_listenerLock);
        m_listenToAllListeners.erase(listener);
}

void NetworkTable::AddAdditionListener(NetworkTableAdditionListener *listener)
{
        Synchronized sync(m_listenerLock);
        m_additionListeners.insert(listener);
}

void NetworkTable::RemoveAdditionListener(
        NetworkTableAdditionListener *listener)
{
        Synchronized sync(m_listenerLock);
        m_additionListeners.erase(listener);
}

void NetworkTable::AddConnectionListener(
        NetworkTableConnectionListener *listener, bool immediateNotify)
{
        Synchronized sync(m_listenerLock);
        m_connectionListeners.insert(listener);
}

void NetworkTable::RemoveConnectionListener(
        NetworkTableConnectionListener *listener)
{
        Synchronized sync(m_listenerLock);
        m_connectionListeners.erase(listener);
}

bool NetworkTable::IsConnected()
{
        Synchronized sync(m_dataLock);
        return m_connections.size() > 0;
}

bool NetworkTable::ContainsKey(const char *keyName)
{
        if (keyName == NULL)
        {
                wpi_setWPIErrorWithContext(NullParameter, "keyName");
                return false;
        }
        Synchronized sync(m_dataLock);
        DataMap::iterator key = m_data.find(keyName);
        return key != m_data.end() && key->second->HasEntry();
}

NetworkTables::Entry *NetworkTable::GetEntry(const char *keyName)
{
        if (keyName == NULL)
        {
                wpi_setWPIErrorWithContext(NullParameter, "keyName");
                return NULL;
        }
        Synchronized sync(m_dataLock);
        DataMap::iterator key = m_data.find(keyName);
        if (key == m_data.end())
                return NULL;
        return key->second->GetEntry();
}

int NetworkTable::GetInt(const char *keyName)
{
        NetworkTables::Entry *entry = GetEntry(keyName);
        if (entry != NULL)
        {
                if (entry->GetType() == kNetworkTables_Types_INT)
                        return entry->GetInt();
                else
                        wpi_setWPIError(NetworkTablesWrongType);
        }
        return 0;
}

bool NetworkTable::GetBoolean(const char *keyName)
{
        NetworkTables::Entry *entry = GetEntry(keyName);
        if (entry != NULL)
        {
                if (entry->GetType() == kNetworkTables_Types_BOOLEAN)
                        return entry->GetBoolean();
                else
                        wpi_setWPIError(NetworkTablesWrongType);
        }
        return false;
}

double NetworkTable::GetDouble(const char *keyName)
{
        NetworkTables::Entry *entry = GetEntry(keyName);
        if (entry != NULL)
        {
                if (entry->GetType() == kNetworkTables_Types_DOUBLE)
                        return entry->GetDouble();
                else
                        wpi_setWPIError(NetworkTablesWrongType);
        }
        return 0.0;
}

int NetworkTable::GetString(const char *keyName, char *value, int len)
{
        NetworkTables::Entry *entry = GetEntry(keyName);
        if (entry != NULL)
        {
                if (entry->GetType() == kNetworkTables_Types_STRING)
                        return entry->GetString(value, len);
                else
                        wpi_setWPIError(NetworkTablesWrongType);
        }
        return 0;
}

std::string NetworkTable::GetString(std::string keyName)
{
        NetworkTables::Entry *entry = GetEntry(keyName.c_str());
        if (entry != NULL)
        {
                if (entry->GetType() == kNetworkTables_Types_STRING)
                        return entry->GetString();
                else
                        wpi_setWPIError(NetworkTablesWrongType);
        }
        return "";
}


NetworkTable *NetworkTable::GetSubTable(const char *keyName)
{
        NetworkTables::Entry *entry = GetEntry(keyName);
        if (entry != NULL)
        {
                if (entry->GetType() == kNetworkTables_Types_TABLE)
                        return entry->GetTable();
                else
                        wpi_setWPIError(NetworkTablesWrongType);
        }
        return NULL;
}

void NetworkTable::PutInt(const char *keyName, int value)
{
        Put(keyName, std::auto_ptr<NetworkTables::Entry>(new NetworkTables::IntegerEntry(value)));
}

void NetworkTable::PutBoolean(const char *keyName, bool value)
{
        Put(keyName, std::auto_ptr<NetworkTables::Entry>(new NetworkTables::BooleanEntry(value)));
}

void NetworkTable::PutDouble(const char *keyName, double value)
{
        Put(keyName, std::auto_ptr<NetworkTables::Entry>(new NetworkTables::DoubleEntry(value)));
}

void NetworkTable::PutString(const char *keyName, const char *value)
{
        if (value == NULL)
        {
                wpi_setWPIErrorWithContext(NullParameter, "value");
                return;
        }
        Put(keyName, std::auto_ptr<NetworkTables::Entry>(new NetworkTables::StringEntry(value)));
}

void NetworkTable::PutString(std::string keyName, std::string value)
{
        PutString(keyName.c_str(), value.c_str());
}

void NetworkTable::PutSubTable(const char *keyName, NetworkTable *value)
{
        if (value == NULL)
        {
                wpi_setWPIErrorWithContext(NullParameter, "value");
                return;
        }
        Put(keyName, std::auto_ptr<NetworkTables::Entry>(new NetworkTables::TableEntry(value)));
}

UINT32 NetworkTable::GrabId()
{
        Synchronized sync(_staticMemberMutex);
        return _currentId++;
}

void NetworkTable::ProcessTransaction(bool confirmed, NetworkTables::NetworkQueue *transaction)
{
        if (transaction->IsEmpty())
                return;

        NetworkTables::Connection *source = ((NetworkTables::Entry *)transaction->Peek())->GetSource();

        Synchronized sync(m_dataLock);

        std::set<NetworkTables::Connection *>::iterator it, end;
        it = m_connections.begin();
        end = m_connections.end();
        for (; it != end; it++)
                if (*it != source)
                        (*it)->OfferTransaction(transaction);

        while (!transaction->IsEmpty())
        {
                std::pair<NetworkTables::Data *, bool> data = transaction->Poll();
                // TODO: Remove this
                if (!data.second)
                        printf("Internal error!");
                std::auto_ptr<NetworkTables::Entry> entry =
                        std::auto_ptr<NetworkTables::Entry>((NetworkTables::Entry *)data.first);
                std::auto_ptr<NetworkTables::Entry> oldEntry = entry->GetKey()->SetEntry(entry);
                if (oldEntry.get() == NULL)
                        m_hasAdded->Offer(entry.get());
                else    // TODO: Filter unchanged values
                        m_hasChanged->Offer(entry.get());
        }
        while (!m_hasAdded->IsEmpty())
        {
                NetworkTables::Entry *entry = (NetworkTables::Entry *)m_hasAdded->Poll().first;
                AlertListeners(true, confirmed, entry->GetKey()->GetName().c_str(), entry);
        }
        while (!m_hasChanged->IsEmpty())
        {
                NetworkTables::Entry *entry = (NetworkTables::Entry *)m_hasChanged->Poll().first;
                AlertListeners(true, confirmed, entry->GetKey()->GetName().c_str(), entry);
        }
}

void NetworkTable::AddConnection(NetworkTables::Connection *connection)
{
        Synchronized sync(m_dataLock);

        if (m_connections.insert(connection).second)
        {
                DataMap::iterator it = m_data.begin();
                DataMap::iterator end = m_data.end();
                for (; it != end; it++)
                {
                        connection->Offer(it->second);
                        if(it->second->HasEntry())
                                connection->Offer(it->second->GetEntry());
                }
                if (m_connections.size() == 1)
                {
                        Synchronized syncStatic(_staticMemberMutex);
                        _tableIdMap.insert(TableIdMap::value_type(m_id, this));

                        std::set<NetworkTableConnectionListener *>::iterator lit, lend;
                        lit = m_connectionListeners.begin();
                        lend = m_connectionListeners.end();
                        for (; lit != lend; lit++)
                                (*lit)->Connected(this);
                }
        }
}

void NetworkTable::RemoveConnection(NetworkTables::Connection *connection)
{
        Synchronized sync(m_dataLock);

        m_connections.erase(connection);

        if (m_connections.size() == 0)
        {
                Synchronized syncStatic(_staticMemberMutex);
                _tableIdMap.erase(m_id);

                std::set<NetworkTableConnectionListener *>::iterator lit, lend;
                lit = m_connectionListeners.begin();
                lend = m_connectionListeners.end();
                for (; lit != lend; lit++)
                        (*lit)->Disconnected(this);
        }
}

NetworkTables::Key *NetworkTable::GetKey(const char *keyName)
{
        Synchronized sync(m_dataLock);
        // Insert will add a new element if the key is not found
        //  or will return the existing key if it is found.
        std::pair<DataMap::iterator, bool> ret =
                m_data.insert(DataMap::value_type(keyName, NULL));
        if (ret.second)
        {
                // Key not found.  Create a new one.
                ret.first->second = new NetworkTables::Key(this, keyName);
                if (m_connections.size() != 0)
                {
                        std::set<NetworkTables::Connection *>::iterator it, end;
                        it = m_connections.begin();
                        end = m_connections.end();
                        for (; it != end; it++)
                                (*it)->Offer(ret.first->second);
                }
        }
        return ret.first->second;
}

void NetworkTable::Put(const char *keyName, std::auto_ptr<NetworkTables::Entry> value)
{
        if (keyName == NULL)
        {
                wpi_setWPIErrorWithContext(NullParameter, "keyName");
                return;
        }
        Synchronized sync(m_dataLock);
        NetworkTables::Key *key = GetKey(keyName);
        value->SetKey(key);

        if (m_transactionCount == 0)
                Got(true, key, value);
        else
                m_transaction->Offer(std::auto_ptr<NetworkTables::Data>(value.release()));
}

void NetworkTable::Send(NetworkTables::Entry *entry)
{
        Synchronized sync(m_dataLock);
        std::set<NetworkTables::Connection *>::iterator it, end;
        it = m_connections.begin();
        end = m_connections.end();
        for (; it != end; it++)
                if (*it != entry->GetSource())
                        (*it)->Offer(entry);
}

void NetworkTable::Got(bool confirmed, NetworkTables::Key *key, std::auto_ptr<NetworkTables::Entry> value)
{
        std::auto_ptr<NetworkTables::Entry> old;
        {
                Synchronized sync(m_dataLock);
                old = key->SetEntry(value);
        }
        // TODO: return if value didn't change

        Send(key->GetEntry());
        AlertListeners(old.get() == NULL, confirmed, key->GetName().c_str(), key->GetEntry());
}

void NetworkTable::AlertListeners(bool isNew, bool confirmed, const char *keyName,
        NetworkTables::Entry *value)
{
        Synchronized sync(m_listenerLock);

        if (isNew && m_additionListeners.size() != 0)
        {
                std::set<NetworkTableAdditionListener *>::iterator lit, lend;
                lit = m_additionListeners.begin();
                lend = m_additionListeners.end();
                for (; lit != lend; lit++)
                        (*lit)->FieldAdded(this, keyName, value->GetType());
        }

        ListenersMap::iterator listeners = m_listeners.find(keyName);
        if (listeners != m_listeners.end())
        {
                std::set<NetworkTableChangeListener *>::iterator lit, lend;
                lit = listeners->second.begin();
                lend = listeners->second.end();
                for (; lit != lend; lit++)
                {
                        if (confirmed)
                                (*lit)->ValueConfirmed(this, keyName, value->GetType());
                        else
                                (*lit)->ValueChanged(this, keyName, value->GetType());
                }
        }

        {
                std::set<NetworkTableChangeListener *>::iterator lit, lend;
                lit = m_listenToAllListeners.begin();
                lend = m_listenToAllListeners.end();
                for (; lit != lend; lit++)
                {
                        if (confirmed)
                                (*lit)->ValueConfirmed(this, keyName, value->GetType());
                        else
                                (*lit)->ValueChanged(this, keyName, value->GetType());
                }
        }
}

void NetworkTable::EncodeName(NetworkTables::Buffer *buffer)
{
        buffer->WriteTableId(m_id);
}