---

eventQuery.cpp

Go to the documentation of this file.

#include "eventQuery.h"
#include "rmClientTypes.h"

int
eventQuery::removeElement(unsigned long aID)
{
  int ret;

  EventQuery * query = getElement(aID);
  if(!query)
    return RMCLIENT_ERROR_QUERY;

  if(query->refCnt > 0)
    return RMCLIENT_ERROR_CC_REFCNT;

  if(query->status == ACTIVE) {
    ret = posix_log_query_destroy(&(query->query));
    if(ret)
      return RMCLIENT_ERROR_QUERY_DESTROY;
  }

  return rmRefArray<EventQuery>::removeElement(aID);
}

bool
eventQuery::elementIsReady(const EventQuery & aQuery) const
{
  if(aQuery.purpose > PURPOSE_GENERAL || aQuery.purpose < PURPOSE_NOTIFY)
    return false;

  if(aQuery.qstr.size() == 0)
    return false;

  return true;
}

int
eventQuery::getInteger32(RMAttribute aName, unsigned long aID, long & aValue)
{
  aValue = -1;
  const EventQuery * query = getConstElement(aID);
  if(!query)
    return RMCLIENT_ERROR_QUERY;

  switch(aName) {
    case EVENTQUERY_PURPOSE:
      aValue = query->purpose;
      break;

    case EVENTQUERY_REFCOUNT:
      aValue = query->refCnt;
      break;

    case EVENTQUERY_STATUS:
      aValue = query->status;
      break;

    default:
      return RMCLIENT_ERROR_NOSUCHNAME;
  }

  return RMCLIENT_SUCCESS;
}

int
eventQuery::setInteger32(RMAttribute aName, unsigned long aID, long aValue)
{
  int ret, purpose;

  EventQuery * query = getElement(aID);
  if(!query)
    return RMCLIENT_ERROR_QUERY;

  if(query->refCnt > 0)
    return RMCLIENT_ERROR_CC_REFCNT;

  switch(aName) {

    case EVENTQUERY_PURPOSE:
      // do not modify anything while we r active.
      if(query->status == ACTIVE)
        return RMCLIENT_ERROR_STATE;

      // '1' is for notify, '2' is for seek, '3' is for general
      if(aValue < PURPOSE_NOTIFY || aValue > PURPOSE_GENERAL)
        return RMCLIENT_ERROR_NOSUCHVALUE;

      query->purpose = aValue;
      updateStatus(*query);

      break;

    case EVENTQUERY_STATUS:
      if(aValue < NOTEXIST || aValue > DESTROY || aValue == NOTREADY)
        return RMCLIENT_ERROR_NOSUCHVALUE;

      if(aValue == ACTIVE) {

        if(query->status == NOTINSERVICE) {

          if(query->purpose == PURPOSE_NOTIFY)
            purpose = POSIX_LOG_PRPS_NOTIFY;
          else if(query->purpose == PURPOSE_SEEK)
            purpose = POSIX_LOG_PRPS_SEEK;
          else 
            purpose = POSIX_LOG_PRPS_GENERAL;

          ret = posix_log_query_create(query->qstr.c_str(), purpose, &(query->query), 0, 0);
          if(ret)
            return RMCLIENT_ERROR_QUERY_CREATE;
        } 
        else if(query->status == ACTIVE) 
          return RMCLIENT_SUCCESS;

        // we r "notready", cannot change status to active.
        else  {
          return RMCLIENT_ERROR_STATE;
        }

      } 
      else if(aValue == NOTINSERVICE) {

        if(query->status == ACTIVE) {

          ret = posix_log_query_destroy(&(query->query));
          if(ret)
            return RMCLIENT_ERROR_QUERY_DESTROY;

          memset(&(query->query), 0, sizeof(posix_log_query_t));
        }
        else if(query->status == NOTINSERVICE)
          return RMCLIENT_SUCCESS;

        // we r "notready", cannot change status to notinservice.
        else 
          return RMCLIENT_ERROR_STATE;
      }

      query->status = aValue;
      break;

    default:
      return RMCLIENT_ERROR_NOSUCHNAME;
  }

  return RMCLIENT_SUCCESS;
}

int
eventQuery::getString(RMAttribute aName, unsigned long aID, char * & aBuf)
{
  aBuf = NULL;

  int purpose;
  size_t len, qstrlen;
  char * qstrbuf(NULL);

  const EventQuery * query = getConstElement(aID);
  if(!query) 
    return  RMCLIENT_ERROR_QUERY;

  switch(aName) {

    case EVENTQUERY_STRING:

      if(query->status == ACTIVE) {
        posix_log_query_get(&(query->query), &purpose, 0, 0, &len);
        if(len && purpose) {

          qstrlen = len;
          qstrbuf = (char *) malloc(sizeof(char)*qstrlen);
          if(!qstrbuf)
            return RMCLIENT_ERROR_MEMORY;

          posix_log_query_get(&query->query, &purpose, qstrbuf, qstrlen, &len);
        }
        else return RMCLIENT_ERROR_QUERY_STRING;
      } else {

        qstrlen = query->qstr.size() + 1;

        if(qstrlen > 1) {
          qstrbuf = (char *) malloc(sizeof(char)*qstrlen);
          if(!qstrbuf)
            return RMCLIENT_ERROR_MEMORY;

          strncpy(qstrbuf, query->qstr.c_str(), qstrlen);
        }
      }

      aBuf = qstrbuf;
      break;

    default:
      return RMCLIENT_ERROR_NOSUCHNAME;
  }
  return RMCLIENT_SUCCESS;
}

int
eventQuery::setString(RMAttribute aName, unsigned long aID, char * aBuf)
{
  EventQuery * query = getElement(aID);
  if(!query) 
    return  RMCLIENT_ERROR_QUERY;

  if(query->refCnt > 0)
    return RMCLIENT_ERROR_CC_REFCNT;

  switch(aName) {

    case EVENTQUERY_STRING:

      // do not modify the string while the query is active
      if(query->status == ACTIVE) 
        return RMCLIENT_ERROR_STATE;

      query->qstr = aBuf;
      break;

    default:
      return RMCLIENT_ERROR_NOSUCHNAME;
  }

  updateStatus(*query);
  return RMCLIENT_SUCCESS;
}

int
eventQuery::addDefaultElement(unsigned long aID)
{
  EventQuery query;

  // memset(&query, 0, sizeof(EventQuery));

  query.purpose = 0;
  query.refCnt = 0;
  query.status = NOTREADY;

  return addElement(query, aID);
}

---