AliMUONTriggerDDLDecoder.h

Go to the documentation of this file.

#ifndef ALIMUONTRIGGERDDLDECODER_H
#define ALIMUONTRIGGERDDLDECODER_H
/**************************************************************************
 * This file is property of and copyright by the ALICE HLT Project        *
 * All rights reserved.                                                   *
 *                                                                        *
 * Primary Authors:                                                       *
 *   Artur Szostak <artursz@iafrica.com>                                  *
 *                                                                        *
 * Permission to use, copy, modify and distribute this software and its   *
 * documentation strictly for non-commercial purposes is hereby granted   *
 * without fee, provided that the above copyright notice appears in all   *
 * copies and that both the copyright notice and this permission notice   *
 * appear in the supporting documentation. The authors make no claims     *
 * about the suitability of this software for any purpose. It is          *
 * provided "as is" without express or implied warranty.                  *
 **************************************************************************/

/* $Id$ */


#include "AliMUONTriggerDDLDecoderEventHandler.h"

template <class EventHandler>
class AliMUONTriggerDDLDecoder
{
public:

  AliMUONTriggerDDLDecoder() :
    fExitOnError(true), fTryRecover(false),
    fAutoDetectScalars(false), fHadError(false),
    fNoRegionals(0), fMaxRegionals(8), fMaxLocals(16),
    fHandler()
  {}
  
  const EventHandler& GetHandler() const { return fHandler; }
  
  EventHandler& GetHandler() { return fHandler; }
  
  bool ExitOnError() const { return fExitOnError; }
  
  void ExitOnError(bool value) { fExitOnError = value; }
  
  bool TryRecover() const { return fTryRecover; }
  
  void TryRecover(bool value) { fTryRecover = value; }
  
  bool AutoDetectScalars() const { return fAutoDetectScalars; }
  
  void AutoDetectScalars(bool value) { fAutoDetectScalars = value; }
  
  UInt_t MaxRegionals() const { return fMaxRegionals; }
  
  void MaxRegionals(UInt_t n) { fMaxRegionals = n; }
  
  UInt_t RegionalsDecoded() const { return fNoRegionals; }
  
  UInt_t MaxLocals() const { return fMaxLocals; }
  
  void MaxLocals(UInt_t n) { fMaxLocals = n; }
  
  bool Decode(const void* buffer, UInt_t bufferSize, bool scalarEvent = false);
  
  static UInt_t EndOfDarcWord() { return fgkEndOfDarc; }
  
  static UInt_t EndOfGlobalWord() { return fgkEndOfGlobal; }
  
  static UInt_t EndOfRegionalWord() { return fgkEndOfReg; }
  
  static UInt_t RegionalErrorWord() { return fgkErrorWord; }
  
  static UInt_t EndOfLocalWord() { return fgkEndOfLocal; }
  
  static UInt_t LocalDisableWord() { return fgkDisableWord; }
  
  static UInt_t DarcDefaultType() { return fgkDarcDefaultType; }
  
  static UInt_t DarcVadorhType()  { return fgkDarcVadorhType; }
  
private:

  bool fExitOnError; 
  bool fTryRecover; 
  bool fAutoDetectScalars; 
  bool fHadError; 
  UInt_t fNoRegionals; 
  UInt_t fMaxRegionals; 
  UInt_t fMaxLocals; 
  EventHandler fHandler; 

  void DecodeBuffer(const UChar_t* start, const UChar_t* end, bool scalarEvent);
  void DecodeRegionalStructs(const UChar_t* start, const UChar_t* end, bool scalarEvent);
  const UChar_t* DecodeLocalStructs(const UChar_t* start, const UChar_t* end, bool scalarEvent);
  
  const UChar_t* FindKey(
      UInt_t key, const UChar_t* start, const UChar_t* end
    );

  static const UInt_t fgkEndOfDarc;   
  static const UInt_t fgkEndOfGlobal; 
  static const UInt_t fgkEndOfReg;    
  static const UInt_t fgkErrorWord;   
  static const UInt_t fgkEndOfLocal;  
  static const UInt_t fgkDisableWord; 
  static const UInt_t fgkDarcDefaultType;   
  static const UInt_t fgkDarcVadorhType;    
};

//_____________________________________________________________________________

