ippServerQueues.cpp

Go to the documentation of this file.

// 
// DISCLAIMER: 
//  This software was produced by the National Institute of Standards 
//  and Technology (NIST), an agency of the U.S. government, and by statute is 
//  not subject to copyright in the United States.  Recipients of this 
//  software assume all responsibility associated with its operation,
//  modification,maintenance, and subsequent redistribution. 
//
//  See NIST Administration Manual 4.09.07 b and Appendix I. 
//
// History
// Who When     What
// --- -------- ---------------------------------------------------------------
// ER  09/03/06 remove handshaking and improve naming of methods
//-----------------------------------------------------------------------------

#include "stdafx.h"

#include "ippdme/Server/ippServerQueues.h"
#include "ippdme/assert.h"

ippServerQueues::ippServerQueues()
{ 
  _tagList.reserve(50);
}



void ippServerQueues::addTag(int tag_num)
{
         _tagList.push_back(tag_num);
}

void ippServerQueues::delTag(int tag_num)
{
  for ( std::vector<int>::iterator p = _tagList.begin(); p != _tagList.end(); p++){
          if (*p == tag_num) {
                  _tagList.erase(p);
                  break;
          }
        }
}

bool ippServerQueues::tagInList(int tag_num) const
{
        std::vector<int>::const_iterator p;
  for (p = _tagList.begin(); p != _tagList.end(); p++)  {
    if (*p == tag_num) {
            break;
    }
        } 
        return ((p == _tagList.end()) ? false : true);   
}


// Put an event on the event queue
void ippServerQueues::EnqueueEvent(const char * a_string) 
{
        _fastQueue.push(a_string);
}

// Put a command on the command queue
void ippServerQueues::EnqueueCommand(const char * a_string) 
{
  _slowQueue.push(a_string);
}

// Put a response on the response queue
void ippServerQueues::EnqueueResponse(const char * a_string)
{
  _responseQueue.push(a_string);
}

// Remove an event from the event queue
std::string ippServerQueues::DequeueEvent() 
{
  IPP_ASSERT(_fastQueue.size()>0);
        std::string a_string = _fastQueue.front();
  _fastQueue.pop();
        return a_string;
}

// Remove a command from the command queue
std::string ippServerQueues::DequeueCommand() 
{
  IPP_ASSERT(_slowQueue.size()>0);
        std::string a_string= _slowQueue.front();
        _slowQueue.pop();
  return a_string;
}

// Remove a response from the response queue
std::string ippServerQueues::DequeueResponse() 
{
  IPP_ASSERT(_responseQueue.size()>0);
  std::string a_string= _responseQueue.front();
        _responseQueue.pop();
        return a_string;
}



// Clear all queues in the case of an abort or a mid session client disconnect
void ippServerQueues::ClearAllQueues()
{
        while (_fastQueue.empty() == false) { _fastQueue.pop(); }
        while (_slowQueue.empty() == false) { _slowQueue.pop(); }
        while (_responseQueue.empty() == false) { _responseQueue.pop(); }
        _tagList.erase(_tagList.begin(), _tagList.end());
}

ippServerQueues::~ippServerQueues()
{

}

---