#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 10 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 24 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 11 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 28 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.

46{return io->GetAddress();};

◆ GetRetryCount()

uint64_t AddressTable::GetRetryCount ( )

inline

Definition at line 48 of file AddressTable.hh.

48{return io->GetRetryCount();};

◆ GetTables()

std::vector< std::string > AddressTable::GetTables ( std::string const & regex )

Definition at line 87 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 135 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 33 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 50 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 13 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 110 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 113 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 67 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 25 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 28 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 18 of file AddressTable_IO.cpp.

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

◆ WriteWithRetry() [1/2]

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

Definition at line 88 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 21 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

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ AddressTable() [1/3]

◆ AddressTable() [2/3]

◆ AddressTable() [3/3]

Member Function Documentation

◆ AddEntry()

◆ GetAddresses()

◆ GetItem()

◆ GetNames() [1/2]

◆ GetNames() [2/2]

◆ GetRemoteAddress()

◆ GetRetryCount()

◆ GetTables()

◆ GetTagged()

◆ LoadFile()

◆ operator=()

◆ ProcessLine()

◆ Read() [1/2]

◆ Read() [2/2]

◆ ReadWithRetry() [1/2]

◆ ReadWithRetry() [2/2]

◆ Write() [1/6]

◆ Write() [2/6]

◆ Write() [3/6]

◆ Write() [4/6]

◆ Write() [5/6]

◆ Write() [6/6]

◆ WriteWithRetry() [1/2]

◆ WriteWithRetry() [2/2]

Member Data Documentation

◆ addressItemMap

◆ fileLevel

◆ io

◆ nameItemMap