// The following are the structure key words which are used to demarcate (identify
// the end) of the structures within the raw trigger data.
template <class EventHandler>
const UInt_t AliMUONTriggerDDLDecoder<EventHandler>::fgkEndOfDarc    = 0xDEADFACE;
template <class EventHandler>
const UInt_t AliMUONTriggerDDLDecoder<EventHandler>::fgkEndOfGlobal  = 0xDEADBEEF;
template <class EventHandler>
const UInt_t AliMUONTriggerDDLDecoder<EventHandler>::fgkEndOfReg     = 0xBEEFFACE;
template <class EventHandler>
const UInt_t AliMUONTriggerDDLDecoder<EventHandler>::fgkErrorWord    = 0xCAFEDEAD;
template <class EventHandler>
const UInt_t AliMUONTriggerDDLDecoder<EventHandler>::fgkEndOfLocal   = 0xCAFEFADE;
template <class EventHandler>
const UInt_t AliMUONTriggerDDLDecoder<EventHandler>::fgkDisableWord  = 0x10CADEAD;
template <class EventHandler>
const UInt_t AliMUONTriggerDDLDecoder<EventHandler>::fgkDarcDefaultType = 0x6;
template <class EventHandler>
const UInt_t AliMUONTriggerDDLDecoder<EventHandler>::fgkDarcVadorhType  = 0x4;


template <class EventHandler>
bool AliMUONTriggerDDLDecoder<EventHandler>::Decode(
    const void* buffer, UInt_t bufferSize, bool scalarEvent
  )
{
  
  assert( buffer != NULL );
  
  fHadError = false;
  
  // We are basically implementing something like a recursive decent parser.
  // So start by marking the start of buffer position and end of buffer.
  const UChar_t* start = reinterpret_cast<const UChar_t*>(buffer);
  const UChar_t* end = start + bufferSize;
  
  fHandler.OnNewBuffer(buffer, bufferSize);
  DecodeBuffer(start, end, scalarEvent);
  fHandler.OnEndOfBuffer(buffer, bufferSize);
  return not fHadError;
}


