---

marshalling.h

#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.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::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

---