AddressTable Class Reference

#include <AddressTable.hh>

Collaboration diagram for AddressTable:

Public Member Functions
	AddressTable (std::string const &addressTableName, std::string const &deviceAddress, uint16_t offset)
uint32_t	Read (uint16_t)
uint32_t	Read (std::string registerName)
uint32_t	ReadWithRetry (uint16_t)
uint32_t	ReadWithRetry (std::string registerName)
void	Write (uint16_t, uint32_t)
void	Write (std::string registerName, uint32_t val)
void	WriteWithRetry (uint16_t, uint32_t)
void	WriteWithRetry (std::string registerName, uint32_t val)
void	Write (uint16_t, std::vector< uint32_t > const &values)
void	Write (std::string registerName, std::vector< uint32_t > const &values)
void	Write (uint16_t, uint32_t const *values, size_t word_count)
void	Write (std::string registerName, uint32_t const *values, size_t word_count)
Item const *	GetItem (std::string const &)
std::vector< Item const * >	GetTagged (std::string const &tag)
std::vector< std::string >	GetNames ()
std::vector< std::string >	GetNames (std::string const &regex)
std::vector< std::string >	GetAddresses (uint16_t lower, uint16_t upper)
std::string	GetRemoteAddress ()
std::vector< std::string >	GetTables (std::string const &regex)
uint64_t	GetRetryCount ()

Private Member Functions
	AddressTable ()
	AddressTable (const AddressTable &)
AddressTable &	operator= (const AddressTable &)
void	LoadFile (std::string const &, std::string const &prefix="", uint16_t offset=0)
void	ProcessLine (std::string const &, size_t, std::string const &prefix="", uint16_t offset=0)
void	AddEntry (Item *)

Private Attributes
int	fileLevel
std::map< uint32_t, std::vector< Item * > >	addressItemMap
std::map< std::string, Item * >	nameItemMap
BNL_UDP *	io

Detailed Description

Definition at line 26 of file AddressTable.hh.

Constructor & Destructor Documentation

AddressTable() [1/3]

AddressTable::AddressTable	(	std::string const &	addressTableName,
		std::string const &	deviceAddress,
		uint16_t	offset )

Definition at line 9 of file AddressTable.cpp.

{
  fileLevel = 0;
  io = new BNL_UDP;
  io->Setup(deviceAddress, offset);
  io->SetWriteAck(true);
  LoadFile(addressTableName);
}

AddressTable() [2/3]

AddressTable::AddressTable ( )

private

AddressTable() [3/3]

AddressTable::AddressTable ( const AddressTable & )

private

Member Function Documentation

AddEntry()

void AddressTable::AddEntry ( Item * item )

private

Definition at line 27 of file AddressTable_item.cpp.

{
  // Check for null item
  if (item == NULL) {
    BUException::NULL_POINTER e;
    e.Append("Null Item pointer passed to AddEntry\n");
    throw e;
  }
  // Check for invalid Mode
  if ((item->mode & Item::WRITE) && (item->mode & Item::ACTION)) {
    BUException::BAD_MODE e;
    e.Append("AddEntry called with both WRITE and ACTION modes\n");
    throw e;
  }
 
  // This function now owns the memory at item
 
  // Add the item to the address map and check that it doesn't conflict with
  std::map<uint32_t, std::vector<Item*>>::iterator itAddressItem = addressItemMap.find(item->address);
  if (itAddressItem == addressItemMap.end()) {
    // This is the first entry at this address.
    // Create the entry in addressItemMap and then push_back with our item.
    addressItemMap[item->address].push_back(item);
    // Update the iterator to the newly inserted item
    itAddressItem = addressItemMap.find(item->address);
  } else {
    std::vector<Item*>& addressItems = itAddressItem->second;
    // Check each entry for an overlap in masks.  This is only ok if one is a subset, via it's name, of the other
    for (size_t iItem = 0; iItem < addressItems.size(); iItem++) {
      if (addressItems[iItem]->mask & item->mask) {
        // free for all now
 
        // These items overlap in mask
        // CHeck that one or the other contains the other starting at pos 0.
        // in other words, that they are the same up until the end of the shorter one
        //  if( (addressItems[iItem]->name.find(item->name) != 0) &&
        //      (item->name.find(addressItems[iItem]->name) != 0) ) {
        //    BUException::BAD_MODE e;
        //    e.Append("Entry: ");
        //    e.Append(item->name.c_str());
        //    e.Append(" conflicts with entry ");
        //    e.Append(addressItems[iItem]->name.c_str());
        //    e.Append("\n");
        //    throw e;
        //  }
      }
    }
    addressItems.push_back(item);
  }
 
  // Add the item to the list of addresses
  std::map<std::string, Item*>::iterator itNameItem = nameItemMap.find(item->name);
  if (itNameItem == nameItemMap.end()) {
    // Add this entry and everything is good.
    nameItemMap[item->name] = item;
  } else {
    // There was a collision in entry name, remote the newly added element and throw an exception
 
    // delete the addition to the vector
    std::vector<Item*>& addressItems = itAddressItem->second;
    for (size_t iItem = 0; iItem < addressItems.size(); iItem++) {
      if (addressItems[iItem] == item) {
        // Found what we just added, removing
        addressItems.erase(addressItems.begin() + iItem);
      }
    }
    // throw exception about collission
    BUException::NAME_COLLISION e;
    e.Append("Item ");
    e.Append(item->name.c_str());
    e.Append(" already existed\n");
 
    // delete the item
    delete item;
 
    throw e;
  }
 
  // Create Slow Control ItemConversion for this item
 
  item->sc_conv = (ItemConversion*)0x0;
 
  if (item->user.count(SC_key_conv)) {
    std::string convstring = item->user.at(SC_key_conv);
    item->sc_conv = ItemConversion::FromString(convstring);
    if (!item->sc_conv) {
      fprintf(stderr, "Warning: Unknown item conversion \"%s\"\n", convstring.c_str());
      item->sc_conv = ItemConversion::FromString("pass");
    }
  } else {
    item->sc_conv = ItemConversion::FromString("pass");
  }
 
  // Everything is good, we've added it
}