template <class EventHandler>
void AliMUONTriggerDDLDecoder<EventHandler>::DecodeBuffer(
    const UChar_t* start, const UChar_t* end, bool scalarEvent
  )
{
  
  const UChar_t* current = start;
  
  // Mark the DARC header, but check that we do not overrun the buffer.
  const UInt_t* darcHeader = reinterpret_cast<const UInt_t*>(current);
  current += sizeof(UInt_t);
  if (current > end or current < start)
  {
    // Indicate we had an error and stop the decoding because we
    // hit the end of the buffer already.
    fHandler.OnError(EventHandler::kNoDarcHeader, darcHeader);
    fHadError = true;
    return;
  }
  
  // Check if we need to figure out if this is a scalar event.
  // If we do, then we do this by checking the event type in the DARC header
  // and double checking this by checking if the fgkEndOfDarc key is in the
  // expected location for a scalar event DDL payload.
  if (fAutoDetectScalars)
  {
    const UInt_t* expectedEndOfDarc = reinterpret_cast<const UInt_t*>(
        current + sizeof(AliMUONDarcScalarsStruct)
      );
    
    // First make sure not to read past the end of buffer. Then check
    // the value of the event type in the DARC header.
    // Physics events are indicated by the two trigger bits of the
    // DARC header set to 01b. Everything else is a software trigger
    // of some sort.
    if (reinterpret_cast<const UChar_t*>(expectedEndOfDarc+1) <= end and
        reinterpret_cast<const UChar_t*>(expectedEndOfDarc+1) > start and
        EventHandler::GetDarcEventType(*darcHeader) != 0x1
        and *expectedEndOfDarc == fgkEndOfDarc
       )
    {
      scalarEvent = true;
    }
    else
    {
      scalarEvent = false;
    }
  }
  
  // Detect how many regional blocks we expect. If we have no idea then
  // just use what the maximum setting is.
  UInt_t darkType = EventHandler::GetDarcType(*darcHeader);
  if (darkType == fgkDarcVadorhType)
  {
    fNoRegionals = 1;
  }
  else if (darkType == fgkDarcDefaultType)
  {
    fNoRegionals = 8;
  }
  else
  {
    fNoRegionals = fMaxRegionals;
  }
  
  // Check if the DARC header indicates we expect more regionals than we
  // are allowed to decode according to our max regional structures count.
  // If we do then this is an error and we should indicate it and exit
  // if so requested by the user. Also we can fix the number of regionals
  // to expect if we are trying to recover from errors.
  if (fNoRegionals > fMaxRegionals)
  {
    fHandler.OnError(EventHandler::kTooManyRegionals, darcHeader);
    fHadError = true;
    if (fExitOnError) return;
    if (fTryRecover)
    {
      fNoRegionals = fMaxRegionals;
    }
  }
  
  // Check that the DARC header indicates correctly if we are a scalar event or not.
  bool darcShowsScalar = (EventHandler::GetDarcEventType(*darcHeader) != 0x1);
  if (darcShowsScalar != scalarEvent)
  {
    // Indicate we had an error and stop the decoding if so requested
    // by the user.
    fHandler.OnError(EventHandler::kWrongEventType, darcHeader);
    fHadError = true;
    if (fExitOnError) return;
  }
  
  // Decode the DARC scalars if this is a scalar event.
  const AliMUONDarcScalarsStruct* darcScalars = NULL;
  if (scalarEvent)
  {
    darcScalars = reinterpret_cast<const AliMUONDarcScalarsStruct*>(current);
    current += sizeof(AliMUONDarcScalarsStruct);
    if (current > end or current < start)
    {
      // If we overflowed the pointer and already had an error then
      // we are clearly lost so just stop decoding before we segfault.
      if (current < start and fHadError) return;
      
      // Indicate we had an error and stop the decoding because we
      // hit the end of the buffer already.
      fHandler.OnError(EventHandler::kNoDarcScalars, darcScalars);
      fHadError = true;
      return;
    }
  }
  
  // Now check that the end of DARC header marker is OK.
  const UInt_t* endOfDarc = reinterpret_cast<const UInt_t*>(current);
  current += sizeof(UInt_t);
  if (current > end or current < start)
  {
    // If we overflowed the pointer and already had an error then
    // we are clearly lost so just stop decoding before we segfault.
    if (current < start and fHadError) return;
    
    // Indicate we had an error and stop the decoding because we
    // hit the end of the buffer already.
    fHandler.OnError(EventHandler::kNoEndOfDarc, endOfDarc);
    fHadError = true;
    return;
  }
  if (*endOfDarc != fgkEndOfDarc)
  {
    // Indicate we had an error and stop the decoding if so requested
    // by the user.
    fHandler.OnError(EventHandler::kBadEndOfDarc, endOfDarc);
    fHadError = true;
    if (fExitOnError) return;
    
    // If the user requested for us to try and recover from structure
    // errors then we need to try locate the key in the data stream
    // and continue decoding from there.
    if (fTryRecover)
    {
      const UChar_t* keypos = FindKey(fgkEndOfDarc,
          reinterpret_cast<const UChar_t*>(darcHeader),
          end
        );
      if (keypos != NULL)
      {
        // remember to continue decoding just past the key.
        current = keypos + sizeof(UInt_t);
      }
    }
  }
  
  fHandler.OnDarcHeader(*darcHeader, darcScalars, current);
  
  // Next, we mark the Global header and check that we do not overrun the buffer.
  const AliMUONGlobalHeaderStruct* globalHeader =
    reinterpret_cast<const AliMUONGlobalHeaderStruct*>(current);
  current += sizeof(AliMUONGlobalHeaderStruct);
  if (current > end or current < start)
  {
    // If we overflowed the pointer and already had an error then
    // we are clearly lost so just stop decoding before we segfault.
    if (current < start and fHadError) return;
    
    // Indicate we had an error and stop the decoding because we
    // hit the end of the buffer already.
    fHandler.OnError(EventHandler::kNoGlobalHeader, globalHeader);
    fHadError = true;
    return;
  }
  
  // Decode the global scalars if this is a scalar event.
  const AliMUONGlobalScalarsStruct* globalScalars = NULL;
  if (scalarEvent)
  {
    globalScalars = reinterpret_cast<const AliMUONGlobalScalarsStruct*>(current);
    current += sizeof(AliMUONGlobalScalarsStruct);
    if (current > end or current < start)
    {
      // If we overflowed the pointer and already had an error then
      // we are clearly lost so just stop decoding before we segfault.
      if (current < start and fHadError) return;
      
      // Indicate we had an error and stop the decoding because we
      // hit the end of the buffer already.
      fHandler.OnError(EventHandler::kNoGlobalScalars, globalScalars);
      fHadError = true;
      return;
    }
  }
  
  // Now check that the end of global header marker is OK.
  const UInt_t* endOfGlobal = reinterpret_cast<const UInt_t*>(current);
  current += sizeof(UInt_t);
  if (current > end or current < start)
  {
    // If we overflowed the pointer and already had an error then
    // we are clearly lost so just stop decoding before we segfault.
    if (current < start and fHadError) return;
    
    // Indicate we had an error and stop the decoding because we
    // hit the end of the buffer already.
    fHandler.OnError(EventHandler::kNoEndOfGlobal, endOfGlobal);
    fHadError = true;
    return;
  }
  if (*endOfGlobal != fgkEndOfGlobal)
  {
    // Indicate we had an error and stop the decoding if so requested
    // by the user.
    fHandler.OnError(EventHandler::kBadEndOfGlobal, endOfGlobal);
    fHadError = true;
    if (fExitOnError) return;
    
    // If the user requested for us to try and recover from structure
    // errors then we need to try locate the key in the data stream
    // and continue decoding from there.
    if (fTryRecover)
    {
      const UChar_t* keypos = FindKey(fgkEndOfGlobal,
          reinterpret_cast<const UChar_t*>(globalHeader),
          end
        );
      if (keypos != NULL)
      {
        // remember to continue decoding just past the key.
        current = keypos + sizeof(UInt_t);
      }
    }
  }
  
  fHandler.OnGlobalHeader(globalHeader, globalScalars, current);
  
  DecodeRegionalStructs(current, end, scalarEvent);
}


