source: geovis/trunk/ResponseQueue.h @ 5224

Last change on this file since 5224 was 3998, checked in by ldelgass, 10 years ago

Add prelimilary skeleton for geovis map rendering server. Not functional, not
integrated into configure, etc.

File size: 3.0 KB
Line 
1/* -*- mode: c++; c-basic-offset: 4; indent-tabs-mode: nil -*- */
2/*
3 * Copyright (C) 2004-2013  HUBzero Foundation, LLC
4 *
5 * Author: George A. Howlett <gah@purdue.edu>
6 */
7#ifndef GEOVIS_RESPONSE_QUEUE_H
8#define GEOVIS_RESPONSE_QUEUE_H
9
10#include <pthread.h>
11#include <semaphore.h>
12#include <cstdlib>
13#include <cstring>
14#include <list>
15
16namespace GeoVis {
17
18/**
19 * \brief Holds data for a response to be sent to client
20 */
21class Response
22{
23public:
24    enum AllocationType {
25        STATIC,
26        DYNAMIC,
27        VOLATILE
28    };
29    enum ResponseType {
30        IMAGE,          /**< Image to be displayed. */
31        LEGEND,         /**< Legend to be displayed. */
32        DATA,           /**< Any other type of non-error message. */
33        ERROR,          /**< Error message. */
34        OK              /**< Ack for client when no render required */
35    };
36
37    Response(ResponseType type) :
38        _mesg(NULL),
39        _length(0),
40        _type(type)
41    {
42    }
43
44    virtual ~Response()
45    {
46        if ((_length > 0) && (_mesg != NULL) && (_allocType == DYNAMIC)) {
47            free(_mesg);
48        }
49    }
50
51    /// Get the ResponseType
52    ResponseType type()
53    {
54        return _type;
55    }
56
57    /// Get the Response data
58    unsigned char *message()
59    {
60        return _mesg;
61    }
62
63    /// Get the number of bytes in the Response data
64    size_t length()
65    {
66        return _length;
67    }
68
69    /// Set the message/data making up the Response
70    /**
71     * If the AllocationType is DYNAMIC, the message data will be free()d
72     * by the destructor.  If the AllocationType is VOLATILE, a copy of
73     * the message data will be made.
74     *
75     * \param[in] mesg The Response data, can be a command and/or binary data
76     * \param[in] length The number of bytes in mesg
77     * \param[in] type Specify how the memory was allocated for mesg
78     */
79    void setMessage(unsigned char *mesg, size_t length, AllocationType type)
80    {
81        if (type == VOLATILE) {
82            _length = length;
83            _mesg = (unsigned char *)malloc(length);
84            memcpy(_mesg, mesg, length);
85            _allocType = DYNAMIC;
86        } else {
87            _length = length;
88            _mesg = mesg;
89            _allocType = type;
90        }
91    }
92
93private:
94    /**
95     * (Malloc-ed by caller, freed by destructor)
96     * Contains the message/bytes to be sent to the client. */
97    unsigned char *_mesg;
98    size_t _length;       /**< # of bytes in the above message. */
99    ResponseType _type;
100    AllocationType _allocType;
101};
102
103/**
104 * \brief Queue to hold pending Responses to be sent to the client
105 *
106 * A semaphore and mutex are used to control access to the
107 * queue by a reader and writer thread
108 */
109class ResponseQueue
110{
111public:
112    ResponseQueue();
113
114    virtual ~ResponseQueue();
115
116    /// Add a response to the end of the queue
117    void enqueue(Response *response);
118
119    /// Remove a response from the front of the queue
120    Response *dequeue();
121
122private:
123    pthread_mutex_t _idle;
124    sem_t _ready; /**< Semaphore indicating that a response has been queued. */
125    std::list<Response *> _list;
126};
127
128}
129
130#endif
Note: See TracBrowser for help on using the repository browser.