GetAddresses()

std::vector< std::string > AddressTable::GetAddresses	(	uint16_t	lower,
		uint16_t	upper )

Definition at line 66 of file AddressTable_search.cpp.

{
  std::vector<std::string> names;
  // Get an iterator into our map of addresses to vectors of items that is the first entry that is not less than lower
  std::map<uint32_t, std::vector<Item*>>::iterator itAddress = addressItemMap.lower_bound(lower);
  for (; itAddress != addressItemMap.end(); itAddress++) {
    // loop over all following address keys
 
    if (itAddress->first < upper) {
      // Address key is less than uppper, so add its entries to names
      std::vector<Item*>& items = itAddress->second;
      for (size_t iItem = 0; iItem < items.size(); iItem++) {
        names.push_back(items[iItem]->name);
      }
    } else {
      // address key is greater than or equal to upper, so stop
      break;
    }
  }
  return names;
}

GetItem()

Item const * AddressTable::GetItem

(

std::string const &

registerName

)

Definition at line 12 of file AddressTable_item.cpp.

{
  std::map<std::string, Item*>::iterator itNameItem = nameItemMap.find(registerName);
  if (itNameItem == nameItemMap.end()) {
    BUException::INVALID_NAME e;
    e.Append("Can't find item with name \"");
    e.Append(registerName.c_str());
    e.Append("\"");
    throw e;
  }
  Item* item = itNameItem->second;
  return item;
}

GetNames() [1/2]

std::vector< std::string > AddressTable::GetNames

(

)

Definition at line 10 of file AddressTable_search.cpp.

{
  std::vector<std::string> names;
  for (std::map<std::string, Item*>::iterator it = nameItemMap.begin(); it != nameItemMap.end(); it++) {
    names.push_back(it->first);
  }
  return names;
}

GetNames() [2/2]

std::vector< std::string > AddressTable::GetNames

(

std::string const &

regex

)

Definition at line 29 of file AddressTable_search.cpp.

{
  std::vector<std::string> names;
  // Fix regex
  std::string rx = regex;
  std::transform(rx.begin(), rx.end(), rx.begin(), ::toupper);
  if (rx.size() > 6 && rx.substr(0, 5) == "PERL:") {
    printf("Using PERL-style regex unchanged\n");
    rx = rx.substr(5);
  } else {
    ReplaceStringInPlace(rx, ".", "#");
    ReplaceStringInPlace(rx, "*", ".*");
    ReplaceStringInPlace(rx, "#", "\\.");
  }
 
  // Create regex match
  boost::regex re;
  try {
    re = boost::regex(rx);
  } catch (std::exception& e) {
    BUException::BAD_REGEX e2;
    e2.Append("In GetNames: (");
    e2.Append(rx.c_str());
    e2.Append(") ");
    e2.Append(regex.c_str());
    throw e2;
  }
  boost::cmatch match;
  for (std::map<std::string, Item*>::iterator it = nameItemMap.begin(); it != nameItemMap.end(); it++) {
    if (regex_match(it->first.c_str(), match, re)) {
      names.push_back(it->first);
    }
  }
  return names;
}

