GyrosCommsInterface.hpp

Go to the documentation of this file.

/*
 * GyrosCommsInterface.hpp
 *
 *  Created on: Feb 14, 2011
 *      Author: Tomislav Lugaric
 *
 * This class represents an abstract communication interface
 * The communication interface is configured from an XML file
 * It uses a standardised xml based data format for communication
 * It can operate in active or passive mode
 * In active mode, the interface carries out operations when data is sent or received
 * In passive mode, an external object polls the interface for data
 * 
 */

#ifndef GYROSCOMMSINTERFACE_HPP_
#define GYROSCOMMSINTERFACE_HPP_

#include <LABUSTTypes.h>
#include <string>
#include <labust/xml/GyrosReader.hpp>
#include <labust/xml/GyrosWriter.hpp>
#include <labust/xml/GyrosMatrix.hpp>
#include <boost/smart_ptr.hpp>

#include <labust/plugins/Factory.hpp>
#include <labust/plugins/DLLoad.hpp>
#include <labust/xml/xmlfwd.hpp>

namespace LABUST
{
    namespace COMMUNICATION
    {

        namespace COMMERRORS
        {

            enum CommError
            {
                notImplemented = -2, // for functions that do not have an implementation (e.g. optional legacy functions)
                undefined = -1, // generic error
                noError = 0,
                noData = 1,
                callbackRegistered,
                communicationFailed, // for send/receive
                commsMisconfigured // if interface is not successfully configured
            };
        }

        class CommEntity
        {
        public:
            virtual int AcceptData(std::vector<labust::xml::GyrosReader> &data) = 0;
        private:

        };

        class GyrosCommsInterface
        {
        public:

            GyrosCommsInterface():
                        connected(false)
                        {};

            /*
             * Destructor, if interface needs to be explicitely terminated, put code here
             */
            virtual ~GyrosCommsInterface()
            {
            }

            virtual COMMERRORS::CommError Send(const labust::xml::GyrosWriter &data, bool wait = false) = 0;

            virtual COMMERRORS::CommError Send(const std::vector<labust::xml::GyrosWriter> &data, bool wait = false) = 0;

            virtual COMMERRORS::CommError Receive(std::vector<labust::xml::GyrosReader> &data, bool wait = false) = 0;

            virtual const void* GetCommObject(void)
            {
                return NULL;
            };

            virtual void RegisterCallbackObject(CommEntity *entity)
            {
                this->callbackObject = entity;
            };

            virtual void unRegisterCallbackObject()
            {
                this->callbackObject = NULL;
            };

                        inline const bool Connected()
                        {
                                return connected;
                        }
        protected:

            CommEntity *callbackObject;

                        bool connected;
        private:
            /*
             * Noncopyable
             */
            GyrosCommsInterface(const GyrosCommsInterface& orig);
            GyrosCommsInterface & operator =(const GyrosCommsInterface &);
        };


        typedef boost::shared_ptr<GyrosCommsInterface> GyrosCommsInterfacePtr;


    //Plugin factory typedef
    typedef labust::plugins::TmplPluginFactory<
      GyrosCommsInterface,
      const labust::xml::Reader&,
      const std::string&> CommsFactory;
    //Factory typedef
    typedef CommsFactory::AbstractFactory* CommsFactoryPtr;

    typedef labust::plugins::DLLoad<LABUST::COMMUNICATION::CommsFactory> CommsPlugin;
    typedef boost::shared_ptr<CommsPlugin> CommsPluginPtr;
 

    };
};
#endif /* GYROSCOMMSINTERFACE_HPP_ */