TuioClient.h

/*
 TUIO C++ Library
 Copyright (c) 2005-2017 Martin Kaltenbrunner <martin@tuio.org>
 
 This library is free software; you can redistribute it and/or
 modify it under the terms of the GNU Lesser General Public
 License as published by the Free Software Foundation; either
 version 3.0 of the License, or (at your option) any later version.
 
 This library is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
 Lesser General Public License for more details.
 
 You should have received a copy of the GNU Lesser General Public
 License along with this library.
*/

#ifndef INCLUDED_TUIOCLIENT_H
#define INCLUDED_TUIOCLIENT_H

#include "TuioDispatcher.h"
#include "OscReceiver.h"
#include "osc/OscReceivedElements.h"

#include <iostream>
#include <list>
#include <map>
#include <algorithm>
#include <string>
#include <cstring>

namespace TUIO {
    
    class OscReceiver; // Forward declaration
    
    class LIBDECL TuioClient : public TuioDispatcher { 
        
    public:
        TuioClient();
    
        TuioClient(int port);
        
        TuioClient(OscReceiver *oscreceiver);

        ~TuioClient();

        void connect(bool lock=false);
        
        void disconnect();
        
        bool isConnected();

        std::list<TuioObject*> getTuioObjects() {
            return TuioDispatcher::getTuioObjects();
        }
        
        std::list<TuioObject*> getTuioObjects(int source_id);

        std::list<TuioObject> copyTuioObjects(int source_id);

        
        std::list<TuioObject> copyTuioObjects() {
            return TuioDispatcher::copyTuioObjects();
        }
        
        TuioObject* getTuioObject(long s_id) {
            return getTuioObject(0,s_id);
        };
        
        TuioObject* getTuioObject(int src_id, long s_id);

        std::list<TuioCursor*> getTuioCursors() {
            return TuioDispatcher::getTuioCursors();
        }
        
        std::list<TuioCursor*> getTuioCursors(int source_id);

        std::list<TuioCursor> copyTuioCursors() {
            return TuioDispatcher::copyTuioCursors();
        }
        
        std::list<TuioCursor> copyTuioCursors(int source_id);
        
        TuioCursor* getTuioCursor(long s_id) {
            return getTuioCursor(0,s_id);
        };
        
        TuioCursor* getTuioCursor(int src_id, long s_id);

        std::list<TuioBlob*> getTuioBlobs() {
            return TuioDispatcher::getTuioBlobs();
        }
        
        std::list<TuioBlob*> getTuioBlobs(int source_id);

        std::list<TuioBlob> copyTuioBlobs() {
            return TuioDispatcher::copyTuioBlobs();
        }
        
        std::list<TuioBlob> copyTuioBlobs(int source_id);
        
        TuioBlob* getTuioBlob(long s_id) {
            return getTuioBlob(0,s_id);
        };
        
        TuioBlob* getTuioBlob(int src_id, long s_id);
        
        void processOSC( const osc::ReceivedMessage& message);
        
    private:
        void initialize();
        
        std::list<TuioObject*> frameObjects;
        std::list<long> aliveObjectList;
        std::list<TuioCursor*> frameCursors;
        std::list<long> aliveCursorList;
        std::list<TuioBlob*> frameBlobs;
        std::list<long> aliveBlobList;
        
        osc::int32 currentFrame;
        TuioTime currentTime;
            
        std::list<TuioCursor*> freeCursorList, freeCursorBuffer;
        std::map<int,int> maxCursorID;

        std::list<TuioBlob*> freeBlobList, freeBlobBuffer;
        std::map<int,int> maxBlobID;
        
        std::map<std::string,int> sourceList;
        int source_id;
        char *source_name;
        char *source_addr;
        
        OscReceiver *receiver;
        bool local_receiver;
    };
};
#endif /* INCLUDED_TUIOCLIENT_H */