template <class EventHandler>
void AliMUONTriggerDDLDecoder<EventHandler>::DecodeRegionalStructs(
    const UChar_t* start, const UChar_t* end, bool scalarEvent
  )
{
  
  const UChar_t* current = start;
  
  for (UInt_t iReg = 0; iReg < fNoRegionals; iReg++)
  {
    const AliMUONRegionalHeaderStruct* regionalHeader =
      reinterpret_cast<const AliMUONRegionalHeaderStruct*>(current);
    current += sizeof(AliMUONRegionalHeaderStruct);
    
    if (current > end or current < start)
    {
      // If we overflowed the pointer and already had an error then
      // we are clearly lost so just stop decoding before we segfault.
      if (current < start and fHadError) return;
      
      // So we only got part of a regional header, nothing to do but
      // report the error and exit.
      fHandler.OnError(EventHandler::kNoRegionalHeader, regionalHeader);
      fHadError = true;
      return;
    }
    
    // Skip empty regional board (not connected or with error reading).
    if (regionalHeader->fDarcWord == fgkErrorWord)
    {
      //current += sizeof(AliMUONRegionalHeaderStruct);  // already done above
      if (scalarEvent)
        current += sizeof(AliMUONRegionalScalarsStruct);
      current += sizeof(UInt_t); // skip the end of regional structure key.
      
      // now also skip the local structure part:
      current += fMaxLocals * sizeof(AliMUONLocalInfoStruct);
      if (scalarEvent)
        current += fMaxLocals * sizeof(AliMUONLocalScalarsStruct);
      current += fMaxLocals * sizeof(UInt_t); // skip all the end of local structure keys.
      
      continue;
    }
    
    // Decode the regional scalar words if this is a scalar event.
    const AliMUONRegionalScalarsStruct* regionalScalars = NULL;
    if (scalarEvent)
    {
      regionalScalars = reinterpret_cast<const AliMUONRegionalScalarsStruct*>(current);
      current += sizeof(AliMUONRegionalScalarsStruct);
      if (current > end or current < start)
      {
        // If we overflowed the pointer and already had an error then
        // we are clearly lost so just stop decoding before we segfault.
        if (current < start and fHadError) return;
        
        // Indicate we had an error and stop the decoding because we
        // hit the end of the buffer already.
        fHandler.OnError(EventHandler::kNoRegionalScalars, regionalScalars);
        fHadError = true;
        return;
      }
    }
    
    // Now check that the end of regional header marker is OK.
    const UInt_t* endOfRegional = reinterpret_cast<const UInt_t*>(current);
    current += sizeof(UInt_t);
    if (current > end or current < start)
    {
      // If we overflowed the pointer and already had an error then
      // we are clearly lost so just stop decoding before we segfault.
      if (current < start and fHadError) return;
      
      // Indicate we had an error and stop the decoding because we
      // hit the end of the buffer already.
      fHandler.OnError(EventHandler::kNoEndOfRegional, endOfRegional);
      fHadError = true;
      return;
    }
    if (*endOfRegional != fgkEndOfReg)
    {
      // Indicate we had an error and stop the decoding if so requested
      // by the user.
      fHandler.OnError(EventHandler::kBadEndOfRegional, endOfRegional);
      fHadError = true;
      if (fExitOnError) return;
      
      // If the user requested for us to try and recover from structure
      // errors then we need to try locate the key in the data stream
      // and continue decoding from there.
      if (fTryRecover)
      {
        const UChar_t* keypos = FindKey(fgkEndOfReg,
            reinterpret_cast<const UChar_t*>(regionalHeader),
            end
          );
        
        // If the fgkEndOfReg key was found exactly one regional
        // structure later then we should not adjust the current
        // decoding position because it is more likely that the
        // end of regional structure key was just corrupt rather
        // than offset.
        // If we could not find another good key then just continue.
        size_t sizeOfRegional = sizeof(AliMUONRegionalHeaderStruct) + sizeof(UInt_t)
          + fMaxLocals * (sizeof(AliMUONLocalInfoStruct) + sizeof(UInt_t));
        if (scalarEvent)
        {
          sizeOfRegional += sizeof(AliMUONRegionalScalarsStruct)
            + fMaxLocals * sizeof(AliMUONLocalScalarsStruct);
        }
        
        if (keypos != NULL and keypos != current + sizeOfRegional)
        {
          current = keypos + sizeof(UInt_t);
        }
      }
    }
    
    // Tell the handler that we have a new regional block and decode it.
    // When done, tell the handler again.
    // We call both versions of OnNewRegionalStruct so that user event
    // handlers can implement the one they prefer to use.
    const UChar_t* startOfLocals = current;
    fHandler.OnNewRegionalStruct(regionalHeader, regionalScalars, startOfLocals);
    fHandler.OnNewRegionalStructV2(iReg, regionalHeader, regionalScalars, startOfLocals);
    current = DecodeLocalStructs(current, end, scalarEvent);
    fHandler.OnEndOfRegionalStruct(regionalHeader, regionalScalars, startOfLocals);
    fHandler.OnEndOfRegionalStructV2(iReg, regionalHeader, regionalScalars, startOfLocals);
  }
  
  // Now just check that there is no extra rubbish at the end of the DDL.
  if (current != end)
  {
    fHandler.OnError(EventHandler::kBufferTooBig, current);
    fHadError = true;
  }
}


