Device.cpp

/*
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/>.
*/



#include "config.h"

#include "Device.hpp"
#include "DeviceConfigurator.hpp"
#include "StreamReader.hpp"
#include "StreamReadReplyTask.hpp"
#include "StreamWriter.hpp"
#include "StreamWriteReplyTask.hpp"
#include "IOManager.hpp"

#include <cassert>

using namespace mermaid::support::io;

using boost::shared_ptr;

Device::~Device()
{

}

Device::Device (int expectedDataSize, int fileDescriptor, shared_ptr<ActiveObject> owner, shared_ptr<DeviceConfigurator> deviceConfigurator) :
    expectedDataSize_ (expectedDataSize), fileDescriptor_ (fileDescriptor), readEnabled_ (false), writeEnabled_ (false), deviceConfigurator_ (deviceConfigurator),
    owner_ (owner), streamOperationHandlerRead_ ()
{
}

void Device::enableRead (shared_ptr<StreamOperationHandlerMethodBase> streamOperationHandlerRead)
{
  streamOperationHandlerRead_ = streamOperationHandlerRead;
  if (readEnabled_ == false) {
    shared_ptr<StreamReader> streamReader (new StreamReader (this));
    IOManager::getInstance()->getIOThread()->addStreamReader (streamReader);
    readEnabled_ = true;
  }
}

void Device::enableWrite()
{
  if (writeEnabled_ == false) {
    shared_ptr<StreamWriter> streamWriter (new StreamWriter (this));
    IOManager::getInstance()->getIOThread()->addStreamWriter (streamWriter);
    writeEnabled_ = true;
  }
}

void Device::write (size_t bytesToWrite, const char* data, shared_ptr<StreamOperationHandlerMethodBase> streamOperationHandlerWrite)
{
  enableWrite();
  assert (writeEnabled_ == true);
  IOManager::getInstance()->getIOThread()->addWriteOperation (fileDescriptor_, bytesToWrite, data, streamOperationHandlerWrite);
}

void Device::callReadHandler (size_t bytesRead, size_t requestedBytes, const char* data, bool success)
{
  owner_->addTask (shared_ptr<Task> (new StreamReadReplyTask (bytesRead, requestedBytes, data, success, streamOperationHandlerRead_)));
}

void Device::callWriteHandler (size_t bytesWritten, size_t requestedBytes, const char* data, bool success, shared_ptr<StreamOperationHandlerMethodBase> streamOperationHandlerWrite)
{
  owner_->addTask (shared_ptr<Task> (new StreamWriteReplyTask (bytesWritten, requestedBytes, data, success,
                                     streamOperationHandlerWrite)));
}

void Device::close()
{
  IOManager::getInstance()->getIOThread()->addCloseOperation (fileDescriptor_, writeEnabled_, readEnabled_);
}

void Device::configureDevice (shared_ptr<DeviceConfigurator> deviceConfigurator)
{
  deviceConfigurator->configureDevice (fileDescriptor_);
}