50.1.1. Sample ring EVBClientApp class.

This section incrementally develops an application that can take data from a ring buffer and submit it to the event builder. This is not really a production quality effort, it is designed to illustrate several points. Little bits of code and #include directives are also not shown in order to keep these examples understandable.

Let's start by writing a definition of the CEVBRingClientApp class. For this example the ring URL will be gotten from the RINGURL environment variable (a production version would probably use a command line option but that's beyond the scope of this example.

class CRingBuffer;
class CEVBRingClientApp : public CEVBClientApp {
private:
   CRingBuffer* m_pRing;
public:
  virtual void initialize();
  virtual bool dataReady(int ms) = 0;
  virtual void getEvents() = 0;
  virtual void shutdown();

};
                

There should be no surprises here. All methods have been declared as concrete rather than leaving dataReady and getEvents as pure virtual. Furthermore, m_pRing has been declared as a pointer to a ring buffer object. For illustrative purpose, we'll create the CRingBuffer in the initialize method and destroy it in shutdown. These operations could just as easily be done in a constructor/destructor pair.

Having said this, the initialize and shutdown methods should be pretty easy to write:

void
CEVBRingClientApp::intialize()
{
    const char* pRingName = getenv("RINGURL");
    m_pRing = CRingAccess::daqConsumeFrom(std::string(pRingName));
}

void
CEVBRingClientApp::shutdown()
{
    delete m_pRing;
}
                

There should clearly be more error checking in initialize however these should also be pretty clear. initialize translates the RINGURL environment variable and opens a ring using using the URL in that environment variable.

The dataReady method is a bit tricky. We'd rather not burn the CPU by polling. What we'll here is first check to see if there's at least a ring header in the ring. If so, we return true if not, we block for the number of requested milliseconds and check again.

bool
CEVBRingClientApp::dataReady(int ms)
{
    if (haveHeader()) return true;
    usleep(ms*1000);
    return haveHeader();
}

// Added utility function:

bool
CEVBRingClientApp::haveHeader()
{
    return m_pRing->availableData() >= sizeof(RingItemHeader);
}
                

Note that we have invented a helper method that determines if there's at least a ring header worth of data in the ring for us.

For getEvents we will get the minimum of 100 events or until there is no more data left in the ring. The events will be bundled into a EventFragmentList and submitted to the event builder framework using the CEVBClientFramework::submitFragmentList. Note that each element of the list is a ClientEventFragment and contains:

See CEVBClientFramework for reference information on the framework API methods and data structures.

For simplicity we are not going to worry about the heterogeneous nature of ring items.

void
CEVBRingClientApp::getEvents()
{
    CEVBEventList events;              
    int           eventCount = 0;
    CAllButPredicate all;
    
    while(m_pRing->availableData()) {  
                                       
        CRingItem* pItem = CRingItem::getFromRing(*m_pRing, all);
        ClientEventFragment frag;
        frag.s_timestamp = getTimestamp(pItem);
        frag.s_sourceId  = 1;
        frag.s_size      = pItem->getItemPointer()->s_header.s_size;
        frag.s_payload   = pItem->getItemPointer();
        events.push_back(frag);
        
        eventCount++;                
        if (eventCount >= 100) break;
    }
    if (events.size()) {             
        CEVBClientFramework::submitFragmentList(events);
        
        while(!events.empty()) {    
            EventFragmentList fragment = events.front();
            CRingItem* pItem = reinterpret_cast<CRingItem*>(fragment.s_pPayload);
            delete pItem;
            events.pop_front();
        }
    }
}
                

Since getEvents is the most complicated method we've seen so far, lets break it down into its component pieces.