GetRemoteAddress()

std::string AddressTable::GetRemoteAddress ( )

inline

Definition at line 46 of file AddressTable.hh.

{return io->GetAddress();};

GetRetryCount()

uint64_t AddressTable::GetRetryCount ( )

inline

Definition at line 48 of file AddressTable.hh.

{return io->GetRetryCount();};

GetTables()

std::vector< std::string > AddressTable::GetTables

(

std::string const &

regex

)

Definition at line 89 of file AddressTable_search.cpp.

{
 
  // Fix regex
  std::string rx = regex;
  //  std::transform( rx.begin(), rx.end(), rx.begin(), ::toupper);
  if (rx.size() > 6 && rx.substr(0, 5) == "PERL:") {
    printf("Using PERL-style regex unchanged\n");
    rx = rx.substr(5);
  } else {
    ReplaceStringInPlace(rx, ".", "#");
    ReplaceStringInPlace(rx, "*", ".*");
    ReplaceStringInPlace(rx, "#", "\\.");
  }
 
  // Create regex match
  boost::regex re;
  try {
    re = boost::regex(rx);
  } catch (std::exception& e) {
    BUException::BAD_REGEX e2;
    e2.Append("In GetTables: (");
    e2.Append(rx.c_str());
    e2.Append(") ");
    e2.Append(regex.c_str());
    throw e2;
  }
  std::set<std::string> tableSearch;
  boost::cmatch match;
  for (std::map<std::string, Item*>::iterator it = nameItemMap.begin(); it != nameItemMap.end(); it++) {
    // Check if this item has a table entry
    if (it->second->user.find("Table") != it->second->user.end()) {
      std::string const& tableName = it->second->user.find("Table")->second;
      // check if this table isn't already in the set
      if (tableSearch.find(tableName) == tableSearch.end()) {
        // Check if we should add it
        if (regex_match(tableName.c_str(), match, re)) {
          // Add this table to the set
          tableSearch.insert(tableName);
        }
      }
    }
  }
  std::vector<std::string> tables(tableSearch.begin(), tableSearch.end());
  return tables;
}

GetTagged()

std::vector< const Item * > AddressTable::GetTagged

(

std::string const &

tag

)

Definition at line 137 of file AddressTable_search.cpp.

{
  std::vector<const Item*> matches;
  for (std::map<std::string, Item*>::iterator it = nameItemMap.begin(); it != nameItemMap.end(); it++) {
    // Check if this item has the tag as an entry
    if (it->second->user.find(tag) != it->second->user.end()) {
      matches.push_back(it->second);
    }
  }
  return matches;
}

LoadFile()

void AddressTable::LoadFile ( std::string const & fileName, std::string const & prefix = "", uint16_t offset = 0 )

private

Definition at line 12 of file AddressTable_fileIO.cpp.

{
 
  std::ifstream inFile(fileName.c_str());
  if (!inFile.is_open()) {
    std::string envBasedFileName = fileName;
    // Try to use address table path if it exists
    if (getenv("WIBMOD_SHARE") != NULL) {
      envBasedFileName = getenv("WIBMOD_SHARE");
      envBasedFileName += "/config/WIB1/tables/";
      envBasedFileName += fileName;
      inFile.open(envBasedFileName.c_str());
    }
    if (!inFile.is_open()) {
      BUException::BAD_FILE e;
      e.Append("File not found: ");
      e.Append(envBasedFileName.c_str());
      throw e;
    }
  }
  const size_t bufferSize = 1000;
  char buffer[bufferSize + 1];
  memset(buffer, 0, bufferSize + 1);
  uint32_t lineNumber = 1;
  while (!inFile.eof()) {
    inFile.getline(buffer, bufferSize);
    ProcessLine(std::string(buffer), lineNumber, prefix, offset);
    lineNumber++;
  }
}

operator=()

AddressTable & AddressTable::operator= ( const AddressTable & )

private

ProcessLine()

void AddressTable::ProcessLine ( std::string const & line, size_t lineNumber, std::string const & prefix = "", uint16_t offset = 0 )

private

Definition at line 44 of file AddressTable_fileIO.cpp.

