NetworkTable.h

#ifndef _NETWORKTABLE_H_
#define _NETWORKTABLE_H_

class NetworkTable;
class NetworkTableKeyCache;
class EntryCache;

#include <map>
#include <string>
#include "tables/ITable.h"
#include "tables/IRemote.h"
#include "networktables2/thread/NTThreadManager.h"
#include "networktables2/NetworkTableEntry.h"
#include "networktables2/util/StringCache.h"
#include "networktables/NetworkTableProvider.h"
#include "networktables/NetworkTableMode.h"
#include "networktables2/thread/DefaultThreadManager.h"
#include "networktables/NetworkTableConnectionListenerAdapter.h"
#include "networktables/NetworkTableListenerAdapter.h"
#include "tables/IRemoteConnectionListener.h"



using namespace std;



class NetworkTableKeyCache: public StringCache{
private:
        const std::string path;

public: 
        NetworkTableKeyCache(std::string path);
        ~NetworkTableKeyCache();

        std::string Calc(const std::string& key);
};


class EntryCache {
private:
        map<std::string, NetworkTableEntry*> cache;
        std::string& path;
public:
        EntryCache(std::string& path);
        ~EntryCache();
        
        NetworkTableEntry* Get(std::string& key);
};



class NetworkTable : public ITable, IRemote {
        
private:
        static DefaultThreadManager threadManager;
        static NetworkTableProvider* staticProvider;
        static NetworkTableNode* staticNode;
        static void* streamFactory;
        static NetworkTableEntryTypeManager* typeManager;
        static NetworkTableMode* mode;
        static int port;
        static std::string ipAddress;
        static NTReentrantSemaphore STATIC_LOCK;
        
        
        
        std::string path;
        EntryCache entryCache;
        NetworkTableKeyCache absoluteKeyCache;
        NetworkTableProvider& provider;
        NetworkTableNode& node;
        NTReentrantSemaphore LOCK;
        
        
        map<IRemoteConnectionListener*, NetworkTableConnectionListenerAdapter*> connectionListenerMap;
        multimap<ITableListener*, ITableListener*> listenerMap;
        
        static void CheckInit();
        
        NetworkTableEntry* GetEntry(std::string key);
        
public:

        static const char PATH_SEPARATOR_CHAR;
        static const std::string PATH_SEPARATOR;
        static const int DEFAULT_PORT;
        
        static void Initialize();
        static void Shutdown();

        static void SetTableProvider(NetworkTableProvider* provider);
        
        static void SetClientMode();
        
        static void SetServerMode();
        
        static void SetTeam(int team);
        static void SetIPAddress(const char* address);
        static NetworkTable* GetTable(std::string key);
        

        NetworkTable(std::string path, NetworkTableProvider& provider);
        virtual ~NetworkTable();
        
        bool IsConnected();

        bool IsServer();
        
        
        
        
        
        
        
        void AddConnectionListener(IRemoteConnectionListener* listener, bool immediateNotify);

        void RemoveConnectionListener(IRemoteConnectionListener* listener);
        

        void AddTableListener(ITableListener* listener);

        
        void AddTableListener(ITableListener* listener, bool immediateNotify);
        void AddTableListener(std::string key, ITableListener* listener, bool immediateNotify);
        void AddSubTableListener(ITableListener* listener);

        void RemoveTableListener(ITableListener* listener);
        
        

        NetworkTable* GetSubTable(std::string key);


        bool ContainsKey(std::string key);
        
        bool ContainsSubTable(std::string key);

        void PutNumber(std::string key, double value);

        double GetNumber(std::string key);

        double GetNumber(std::string key, double defaultValue);

        void PutString(std::string key, std::string value);

        std::string GetString(std::string key);

        std::string GetString(std::string key, std::string defaultValue);

        void PutBoolean(std::string key, bool value);

        bool GetBoolean(std::string key);

        bool GetBoolean(std::string key, bool defaultValue);
        

        void PutValue(std::string key, NetworkTableEntryType* type, EntryValue value);
        

    void RetrieveValue(std::string key, ComplexData& externalValue);
        
        void PutValue(std::string key, ComplexData& value);
        
        EntryValue GetValue(std::string key);
        
         EntryValue GetValue(std::string key, EntryValue defaultValue);

};

#endif