GenericSession.cpp

Go to the documentation of this file.

/*

Copyright (C) 2006-2007 by Peter Dimov.

This file is part of Calitko (http://www.calitko.org).

Calitko is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.

Calitko 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 General Public License for more details.

You should have received a copy of the GNU General Public License
along with Calitko; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

*/

#include "Qt.h"
#include "GenericSession.h"
#include "Imports.cpp"


GenericSession::GenericSession (Transport *transport_,
                                DataSerializer *serializer_,
                                DataQueue *queue_,
                                SessionStatus *status_)
 :  transport (transport_),
    dataSerializer (serializer_),
    dataQueue (queue_),
    status (status_),
    state (Closed)
{
    Q_ASSERT (transport != 0 && dataSerializer != 0
              && dataQueue != 0 && status != 0);
}

GenericSession::~GenericSession()
{
}


void GenericSession::open()
{
    Q_ASSERT (state == Closed);
    state = Opened;
    transportReadyRead (transport);
}


void GenericSession::send (const Data &data)
{
    Q_ASSERT (state == Opened);
    status->sessionSendingData (this, data);
    if (!dataQueue->isEmpty() || !dataSerializer->write (data, transport))
        dataQueue->enqueue (data);
}


void GenericSession::abort()
{
    state = Closing;
    status->sessionClosing (this);
    // \todo Clear buffer?
    transport->abort();
    Q_ASSERT (state == Closed);
}


void GenericSession::close()
{
    Q_ASSERT (state == Opened);
    state = Closing;
    status->sessionClosing (this);
    if (dataQueue->isEmpty())
        transport->disconnectFromNode();
}


void GenericSession::transportConnected (Transport *)
{
    Q_ASSERT (false);
}

void GenericSession::transportReadyRead (Transport *)
{
    Q_ASSERT (state != Closed);
    Data data;
    // The handler for sessionReceivedData() may call close() or abort()
    // so we should check our state before trying again to read anything:
    while (state != Closed && dataSerializer->read (data, transport))
        status->sessionReceivedData (this, data);
}

void GenericSession::transportReadyWrite (Transport *)
{
    Q_ASSERT (state != Closed);
    while (!dataQueue->isEmpty())
        if (dataSerializer->write (dataQueue->next(), transport))
            dataQueue->dequeue();
        else
            break;
    if (state == Closing)
        transport->disconnectFromNode();
}

void GenericSession::transportDisconnected (Transport *)
{
    Q_ASSERT (state != Closed);
    state = Closed;
    status->sessionClosed (this);
}

Copyright © 2006 Peter Dimov.
Powered by Doxygen.