{
  // First, ignore commments
  std::string activeLine = line.substr(0, line.find('#'));
 
  // Tokenize the activeLine
  boost::char_separator<char> sep(" ");
  boost::tokenizer<boost::char_separator<char>> tokens(activeLine, sep);
  boost::tokenizer<boost::char_separator<char>>::iterator itToken = tokens.begin();
 
  // crate a new Item;
  Item* item = new Item;
  size_t iToken = 0;
  for (; itToken != tokens.end(); itToken++) {
    switch (iToken) {
      case 0: { // keep name out of everyone else's scope
        // Assign name
 
        std::string name(*itToken);
        if (!prefix.empty()) {
          // we have a prefix to add on to the name
          name = prefix + std::string(".") + name;
        }
 
        while ((name.size() > 0) && ('.' == name[name.size() - 1])) {
          // If the trailing entry is a dot (level marker) drop it as this entry just means the prefix
          name.erase(name.size() - 1);
        }
 
        if (name.size() == 0) {
          // We have an emtpy name, this is bad and we should throw
          BUException::INVALID_NAME e;
          e.Append("Empty name");
          throw e;
        }
 
        boost::to_upper(name);
 
        // Assign the name to this item
        item->name.assign(name);
        iToken++;
      } break;
      case 1:
        // Assign address and apply any offset
        // itToken means we don't have to check for size of string
        item->address = strtoul(itToken->c_str(), NULL, 0) + offset;
        iToken++;
        break;
      case 2:
 
        // Check if this is an include line
        if (!isdigit((itToken->c_str()[0]))) {
          // we have an include file, append all following tokens together to use as the filename.
          std::string filename(*itToken);
          itToken++;
          while (itToken != tokens.end()) {
            filename += " ";
            filename += *itToken;
            itToken++;
          }
          fileLevel++;
          if (fileLevel <= MAX_FILE_LEVEL) {
            LoadFile(filename, item->name, item->address);
          } else {
            BUException::MAX_INCLUDE_FILE_DEPTH e;
            e.Append("File: ");
            e.Append(filename);
            e.Append(" at prefix ");
            e.Append(item->name);
            e.Append(" is too deep\n");
            throw e;
          }
          fileLevel--;
          // Delete fake partial item
          delete item;
          // return to move on to the next line of the main file
          return;
        }
 
        // Assign mask
        item->mask = strtoul(itToken->c_str(), NULL, 0);
        // stolen from https://graphics.stanford.edu/~seander/bithacks.html#ZerosOnRightParallel
        // Find the bitshift offset
        {
          unsigned int v = item->mask; // 32-bit word input to count zero bits on right
          unsigned int c = 32;         // c will be the number of zero bits on the right
          v &= -signed(v);
          if (v) {
            c--;
          }
          if (v & 0x0000FFFF) {
            c -= 16;
          }
          if (v & 0x00FF00FF) {
            c -= 8;
          }
          if (v & 0x0F0F0F0F) {
            c -= 4;
          }
          if (v & 0x33333333) {
            c -= 2;
          }
          if (v & 0x55555555) {
            c -= 1;
          }
          item->offset = c;
        }
 
        iToken++;
        break;
      case 3:
        // Assign mode
        item->mode = 0;
 
        // Read
        if (itToken->find('r') != std::string::npos) {
          item->mode |= Item::READ;
        } else if (itToken->find('R') != std::string::npos) {
          item->mode |= Item::READ;
        }
 
        // Write
        if (itToken->find('w') != std::string::npos) {
          item->mode |= Item::WRITE;
        } else if (itToken->find('W') != std::string::npos) {
          item->mode |= Item::WRITE;
        }
 
        // Action
        if (itToken->find('a') != std::string::npos) {
          item->mode |= Item::ACTION;
        } else if (itToken->find('A') != std::string::npos) {
          item->mode |= Item::ACTION;
        }
 
        iToken++;
        break;
      default:
        // parse user arguments
        // repeated arguments will be over-written
 
        // Find if this is an argument or a flag, flags have no equal signs
        if (itToken->find('=') == std::string::npos) {
          // Create an entry for this with no data
          item->user[*itToken];
          iToken++;
        } else {
          // Get the name of the user value
          size_t equalSignPos = itToken->find('=');
          // make sure there isn't a """ before the =
          if (itToken->find('"') != std::string::npos) {
            if (itToken->find('"') < equalSignPos) {
              BUException::BAD_TOKEN e;
              e.Append("Malformed token : ");
              e.Append(itToken->c_str());
              e.Append(" on line ");
              char numberBuffer[14] = "\0\0\0\0\0\0\0\0\0\0\0\0";
              snprintf(numberBuffer, 12, "%zu\n", lineNumber);
              e.Append(numberBuffer);
              e.Append("Bad line: ");
              e.Append(activeLine);
              e.Append("\n");
              throw e;
            }
          }
          // cache the name of the user field
          std::string name = itToken->substr(0, equalSignPos);
          // Parse the rest of the user value if there is more size
          if (itToken->size() - 1 == equalSignPos) {
            BUException::BAD_TOKEN e;
            e.Append("Malformed token : ");
            e.Append(itToken->c_str());
            e.Append(" on line ");
            char numberBuffer[14] = "\0\0\0\0\0\0\0\0\0\0\0\0";
            snprintf(numberBuffer, 12, "%zu\n", lineNumber);
            e.Append(numberBuffer);
            throw e;
          }
          // star this user field's data (data after the '=' char)
          std::string val = itToken->substr(equalSignPos + 1);
          if (val[0] != '"') {
            // We have a simple entry that has no quotes
            item->user[name] = val;
            iToken++;
          } else {
            // We have a quoted value
            val.erase(0, 1); // remove the quote
 
            // Check if this is still a simple entry, but with quotes
            if (val.find('"') != std::string::npos) {
              // We have another quote, remove it and everything after it
              val = val.substr(0, val.find('"'));
            } else {
              // We have a complicated value
              itToken++;
              while (itToken != tokens.end()) {
                val.append(" ");
                val.append(*itToken);
                if ((*itToken)[itToken->size() - 1] == '"') {
                  // stop now that we've reached the closing quote
                  // remove it from the string
                  val.erase(val.size() - 1);
                  break;
                }
                iToken++;
                itToken++;
              }
            }
            // convert "\n" to '\n'
            while (val.find("\\n") != std::string::npos) {
              val.replace(val.find("\\n"), 2, std::string("\n"));
            }
            item->user[name] = val;
          }
        }
        break;
    }
    if (itToken == tokens.end()) {
      break;
    }
  }
 
  if (iToken >= 4) {
    AddEntry(item);
  } else {
    delete item;
  }
}

