include/spinBaseContext.h

// -----------------------------------------------------------------------------
// |    ___  ___  _  _ _     ___                                        _      |
// |   / __>| . \| || \ |   | __>_ _  ___ ._ _ _  ___  _ _ _  ___  _ _ | |__   |
// |   \__ \|  _/| ||   |   | _>| '_><_> || ' ' |/ ._>| | | |/ . \| '_>| / /   |
// |   <___/|_|  |_||_\_|   |_| |_|  <___||_|_|_|\___.|__/_/ \___/|_|  |_\_\   |
// |                                                                           |
// |---------------------------------------------------------------------------|
//
// http://spinframework.sourceforge.net
// Copyright (C) 2009 Mike Wozniewski, Zack Settel
//
// Developed/Maintained by:
//    Mike Wozniewski (http://www.mikewoz.com)
//    Zack Settel (http://www.sheefa.net/zack)
//
// Principle Partners:
//    Shared Reality Lab, McGill University (http://www.cim.mcgill.ca/sre)
//    La Societe des Arts Technologiques (http://www.sat.qc.ca)
//
// Funding by:
//    NSERC/Canada Council for the Arts - New Media Initiative
//    Heritage Canada
//    Ministere du Developpement economique, de l'Innovation et de l'Exportation
//
// -----------------------------------------------------------------------------
//  This file is part of the SPIN Framework.
//
//  SPIN Framework 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 of the License, or
//  (at your option) any later version.
//
//  SPIN Framework 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 SPIN Framework. If not, see <http://www.gnu.org/licenses/>.
// -----------------------------------------------------------------------------

#ifndef __spinBaseContext_H
#define __spinBaseContext_H

#include <vector>
#include <string>
#include <lo/lo_types.h>
#include "EventTypes.h"
#include <osg/ArgumentParser>

namespace spin
{

// Forward declarations
class spinLog;
class EventHandler;

class spinBaseContext
{
    public:
        spinBaseContext();

        virtual ~spinBaseContext();

        static void sigHandler(int signum);

        static volatile bool signalStop;

        enum SpinContextMode { SERVER_MODE, CLIENT_MODE };

        bool isServer() { return mode==SERVER_MODE; }

        virtual bool start() = 0;

        virtual void debugPrint();

        virtual void addCommandLineOptions(osg::ArgumentParser *arguments);
        virtual int parseCommandLineOptions(osg::ArgumentParser *arguments);

        bool startThread( void *(*threadFunction) (void*) );

        void stop();

        bool isRunning() { return running; }


        void addInfoHandler(EventHandler *obs);
        void removeInfoHandler(EventHandler *obs);

        void removeHandlerForAllEvents(EventHandler *obs);


        bool canAutoAssignPorts() { return autoPorts_; }
        
        void setTTL(int ttl);

        std::vector<lo_address> lo_txAddrs_;

        std::vector<lo_address> lo_rxAddrs_;
        
        std::vector<lo_server> lo_rxServs_;

        lo_address lo_infoAddr;
        
        lo_address lo_syncAddr;
        lo_server lo_infoServ_;
       
        std::string tcpPort_; 
        lo_server lo_tcpRxServer_;

        static int connectionCallback(const char *path, const char *types, lo_arg **argv, 
                int argc, void *data, void *user_data);
        static int nodeCallback(const char *path, const char *types, lo_arg **argv, 
                int argc, void *data, void *user_data);
        static int sceneCallback(const char *path, const char *types, lo_arg **argv, 
                int argc, void *data, void *user_data);
        static int logCallback(const char *path, const char *types, lo_arg **argv, 
                int argc, void *data, void *user_data);
        static int debugCallback(const char *path, const char *types, lo_arg **argv, 
                int argc, void *data, void *user_data);

        static void oscParser_error(int num, const char *msg, const char *path);

        bool doDiscovery_;

    protected:
        bool running;
        bool autoPorts_;
        SpinContextMode mode;
        void setLog(spinLog &log);

        std::vector<EventHandler*> infoHandlers;
        std::vector<EventHandler*> nodeHandlers;
        std::vector<EventHandler*> sceneHandlers;

        virtual void createServers() = 0;

    private:
        // pthread stuff
        pthread_t pthreadID; // id of child thread
        pthread_attr_t pthreadAttr;
};

} // end of namespace spin

#endif