ObjectRequestQueue.cpp

Go to the documentation of this file.

/***************************** License **********************************

 Copyright (C) 2008 by Communicative Machines
 http://www.cmlabs.com   All rights reserved.

 This library 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 2.1 of the License, or (at your option) any later version.

 This library 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 this library; if not, write to the Free Software
 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA

************************************************************************/
// ObjectObjectRequestQueue.cpp: implementation of the ObjectObjectRequestQueue class.
//
//////////////////////////////////////////////////////////////////////

#include "ObjectRequestQueue.h"

namespace cmlabs {

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

ObjectRequestQueue::ObjectRequestQueue() {
        inQueue = new ObjectQueue();
        outQueue = new ObjectQueue();
}

ObjectRequestQueue::~ObjectRequestQueue()
{
        delete(inQueue);
        delete(outQueue);
}

//! Get total size of payload
unsigned long ObjectRequestQueue::getPayloadSize() const {
        return inQueue->getPayloadSize() + outQueue->getPayloadSize();
}

JString ObjectRequestQueue::enterRequest(Object* req) {
        JString id = inQueue->add(req);
        wait(0);
        return id;
}

Object* ObjectRequestQueue::waitForReply(JString id, long ms) {
        return outQueue->waitForNewEntry(id, ms);
}
        
bool ObjectRequestQueue::isEmpty() {
        return inQueue->isEmpty();
}

int ObjectRequestQueue::getCount() {
        return inQueue->getCount();
}



bool ObjectRequestQueue::waitForNewRequestToAppear(int ms) {
        return inQueue->waitForNewEntryToAppear(ms);
}

JString ObjectRequestQueue::waitForNewRequestID(int ms) {
        return inQueue->waitForNewEntryID(ms);
}

Object* ObjectRequestQueue::getRequest(JString id) {
        return inQueue->retrieveEntry(id);
}

bool ObjectRequestQueue::reply(JString id, Object* rep) {
        return (outQueue->add(id, rep).length() > 0);
}


// ***************************************************************
// Binary Functions
// ***************************************************************


//! Get the size of any binary data
long ObjectRequestQueue::getBinarySize(int chunk) {
        int chunkCountInQueue = 0, chunkCountOutQueue = 0;
        long binarySize = 0;
        if (inQueue != NULL) {
                chunkCountInQueue = inQueue->getBinaryChunkCount();
                if (chunk <= chunkCountInQueue)
                        return inQueue->getBinarySize(chunk);
        }
        if (outQueue != NULL) {
                chunkCountOutQueue = outQueue->getBinaryChunkCount();
                if (chunk > chunkCountInQueue)
                        return outQueue->getBinarySize(chunk - chunkCountInQueue);
        }
        return 0;
}

//! Get the number of data chunks
int ObjectRequestQueue::getBinaryChunkCount() {
        int chunkCountInQueue = 0, chunkCountOutQueue = 0;
        if (inQueue != NULL)
                chunkCountInQueue = inQueue->getBinaryChunkCount();
        if (outQueue != NULL)
                chunkCountOutQueue = outQueue->getBinaryChunkCount();
        return chunkCountInQueue + chunkCountOutQueue;
}

//! Get a pointer to the binary data at chunk number 'chunk'
long ObjectRequestQueue::toBinaryBuffer(int chunk, char* buffer, int maxlen) {
        int chunkCountInQueue = 0, chunkCountOutQueue = 0;
        long binarySize = 0;
        if (inQueue != NULL) {
                chunkCountInQueue = inQueue->getBinaryChunkCount();
                if (chunk <= chunkCountInQueue)
                        return inQueue->toBinaryBuffer(chunk, buffer, maxlen);
        }
        if (outQueue != NULL) {
                chunkCountOutQueue = outQueue->getBinaryChunkCount();
                if (chunk > chunkCountInQueue)
                        return outQueue->toBinaryBuffer(chunk-chunkCountInQueue, buffer, maxlen);
        }
        return 0;
}

//! Set the data after separate reception
bool ObjectRequestQueue::fromBinaryBuffer(int chunk, char* buffer, long len) {
        int chunkCountInQueue = 0, chunkCountOutQueue = 0;
        long binarySize = 0;
        if (inQueue != NULL) {
                chunkCountInQueue = inQueue->getBinaryChunkCount();
                if (chunk <= chunkCountInQueue)
                        return inQueue->fromBinaryBuffer(chunk, buffer, len);
        }
        if (outQueue != NULL) {
                chunkCountOutQueue = outQueue->getBinaryChunkCount();
                if (chunk > chunkCountInQueue)
                        return outQueue->fromBinaryBuffer(chunk-chunkCountInQueue, buffer, len);
        }
        return 0;
}


bool ObjectRequestQueue::unitTest() {

        ObjectRequestQueue* rq = new ObjectRequestQueue();

        if (rq->waitForReply("bla", 500) != NULL) {
                delete(rq);
                return false;
        }
        
        if (rq->waitForNewRequestID(500).length() > 0)
                return false;


        // now we add a request
        JString* str = new JString("Test");
        JString id = rq->enterRequest(str);

        // There should be no reply yet...
        if (rq->waitForReply(id, 500) != NULL)
                return false;
        
        JString id2 = rq->waitForNewRequestID(500);

        if (!id.equals(id2))
                return false;

        JString* request = (JString*) rq->getRequest(id2);
        
        if (!request->equals("Test"))
                return false;

        delete(request);

        // reply to request
        str = new JString("TestReply");
        if (!rq->reply(id, str))
                return false;

        // Now we should have a reply
        JString* repl = (JString*) rq->waitForReply(id, 500);
        if (!repl->equals("TestReply"))
                return false;

        delete(rq);
        delete(repl);

        return true;
}















} // namespace cmlabs

---