Read() [1/2]

uint32_t AddressTable::Read

(

std::string

registerName

)

Definition at line 43 of file AddressTable_IO.cpp.

{
  std::map<std::string, Item*>::iterator itNameItem = nameItemMap.find(registerName);
  if (itNameItem == nameItemMap.end()) {
    BUException::INVALID_NAME e;
    e.Append("Can't find item with name \"");
    e.Append(registerName.c_str());
    e.Append("\"");
    throw e;
  }
  Item* item = itNameItem->second;
  uint32_t val = io->Read(item->address);
  val &= (item->mask);
  val >>= item->offset;
 
  return val;
}

Read() [2/2]

uint32_t AddressTable::Read

(

uint16_t

address

)

Definition at line 10 of file AddressTable_IO.cpp.

{
  return io->Read(address);
}

ReadWithRetry() [1/2]

uint32_t AddressTable::ReadWithRetry

(

std::string

registerName

)

Definition at line 62 of file AddressTable_IO.cpp.

{
  std::map<std::string, Item*>::iterator itNameItem = nameItemMap.find(registerName);
  if (itNameItem == nameItemMap.end()) {
    BUException::INVALID_NAME e;
    e.Append("Can't find item with name \"");
    e.Append(registerName.c_str());
    e.Append("\"");
    throw e;
  }
  Item* item = itNameItem->second;
  uint32_t val = io->ReadWithRetry(item->address);
  val &= (item->mask);
  val >>= item->offset;
 
  return val;
}

ReadWithRetry() [2/2]

uint32_t AddressTable::ReadWithRetry

(

uint16_t

address

)

Definition at line 15 of file AddressTable_IO.cpp.

{
  return io->ReadWithRetry(address);
}

Write() [1/6]

void AddressTable::Write	(	std::string	registerName,
		std::vector< uint32_t > const &	values )

Definition at line 127 of file AddressTable_IO.cpp.

{
  Write(registerName, values.data(), values.size());
}

Write() [2/6]

void AddressTable::Write	(	std::string	registerName,
		uint32_t const *	values,
		size_t	word_count )

Definition at line 132 of file AddressTable_IO.cpp.

