OmniMarshalling.h

#ifndef SCT_OMNIMARSHALLING_H
#define SCT_OMNIMARSHALLING_H

#include <list>
#include <set>
#include <string>
#include <vector>
#include <ipc/core.h>
#include "Sct/BugReport.h"
#include "Sct/Addressing.h"
#include "Sct/Addressing.hh"

namespace Sct {

inline Sct::Corba::UPID copyUPIDToCorba(const Sct::UPID & upid) {
  Sct::Corba::UPID ret;
  ret.partition = upid.partition();
  return ret;
};

inline Sct::Corba::UCID copyUCIDToCorba(const Sct::UCID & ucid) {
  Sct::Corba::UCID ret;
  ret.partition = ucid.partition();
  ret.crate = ucid.crate();
  return ret;
};

inline Sct::Corba::URID copyURIDToCorba(const Sct::URID & urid) {
  Sct::Corba::URID ret;
  ret.partition = urid.partition();
  ret.crate = urid.crate();
  ret.rod = urid.rod();
  return ret;
};

inline Sct::UPID copyCorbaToUPID(const Sct::Corba::UPID & upid) {
  return Sct::UPID(upid.partition);
};

inline Sct::UCID copyCorbaToUCID(const Sct::Corba::UCID & ucid) {
  return Sct::UCID(ucid.partition, ucid.crate);
};

inline Sct::URID copyCorbaToURID(const Sct::Corba::URID & urid) {
  return Sct::URID(urid.partition, urid.crate, urid.rod);
};

inline char *copyStringToCorba(const std::string & str) {
  char * ans = CORBA::string_dup(str.c_str());
  Sct::BugReport("BUG01","OMNI_MARSHALLING", std::string("OmniMarshalling has converted [")+str+"] into ["+ans+"]");
  return ans;
}

template <typename CorbaSequence, typename ListMember>
inline CorbaSequence *copyListToCorba(const std::list<ListMember> & thisList) {
  unsigned size=thisList.size();
  CorbaSequence *result = new CorbaSequence(size);
  result->length(size);
  
  unsigned i=0;
  for(typename std::list<ListMember>::const_iterator m = thisList.begin();
      m!=thisList.end();
      m++) {
    (*result)[i] = *m;
    ++i;
  }

  return result;
}

template <typename CorbaSequence>
inline CorbaSequence *copyStringListToCorba(const std::list<std::string> & thisList) {
  unsigned size = thisList.size();
  CorbaSequence *result = new CorbaSequence(size);
  result->length(size);
 
  unsigned i=0;
  for(std::list<std::string>::const_iterator m = thisList.begin();
      m!=thisList.end();
      m++) {
    (*result)[i]=CORBA::string_dup(m->c_str());
    ++i;
  }

  return result;
}

template <typename CorbaSequence>
inline CorbaSequence *copyStringSetToCorba(const std::set<std::string> & thisSet) {
  unsigned size = thisSet.size();
  CorbaSequence *result = new CorbaSequence(size);
  result->length(size);
 
  unsigned i=0;
  for(std::set<std::string>::const_iterator m = thisSet.begin();
      m!=thisSet.end();
      m++) {
    (*result)[i]=CORBA::string_dup(m->c_str());
    ++i;
  }

  return result;
}

template <typename CorbaSequence, typename ListMember>
inline std::list<ListMember> copyCorbaToList(const CorbaSequence * const thisSeq) {
  std::list<ListMember> result;

  if (thisSeq) {
      for(unsigned int i=0; i<thisSeq->length(); i++) {
      result.push_back( ListMember((*thisSeq)[i]) );
      }
  }
  return result;
}


template <typename CorbaSequence, typename List>
inline List copyCorbaToStdCollection(const CorbaSequence * thisSeq) { 
  List result;

  if (thisSeq) {
      for(unsigned int i=0; i<thisSeq->length(); i++) {
          result.push_back((*thisSeq)[i]);
      }
  }
  return result;
}


template <typename CorbaSequence, typename ArrayMember>
inline CorbaSequence *copyArrayToCorba(ArrayMember * const array, const unsigned long length) {
  CorbaSequence *result = new CorbaSequence(length);
  result->length(length);

  if(array) {
    for(unsigned long i=0; i<length; i++) {
      (*result)[i]=array[i];
    }
  }
  return result;
}
 
template <typename CorbaSequence, typename ArrayMember>
inline CorbaSequence *copyVectorToCorba(const std::vector<ArrayMember> & array) {
  CorbaSequence *result;
  unsigned size = array.size();
  result = new CorbaSequence(size);
  result->length(size);

  for(unsigned long i=0; i<array.size(); i++) {
    (*result)[i]=array[i];
  }
  return result;
}

template <typename CorbaMatrix, typename CorbaSequence, typename ArrayMember>
inline CorbaMatrix *copyVectorVectorToCorba(const std::vector<std::vector<ArrayMember> > & matrix) {
  unsigned int size = matrix.size();
  CorbaMatrix *result = new CorbaMatrix(size);
  result->length(size);

  for(unsigned long i=0; i<size; i++) {
    unsigned int width=matrix[i].size();
    CorbaSequence *seq = new CorbaSequence(width);
    seq->length(width);
    for(unsigned long j=0; j<width; j++) {
      (*seq)[j] = matrix[i][j];
    }
    (*result)[i]=*seq;
  }
  return result;
}

template <typename CorbaBlock, typename ArrayMember>
inline ArrayMember *copyCorbaToArray(const CorbaBlock & thisSeq, ArrayMember * const array) {
  for(unsigned int i=0; i<thisSeq.length(); i++) {
    array[i] = thisSeq[i];
  }
  return array;
}

}

#endif //SCT_OMNIMARSHALLING_H

---