template <class EventHandler>
const UChar_t* AliMUONTriggerDDLDecoder<EventHandler>::DecodeLocalStructs(
    const UChar_t* start, const UChar_t* end, bool scalarEvent
  )
{
  
  const UChar_t* current = start;
  
  for (UInt_t iLocal = 0; iLocal < fMaxLocals; iLocal++)
  {
    const AliMUONLocalInfoStruct* localStruct =
      reinterpret_cast<const AliMUONLocalInfoStruct*>(current);
    current += sizeof(AliMUONLocalInfoStruct);
    
    if (current > end or current < start)
    {
      // If we overflowed the pointer and already had an error then
      // we are clearly lost so just stop decoding before we segfault.
      if (current < start and fHadError) return end;
      
      // So we only got part of a local structure, nothing to do but
      // report the error and exit.
      fHandler.OnError(EventHandler::kNoLocalStruct, localStruct);
      fHadError = true;
      return end;
    }
    
    // Skip empty local board if card not notified.
    if (localStruct->fX2X1 == fgkDisableWord and
        localStruct->fX4X3 == fgkDisableWord and
        localStruct->fY2Y1 == fgkDisableWord and
        localStruct->fY4Y3 == fgkDisableWord and
        localStruct->fTriggerBits == fgkDisableWord
       )
    {
      //current += sizeof(AliMUONLocalInfoStruct); // already done above
      if (scalarEvent)
        current += sizeof(AliMUONLocalScalarsStruct);
      current += sizeof(UInt_t); // skip the end of local structure key.
      continue;
    }
    
    // Decode the regional scalar words if this is a scalar event.
    const AliMUONLocalScalarsStruct* localScalars = NULL;
    if (scalarEvent)
    {
      localScalars = reinterpret_cast<const AliMUONLocalScalarsStruct*>(current);
      current += sizeof(AliMUONLocalScalarsStruct);
      if (current > end or current < start)
      {
        // If we overflowed the pointer and already had an error then
        // we are clearly lost so just stop decoding before we segfault.
        if (current < start and fHadError) return end;
        
        // Indicate we had an error and stop the decoding because we
        // hit the end of the buffer already.
        fHandler.OnError(EventHandler::kNoLocalScalars, localScalars);
        fHadError = true;
        return end;
      }
    }
    
    // Now check that the end of regional header marker is OK.
    const UInt_t* endOfLocal = reinterpret_cast<const UInt_t*>(current);
    current += sizeof(UInt_t);
    if (current > end or current < start)
    {
      // If we overflowed the pointer and already had an error then
      // we are clearly lost so just stop decoding before we segfault.
      if (current < start and fHadError) return end;
      
      // Indicate we had an error and stop the decoding because we
      // hit the end of the buffer already. We can however signal that
      // we got a local structure, because the buffer contains enough
      // data to potencially contain the real data of the structure.
      fHandler.OnError(EventHandler::kNoEndOfLocal, endOfLocal);
      if (not fExitOnError)
      {
        fHandler.OnLocalStruct(localStruct, localScalars);
      }
      fHadError = true;
      return end;
    }
    if (*endOfLocal != fgkEndOfLocal)
    {
      // Indicate we had an error and stop the decoding if so requested
      // by the user.
      fHandler.OnError(EventHandler::kBadEndOfLocal, endOfLocal);
      fHadError = true;
      if (fExitOnError) return current;
      
      // If the user requested for us to try and recover from structure
      // errors then we need to try locate the key in the data stream
      // and continue decoding from there.
      if (fTryRecover)
      {
        const UChar_t* searchPos = reinterpret_cast<const UChar_t*>(localStruct);
        const UChar_t* firstLocalKey = FindKey(fgkEndOfLocal, searchPos, end);
        const UChar_t* firstRegionalKey = FindKey(fgkEndOfReg, searchPos, end);
        
        // If a regional key was found first, then give up on
        // anymore local structures from this regional block and
        // continue decoding from the next regional block.
        // Also if the fgkEndOfLocal key was found exactly one
        // local structure later then we should not adjust the
        // current decoding position because it is more likely that
        // the end of local structure key was just corrupt rather
        // than offset.
        if (firstLocalKey != NULL and firstRegionalKey != NULL)
        {
          if (firstLocalKey < firstRegionalKey)
          {
            size_t sizeOflocalStruct = sizeof(AliMUONLocalInfoStruct) + sizeof(UInt_t);
            if (scalarEvent)
              sizeOflocalStruct += sizeof(AliMUONLocalScalarsStruct);
            
            if (firstLocalKey != current + sizeOflocalStruct)
              current = firstLocalKey + sizeof(UInt_t);
          }
          else
          {
            // Adjust back to the start of the regional header.
            current = firstRegionalKey - sizeof(AliMUONRegionalHeaderStruct);
            if (scalarEvent)
              current -= sizeof(AliMUONRegionalScalarsStruct);
            break;
          }
        }
        
        // If we could not find another good key then just continue.
      }
    }
    
    // Call both handlers for local structures so that the user decoder event
    // handler class can implement the one it prefers to use.
    fHandler.OnLocalStruct(localStruct, localScalars);
    fHandler.OnLocalStructV2(iLocal, localStruct, localScalars);
  }
  
  return current;
}


template <class EventHandler>
const UChar_t* AliMUONTriggerDDLDecoder<EventHandler>::FindKey(
    UInt_t key, const UChar_t* start, const UChar_t* end
  )
{
 
  if (end + sizeof(UInt_t) < start) return NULL;  // check for pointer overflow.
  const UChar_t* current = start;
  while (current + sizeof(UInt_t) <= end)
  {
    UInt_t data = * reinterpret_cast<const UInt_t*>(current);
    if (data == key) return current;
    current++;
  }
  return NULL;
}

#endif // ALIMUONTRIGGERDDLDECODER_H