{
  std::map<std::string, Item*>::iterator itNameItem = nameItemMap.find(registerName);
  if (itNameItem == nameItemMap.end()) {
    BUException::INVALID_NAME e;
    e.Append("Can't find item with name \"");
    e.Append(registerName.c_str());
    e.Append("\"");
    throw e;
  }
  Item* item = itNameItem->second;
  // Check if this entry controls all the bits
  if (item->mask != 0xFFFFFFFF) {
    BUException::BAD_BLOCK_WRITE e;
    e.Append("Mask is not 0xFFFFFFFF\n");
    throw e;
  }
  io->Write(item->address, values, word_count);
}

Write() [3/6]

void AddressTable::Write	(	std::string	registerName,
		uint32_t	val )

Definition at line 81 of file AddressTable_IO.cpp.

{
  std::map<std::string, Item*>::iterator itNameItem = nameItemMap.find(registerName);
  if (itNameItem == nameItemMap.end()) {
    BUException::INVALID_NAME e;
    e.Append("Can't find item with name \"");
    e.Append(registerName.c_str());
    e.Append("\"");
    throw e;
  }
  Item* item = itNameItem->second;
  // Check if this entry controls all the bits
  uint32_t buildingVal = 0;
  if (item->mask != 0xFFFFFFFF) {
    // Since there are bits this register we don't control, we need to see what they currently are
    buildingVal = io->Read(item->address);
    buildingVal &= ~(item->mask);
  }
  buildingVal |= (item->mask & (val << item->offset));
  io->Write(item->address, buildingVal);
}

Write() [4/6]

void AddressTable::Write	(	uint16_t	address,
		std::vector< uint32_t > const &	values )

Definition at line 32 of file AddressTable_IO.cpp.

{
  io->Write(address, values);
}

Write() [5/6]

void AddressTable::Write	(	uint16_t	address,
		uint32_t const *	values,
		size_t	word_count )

Definition at line 37 of file AddressTable_IO.cpp.

{
  io->Write(address, values, word_count);
}

Write() [6/6]

void AddressTable::Write	(	uint16_t	address,
		uint32_t	data )

Definition at line 21 of file AddressTable_IO.cpp.

{
  io->Write(address, data);
}

WriteWithRetry() [1/2]

void AddressTable::WriteWithRetry	(	std::string	registerName,
		uint32_t	val )

Definition at line 104 of file AddressTable_IO.cpp.

{
  std::map<std::string, Item*>::iterator itNameItem = nameItemMap.find(registerName);
  if (itNameItem == nameItemMap.end()) {
    BUException::INVALID_NAME e;
    e.Append("Can't find item with name \"");
    e.Append(registerName.c_str());
    e.Append("\"");
    throw e;
  }
  Item* item = itNameItem->second;
  // Check if this entry controls all the bits
  uint32_t buildingVal = 0;
  if (item->mask != 0xFFFFFFFF) {
    // Since there are bits this register we don't control, we need to see what they currently are
    buildingVal = io->ReadWithRetry(item->address);
    buildingVal &= ~(item->mask);
  }
  buildingVal |= (item->mask & (val << item->offset));
  io->WriteWithRetry(item->address, buildingVal);
}

WriteWithRetry() [2/2]

void AddressTable::WriteWithRetry	(	uint16_t	address,
		uint32_t	data )

Definition at line 26 of file AddressTable_IO.cpp.

{
  io->WriteWithRetry(address, data);
}

Member Data Documentation

addressItemMap

std::map<uint32_t,std::vector<Item*> > AddressTable::addressItemMap

private

Definition at line 64 of file AddressTable.hh.

fileLevel

int AddressTable::fileLevel

private

Definition at line 56 of file AddressTable.hh.

io

BNL_UDP* AddressTable::io

private

Definition at line 68 of file AddressTable.hh.

nameItemMap

std::map<std::string,Item*> AddressTable::nameItemMap

private

Definition at line 66 of file AddressTable.hh.

---

The documentation for this class was generated from the following files:

• /github/workspace/dunedaq/sourcecode/wibmod/src/wibmod/WIB1/AddressTable.hh
• /github/workspace/dunedaq/sourcecode/wibmod/src/WIB1/AddressTable.cpp
• /github/workspace/dunedaq/sourcecode/wibmod/src/WIB1/AddressTable_fileIO.cpp
• /github/workspace/dunedaq/sourcecode/wibmod/src/WIB1/AddressTable_IO.cpp
• /github/workspace/dunedaq/sourcecode/wibmod/src/WIB1/AddressTable_item.cpp
• /github/workspace/dunedaq/sourcecode/wibmod/src/WIB1/AddressTable_search.cpp