IOManager.hpp

/*
Copyright 2007, 2008, 2009, 2010, 2011 Instituto de Sistemas e Robotica, Instituto Superior Tecnico

This file is part of MeRMaID.

MeRMaID 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.

MeRMaID 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 MeRMaID.  If not, see <http://www.gnu.org/licenses/>.
*/



#ifndef _IOMANAGER_HPP_
#define _IOMANAGER_HPP_

#include <string>
#include <map>

#include <ActiveObject.hpp>

#include "DeviceConfigurator.hpp"
#include "DeviceHandle.hpp"
#include "Device.hpp"
#include "IOThread.hpp"
#include "StreamOperationHandlerMethod.hpp"

namespace mermaid
{
  namespace support
  {
    namespace io
    {
    
      using boost::shared_ptr;
      using mermaid::support::activeobject::ActiveObject;
      
      /**
      * @Class IOManager IOManager.hpp "IOManager.hpp"
      * @Description IOManager class
      *
      * This is the class (singleton) which manages IO devices.
      * @Author Joao Carreira
      */
      class IOManager
      {
        public:
        
          /**
          * @Description Method used to retrieve the IOManager instance.
          *
          * This method is used to retrieve the IOManager (singleton entity) instance.
          * @Returns IOManager instance
          * @Author Joao Carreira
          */
          static shared_ptr<IOManager> getInstance();
          
          /**
          * @Description Creates a device.
          *
          * This method creates a device used to perform IO asynchronous operations in devices.
          * @Argument filename Name of the physical device.
          * @Argument owner ActiveObject in which this device is being created.
          * @Argument deviceConfigurator DeviceConfigurator used to configure the device when it has been opened.
          * @Returns Device handle to the created device.
          * @Author Joao Carreira
          */
          shared_ptr<DeviceHandle> createDevice (std::string filename, shared_ptr<ActiveObject> owner, shared_ptr<DeviceConfigurator> deviceConfigurator, int expectedDataSize);
          
          /**
          * @Description Start reading from a device.
          *
          * Enable read operations in a device. When read is enabled and there is available data the callback will be called.
          * @Argument device The device on which we want to enable read operations
          * @Author Joao Carreira
          */
          void enableDeviceRead (shared_ptr<Device> device, shared_ptr<StreamOperationHandlerMethodBase> streamOperationHandlerRead);
          
          /**
           * @Description Enable write operations in a device.
           *
           * Enable write operations in a device. This method must be called before writing to the device
           * @Argument device The device on which we want to enable read operations
           * @Author Joao Carreira
           */
          void enableDeviceWrite (shared_ptr<Device> device);
          
          /**
           * @Description Closes the given device
           * @Author Joao Carreira
           */
          void closeDevice (shared_ptr<Device> device);
          
          /**
          * @Description IOThread getter
          * @Returns IOThread of the IOManager
          * @Author Joao Carreira
          */
          shared_ptr<IOThread> getIOThread() const;
          
          /**
          * @Description Destructor
          * @Author Joao Carreira
          */
          ~IOManager();
          
        private:
          IOManager();
          static shared_ptr<IOManager> instance_;
          
          // Association between a device object and its handle.
          std::map<shared_ptr<Device>, shared_ptr<DeviceHandle> > deviceHandleMap_;
          
          // The IOThread which handles all the device events (read/write operations completed)
          shared_ptr<IOThread> ioThread_;
          
      }; // class IOManager
      
    } // namespace io
  } // namespace support
} // namespace mermaid

#endif // _IOMANAGER_HPP_