---

marshalling.h

Go to the documentation of this file.

#ifndef SCTCONF_MARSHALLING_H
#define SCTCONF_MARSHALLING_H

ABCDModule copyILUToABCDModule(const sctConf_T_ABCDModule& iluModule) {
  assert(sizeof(ABCDModule) == sizeof(sctConf_T_ABCDModule));
  
  return ABCDModule(reinterpret_cast<const ABCDModule&>(iluModule));
}

sctConf_T_ABCDModule* copyABCDModuleToILU(const ABCDModule &module) {

  assert(sizeof(ABCDModule) == sizeof(sctConf_T_ABCDModule));  
    
  return new sctConf_T_ABCDModule(reinterpret_cast<const sctConf_T_ABCDModule&>(module)) ;
}

SctConfiguration::RodConfig copyILUToRodConfig(sctConf_T_RodConfig *iluConfig) {
  SctConfiguration::RodConfig realConfig;

  realConfig.baseAddress = iluConfig->baseAddress;
  realConfig.mapSize = iluConfig->mapSize;
  realConfig.resetLevel = 0;
  realConfig.numSlaves = iluConfig->numSlaves;

  if(iluConfig->slaves->Length() != 4) {
    throw SctConfiguration::ConfigurationException("RodConfig must contain 4 slaves!");
  }

  for(int i=0; i<4; i++) {
    realConfig.slaves[i].emifFile = iluConfig->slaves->Nth(i)->emifFile;
    realConfig.slaves[i].ipramFile = iluConfig->slaves->Nth(i)->ipramFile;
    realConfig.slaves[i].idramFile = iluConfig->slaves->Nth(i)->idramFile;
    realConfig.slaves[i].extFile = iluConfig->slaves->Nth(i)->extFile;
  }

  return realConfig;
}

sctConf_T_RodConfig *copyRodConfigToILU(const SctConfiguration::RodConfig &config) {
  sctConf_T_RodConfig *result = new sctConf_T_RodConfig;

  result->baseAddress = config.baseAddress;
  result->mapSize = config.mapSize;
  result->numSlaves = config.numSlaves;

  result->slaves = _sctConf_T_SlaveList_sequence::Create(4, NULL);
  result->slaves->Clear(0);

  for(int i=0; i<4; i++) {
    sctConf_T_SlaveConfig *slave = new sctConf_T_SlaveConfig;

    const SctConfiguration::SlaveConfig &conf = config.slaves[i];

    slave->emifFile = (char *)malloc((conf.emifFile.length()+1) * sizeof(char));
    strncpy(slave->emifFile, conf.emifFile.c_str(), conf.emifFile.length());
    slave->emifFile[conf.emifFile.length()] = 0;

    slave->ipramFile = (char *)malloc((conf.ipramFile.length()+1) * sizeof(char));
    strncpy(slave->ipramFile, conf.ipramFile.c_str(), conf.ipramFile.length());
    slave->ipramFile[conf.ipramFile.length()] = 0;

    slave->idramFile = (char *)malloc((conf.idramFile.length()+1) * sizeof(char));
    strncpy(slave->idramFile, conf.idramFile.c_str(), conf.idramFile.length());
    slave->idramFile[conf.idramFile.length()] = 0;

    slave->extFile = (char *)malloc((conf.extFile.length()+1) * sizeof(char));
    strncpy(slave->extFile, conf.extFile.c_str(), conf.extFile.length());
    slave->extFile[conf.extFile.length()] = 0;

    result->slaves->Append(slave);
  }

  return result;
}

SctConfiguration::BOCChannelConfig copyILUToBOCChannelConfig(sctConf_T_BOCChannelConfig *iluConfig) {
  SctConfiguration::BOCChannelConfig newConf;

  newConf.current = iluConfig->current;
  newConf.delay = iluConfig->delay;
  newConf.markSpace = iluConfig->markSpace;

  newConf.threshold0 = iluConfig->threshold0;
  newConf.delay0 = iluConfig->delay0;

  newConf.threshold1 = iluConfig->threshold1;
  newConf.delay1 = iluConfig->delay1;

  return newConf;
}

sctConf_T_BOCChannelConfig *copyBOCChannelConfigToILU(const SctConfiguration::BOCChannelConfig &config) {
  sctConf_T_BOCChannelConfig *res = new sctConf_T_BOCChannelConfig;

  res->current = config.current;
  res->delay = config.delay;
  res->markSpace = config.markSpace;

  res->threshold0 = config.threshold0;
  res->delay0 = config.delay0;

  res->threshold1 = config.threshold1;
  res->delay1 = config.delay1;

  return res;
}

SctConfiguration::BOCGlobalConfig copyILUToBOCGlobalConfig(sctConf_T_BOCGlobalConfig *iluConfig) {
  SctConfiguration::BOCGlobalConfig newConf;

  newConf.validMask = iluConfig->validMask;
  newConf.clockControl = iluConfig->clockControl;
  newConf.rxDataMode = iluConfig->rxDataMode;
  newConf.rxDacClear = iluConfig->rxDacClear;
  newConf.txDacClear = iluConfig->txDacClear;
  newConf.vernierFinePhase = iluConfig->vernierFinePhase;
  newConf.vernierClockPhase0 = iluConfig->vernierClockPhase0;
  newConf.vernierClockPhase1 = iluConfig->vernierClockPhase1;
  newConf.bpmClockPhase = iluConfig->bpmClockPhase;
  newConf.bregClockPhase = iluConfig->bregClockPhase;

  return newConf;
}

sctConf_T_BOCGlobalConfig *copyBOCGlobalConfigToILU(const SctConfiguration::BOCGlobalConfig &config) {
  sctConf_T_BOCGlobalConfig *res = new sctConf_T_BOCGlobalConfig;

  res->validMask = config.validMask;
  res->clockControl = config.clockControl;
  res->rxDataMode = config.rxDataMode;
  res->rxDacClear = config.rxDacClear;
  res->txDacClear = config.txDacClear;
  res->vernierFinePhase = config.vernierFinePhase;
  res->vernierClockPhase0 = config.vernierClockPhase0;
  res->vernierClockPhase1 = config.vernierClockPhase1;
  res->bpmClockPhase = config.bpmClockPhase;
  res->bregClockPhase = config.bregClockPhase;

  return res;
}

SctConfiguration::TimConfig copyILUToTimConfig(sctConf_T_TimConfig *iluConfig) {
  SctConfiguration::TimConfig result;

  result.baseAddress = iluConfig->baseAddress;
  result.mapSize = iluConfig->mapSize;

  return result;
}

sctConf_T_TimConfig *copyTimConfigToILU(const SctConfiguration::TimConfig &config) {
  sctConf_T_TimConfig *res = new sctConf_T_TimConfig;

  res->baseAddress = config.baseAddress;
  res->mapSize = config.mapSize;

  return res;
}

#endif //SCTCONF_MARSHALLING_H

---