source: branches/corba/gsdl/src/recpt/corbaproto.mpp@ 1068

/**********************************************************************
 *
 * corbaproto.cpp -- 
 * Copyright (C) 1999  The New Zealand Digital Library Project
 *
 * A component of the Greenstone digital library software
 * from the New Zealand Digital Library Project at the
 * University of Waikato, New Zealand.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 *
 * $Id: corbaproto.mpp 1068 2000-04-04 15:11:31Z cs025 $
 *
 *********************************************************************/

#include <iostream.h>
#include <fstream.h>

// protocol headers for CORBA
#include "corbaiface.h"

// greenstone library headers
#include "corbaconv_text_t.h"

// greenstone local headers
#include "corbatext_t.h"

#include "corbaproto.h"
#include "colservrconfig.h"

// default headers
#include <assert.h>

void corbatext_optionValueArrayToCorba(OptionValue_tarray array, corbaOptionValue_array &corba)
{
  unsigned int i = 0;
  OptionValue_tarray::iterator here = array.begin();
  OptionValue_tarray::iterator end = array.end();
  
  while (here != end)
    {
      corba.length(i+1);
      
      corbaconv_text_t::getCorbatext(here->name,corba[i].name);
      corbaconv_text_t::getCorbatext(here->value,corba[i].value);

      i ++;
      here ++;
    }
  //  cout << "Options " << i << endl;
}

void corbaresponse_resultMetadataToCorba(MetadataInfo_t &meta, corbaMetadataInfo &corbaMeta)
{
  corbaconv_text_t::getCorbatext(meta.params,corbaMeta.params);
  corbatext_arrayToCorbaArray(meta.values, &corbaMeta.values);
  corbaMeta.isRef    = meta.isRef;
}

void corbaresponse_resultMetadataToC(const corbaMetadataInfo &corbaMeta, MetadataInfo_t &meta)
{
  corbaconv_text_t::setCorbatext(meta.params,corbaMeta.params);
  corbatext_corbaArrayToArray(corbaMeta.values, &meta.values);
  meta.isRef    = corbaMeta.isRef;
}

int corbaresponse_resultMetaParentToCorba(MetadataInfo_t *parent, corbaMetadataInfo_array &corbaparent)
{
  int reply = -1, pid = -1;

  // extend for new parent
  reply = corbaparent.length();
  corbaparent.length(reply+1);

  // copy content into new array element
  corbaresponse_resultMetadataToCorba(*parent, corbaparent[reply]);

  // deal with our own parent
  if (parent->parent != NULL)
    {
      // get offset of new parent and extend parent vector

      pid  = corbaresponse_resultMetaParentToCorba(parent->parent, corbaparent);
    }
  corbaparent[reply].parentid = pid;

  // return the parent id from here
  return reply;
}

MetadataInfo_t *corbaresponse_resultMetaParentToC(corbaMetadataInfo_array &corbaparent, int pid)
{
  MetadataInfo_t *reply;

  reply = new MetadataInfo_t;

  corbaresponse_resultMetadataToC(corbaparent[pid], *reply);

  // deal with our own parent
  if (corbaparent[pid].parentid >= 0)
    {
      // get offset of new parent and extend parent vector

      reply->parent = corbaresponse_resultMetaParentToC(corbaparent, corbaparent[pid].parentid);
    }
  else
    {
      reply->parent = NULL;
    }

  // return the parent id from here
  return reply;
}

void corbaresponse_resultDocInfoToCorba(ResultDocInfo_tarray docinfo, corbaResultDocInfo_array &corbainfo)
{
  ResultDocInfo_tarray::iterator here = docinfo.begin();
  ResultDocInfo_tarray::iterator end  = docinfo.end();
  unsigned int i;

  i = 0;
  while (here != end)
    {
      corbainfo.length(i+1);

      // copy the easy bits
      corbaconv_text_t::getCorbatext(here->OID,corbainfo[i].OID);

      corbainfo[i].resultNum     = here->result_num;
      corbainfo[i].ranking       = here->ranking;
      corbainfo[i].termsMatched  = here->num_terms_matched;
      corbainfo[i].phraseMatched = here->num_phrase_match;

      // copy the docFreq array
      vector<int>::iterator fhere = here->docFreq.begin();
      vector<int>::iterator fend  = here->docFreq.end();
      unsigned int          fi = 0;

      while (fhere != fend)
    {
      corbainfo[i].docFreq.length(fi+1);

      corbainfo[i].docFreq[fi] = *fhere;

      fhere ++;
      fi ++;
    }
      // copy the MetadataInfo map
      MetadataInfo_tmap::iterator mhere = here->metadata.begin();
      MetadataInfo_tmap::iterator mend  = here->metadata.end();
      unsigned int mi = 0;

      while (mhere != mend)
    {
      corbainfo[i].metadata.names.length(mi+1);
      corbainfo[i].metadata.values.length(mi+1);
      
      // copy name
      corbaconv_text_t::getCorbatext((*mhere).first,corbainfo[i].metadata.names[mi]);

      // copy metadata
      corbaresponse_resultMetadataToCorba((*mhere).second, corbainfo[i].metadata.values[mi]);
      if (mhere->second.parent != NULL)
        {
          int pid;

          pid = corbaresponse_resultMetaParentToCorba(mhere->second.parent, 
                                  corbainfo[i].metaparents);
          corbainfo[i].metadata.values[mi].parentid = pid;
        }
      else
        {
          corbainfo[i].metadata.values[mi].parentid = -1;
        }

      cout << "Parent " << mi << " " << (int) &mhere->second << " " << (int) mhere->second.parent << endl;

      mhere ++;
      mi ++;
    }

      // Get next Docinfo item
      i++;
      here ++;
    }
}

void corbaresponse_resultDocInfoToC(corbaResultDocInfo_array corbainfo, ResultDocInfo_tarray &docinfo)
{
  unsigned int i;
  ResultDocInfo_t doc;

  for (i = 0; i < corbainfo.length(); i++)
    {
      corbaconv_text_t::setCorbatext(doc.OID,corbainfo[i].OID);
      doc.result_num        = corbainfo[i].resultNum;
      doc.ranking           = corbainfo[i].ranking;
      doc.num_terms_matched = corbainfo[i].termsMatched;
      doc.num_phrase_match  = corbainfo[i].phraseMatched;

      // copy the doc freq array
      unsigned int fi;
      for (fi = 0; fi < corbainfo[i].docFreq.length(); fi ++)
    {
      doc.docFreq.push_back(corbainfo[i].docFreq[fi]);
    }

      // copy the MetadataInfomap
      unsigned int   mi;
      text_t         mname;
      MetadataInfo_t mdata;
      
      doc.metadata.clear();
      for (mi = 0; mi < corbainfo[i].metadata.names.length(); mi ++)
    {
      // get name
      corbaconv_text_t::setCorbatext(mname,corbainfo[i].metadata.names[mi]);

      // get metadata
      corbaresponse_resultMetadataToC(corbainfo[i].metadata.values[mi], mdata);

      if (corbainfo[i].metadata.values[mi].parentid >= 0)
        {
          mdata.parent = 
        corbaresponse_resultMetaParentToC(corbainfo[i].metaparents, 
                          corbainfo[i].metadata.values[mi].parentid);         
        }
     
      doc.metadata.insert(make_pair(mname, mdata));
    }

      // GRB: sort out parent data
      for (mi = 0; mi < corbainfo[i].metadata.names.length(); mi ++)
    {
      if (corbainfo[i].metadata.values[mi].parentid != 0)
        { 
          int pi;

          for (pi = 0; pi < corbainfo[i].metadata.names.length(); pi ++)
        {
          if (pi != mi &&
              corbainfo[i].metadata.values[mi].parentid ==
              corbainfo[i].metadata.values[pi].id)
            {
              doc.metadata[mi].parent = &doc.metadata[pi];
            }
        }
        }
    }
      //      doc.metadata

      docinfo.push_back(doc); 
    }
}

corbaproto::corbaproto()
{ char *dummyv[1] = {""};
  int   dummyc = 0;
  /*  // CORBA variables
  static CORBA::ORB_var orb = CORBA::ORB_init( dummyc , dummyv, "mico-local-orb" );
  static CORBA::BOA_var boa = orb->BOA_init( dummyc , dummyv, "mico-local-boa" );

  // Get ref from "naming service"
  ifstream in ("/tmp/account.objid");
  char ref[1000];
  in >> ref;
  in.close ();

  // startup corba
  static CORBA::Object_var obj = orb->string_to_object (ref);

  client = corbaiface::_narrow( obj );*/
  client = NULL;
}


// this configure will configure each of the collection servers
void corbaproto::configure (const text_t &key, const text_tarray &cfgline) {
  // the naming of the collection should not be done here,
  // it should be done just after the collection server has been 
  // created

  //  cout << "Corbaproto::Configure" << endl;

  char *dummyv[1] = {""};
  int   dummyc = 0;
  // CORBA variables
  static CORBA::ORB_var orb = CORBA::ORB_init( dummyc , dummyv, "mico-local-orb" );
  static CORBA::BOA_var boa = orb->BOA_init( dummyc , dummyv, "mico-local-boa" );

  // Get ref from "naming service"
  ifstream in ("/tmp/account.objid");
  char ref[1000];
  in >> ref;
  in.close ();

  // startup corba
  static CORBA::Object_var obj = orb->string_to_object (ref);

  corbaiface_var lclient = corbaiface::_narrow( obj );

  corbatext_t      corbaKey;
  corbatext_tarray corbaCfgline;

  corbaconv_text_t::getCorbatext(key,corbaKey);
  corbatext_arrayToCorbaArray(cfgline, &corbaCfgline);

  lclient->configure(corbaKey, corbaCfgline);  
}

// this init will configure and init each of the collection servers
bool corbaproto::init (ostream &logout) {
  //  cout << "Corbaproto::Init" << endl;

  char *dummyv[1] = {""};
  int   dummyc = 0;
  // CORBA variables
  static CORBA::ORB_var orb = CORBA::ORB_init( dummyc , dummyv, "mico-local-orb" );
  static CORBA::BOA_var boa = orb->BOA_init( dummyc , dummyv, "mico-local-boa" );

  // Get ref from "naming service"
  ifstream in ("/tmp/account.objid");
  char ref[1000];
  in >> ref;
  in.close ();

  // startup corba
  static CORBA::Object_var obj = orb->string_to_object (ref);

  corbaiface_var lclient = corbaiface::_narrow( obj );

  return lclient->init();
}

text_t corbaproto::get_protocol_name () {
  return "corbaproto";
}


void corbaproto::get_collection_list (text_tarray &collist, comerror_t &err, 
                     ostream &/*logout*/) {

  //  cout << "Corbaproto::Collection list" << endl;

  corbatext_tarray corba_collist;
  corbatext_t      collection;
  text_tarray      tcollist;

  /*  collist.erase(collist.begin(),collist.end());
  err = noError;

  collectservermapclass::iterator here = cservers.begin();
  collectservermapclass::iterator end = cservers.end();
  while (here != end) {
    assert ((*here).second.c != NULL);
    if ((*here).second.c != NULL) {
      collist.push_back ((*here).second.c->get_collection_name());
    }
    here++;
  }
  */
  char *dummyv[1] = {""};
  int   dummyc = 0;
  // CORBA variables
  static CORBA::ORB_var orb = CORBA::ORB_init( dummyc , dummyv, "mico-local-orb" );
  static CORBA::BOA_var boa = orb->BOA_init( dummyc , dummyv, "mico-local-boa" );

  // Get ref from "naming service"
  ifstream in ("/tmp/account.objid");
  char ref[1000];
  in >> ref;
  in.close ();

  // startup corba
  static CORBA::Object_var obj = orb->string_to_object (ref);

  corbaiface_var lclient = corbaiface::_narrow( obj );

  lclient->collectionList(corba_collist);

  corbatext_corbaArrayToArray(corba_collist, &tcollist);
  collist = tcollist;

  err = noError;
}

void corbaproto::has_collection (const text_t &collection, bool &hascollection, 
                comerror_t &err, ostream &/*logout*/) {
  //  cout << "Corbaproto::Has collection" << endl;

  /*  hascollection = (cservers.getcollectserver(collection) != NULL);
  err = noError;
  return;*/

  char *dummyv[1] = {""};
  int   dummyc = 0;
  corbatext_t_var corbaCollectPtr;
  corbatext_t     corbaCollection;
  corbaComError corbaError;
  CORBA::Boolean corbaHas;

  // CORBA variables
  static CORBA::ORB_var orb = CORBA::ORB_init( dummyc , dummyv, "mico-local-orb" );
  static CORBA::BOA_var boa = orb->BOA_init( dummyc , dummyv, "mico-local-boa" );

  // Get ref from "naming service"
  ifstream in ("/tmp/account.objid");
  char ref[1000];
  in >> ref;
  in.close ();

  // startup corba
  static CORBA::Object_var obj = orb->string_to_object (ref);

  corbaiface_var lclient = corbaiface::_narrow( obj );

  // corbaCollectPtr = &corbaCollection;
  //corbatext_corbatext(collection, corbaCollectPtr);
  corbaconv_text_t::getCorbatext(collection,corbaCollection);
  
  lclient->hasCollection(corbaCollection, corbaHas, corbaError);

  hascollection = (corbaHas != 0);
  err = noError;

}

void corbaproto::ping (const text_t &collection, bool &wassuccess, 
              comerror_t &err, ostream &/*logout*/) {
  //  cout << "Corbaproto::Ping" << endl;

  char *dummyv[1] = {""};
  int   dummyc = 0;
  // CORBA variables
  static CORBA::ORB_var orb = CORBA::ORB_init( dummyc , dummyv, "mico-local-orb" );
  static CORBA::BOA_var boa = orb->BOA_init( dummyc , dummyv, "mico-local-boa" );

  // Get ref from "naming service"
  ifstream in ("/tmp/account.objid");
  char ref[1000];
  in >> ref;
  in.close ();

  // startup corba
  static CORBA::Object_var obj = orb->string_to_object (ref);

  corbaiface_var lclient = corbaiface::_narrow( obj );

  corbatext_t corbaCollect;
  corbaComError corbaError;
  bool success;

  corbaconv_text_t::getCorbatext(collection,corbaCollect);
  success = lclient->ping(corbaCollect, corbaError);
  
  wassuccess = success;
  /*  
  wassuccess = (cservers.getcollectserver(collection) != NULL);
  err = noError;
  */
}

void corbaproto::get_collectinfo (const text_t &collection, 
                 ColInfoResponse_t &collectinfo,
                 comerror_t &err, ostream &logout) {
  //  cout << "Corbaproto::Collectinfo" << endl;

  char *dummyv[1] = {""};
  int   dummyc = 0;

  // CORBA variables
  static CORBA::ORB_var orb = CORBA::ORB_init( dummyc , dummyv, "mico-local-orb" );
  static CORBA::BOA_var boa = orb->BOA_init( dummyc , dummyv, "mico-local-boa" );

  // Get ref from "naming service"
  ifstream in ("/tmp/account.objid");
  char ref[1000];
  in >> ref;
  in.close ();

  // startup corba
  static CORBA::Object_var obj = orb->string_to_object (ref);

  corbaiface_var lclient = corbaiface::_narrow( obj );

  corbatext_t          corbaCollection;
  corbaComError        corbaError;
  corbaColInfoResponse corbaCollectInfo;

  corbaconv_text_t::getCorbatext(collection,corbaCollection);
  lclient->getCollectInfo(corbaCollection, corbaCollectInfo, corbaError);

  collectinfo.isPublic = corbaCollectInfo.isPublic;
  collectinfo.isBeta   = corbaCollectInfo.isBeta;
  collectinfo.buildDate = corbaCollectInfo.buildDate;
  corbatext_corbaArrayToArray(corbaCollectInfo.languages, &collectinfo.languages);
  collectinfo.numDocs   = corbaCollectInfo.numDocs;
  collectinfo.numWords  = corbaCollectInfo.numWords;
  collectinfo.numBytes  = corbaCollectInfo.numBytes;
  corbatext_corbaMapToMap(corbaCollectInfo.collectionMeta, collectinfo.collectionmeta);
  corbatext_corbaMapToMap(corbaCollectInfo.format, collectinfo.format);
  corbatext_corbaMapToMap(corbaCollectInfo.building, collectinfo.building);
  corbaconv_text_t::setCorbatext(collectinfo.receptionist,corbaCollectInfo.receptionist);

  err = (comerror_t) corbaError;  
  /*  
  collectserver *cserver = cservers.getcollectserver (collection);
  if (cserver != NULL) cserver->get_collectinfo (collectinfo, err, logout);
  else err = protocolError;
  */
}


void corbaproto::get_filterinfo (const text_t &collection,
                InfoFiltersResponse_t &response,
                comerror_t &err, ostream &logout) {
  //  cout << "Corbaproto::Filterinfo" << endl;

  char *dummyv[1] = {""};
  int   dummyc = 0;
  // CORBA variables
  static CORBA::ORB_var orb = CORBA::ORB_init( dummyc , dummyv, "mico-local-orb" );
  static CORBA::BOA_var boa = orb->BOA_init( dummyc , dummyv, "mico-local-boa" );

  // Get ref from "naming service"
  ifstream in ("/tmp/account.objid");
  char ref[1000];
  in >> ref;
  in.close ();

  // startup corba
  static CORBA::Object_var obj = orb->string_to_object (ref);

  corbaiface_var lclient = corbaiface::_narrow( obj );

  corbatext_t corbaCollection;
  corbatext_tset corbaResponse;
  corbaComError corbaError;
  
  corbaconv_text_t::getCorbatext(collection,corbaCollection);

  lclient->getFilterInfo(corbaCollection, corbaResponse, corbaError);

  corbatext_corbaArrayToSet(corbaResponse, &response.filterNames);

  err = (comerror_t) corbaError;

  /*
  collectserver *cserver = cservers.getcollectserver (collection);
  if (cserver != NULL) cserver->get_filterinfo (response, err, logout);
  else err = protocolError;
  */
}

void corbaproto::get_filteroptions (const text_t &collection,
                   const InfoFilterOptionsRequest_t &request,
                   InfoFilterOptionsResponse_t &response, 
                   comerror_t &err, ostream &logout) {
  //  cout << "Corbaproto::Filteroptions" << endl;

  char *dummyv[1] = {""};
  int   dummyc = 0;
  // CORBA variables
  static CORBA::ORB_var orb = CORBA::ORB_init( dummyc , dummyv, "mico-local-orb" );
  static CORBA::BOA_var boa = orb->BOA_init( dummyc , dummyv, "mico-local-boa" );

  // Get ref from "naming service"
  ifstream in ("/tmp/account.objid");
  char ref[1000];
  in >> ref;
  in.close ();

  // startup corba
  static CORBA::Object_var obj = orb->string_to_object (ref);

  corbaiface_var lclient = corbaiface::_narrow( obj );

  corbatext_t corbaCollection;
  corbatext_t filterName;
  corbaFilterOptionsResponse corbaResponse;
  corbaComError corbaError;
  unsigned int i;
  corbaconv_text_t *cc_name;
  FilterOption_t *option;

  corbaconv_text_t::getCorbatext(collection,corbaCollection);
  corbaconv_text_t::getCorbatext(request.filterName,filterName);

  lclient->getFilterOptions(corbaCollection, filterName, corbaResponse, corbaError);

  for (i = 0; i < corbaResponse.names.length(); i ++)
    {
      cc_name = new corbaconv_text_t(corbaResponse.names[i]);

      option = new FilterOption_t;
      corbaconv_text_t::setCorbatext(option->name,corbaResponse.options[i].name);
      option->type = (FilterOption_t::type_t) corbaResponse.options[i].type;
      option->repeatable = (FilterOption_t::repeatable_t) corbaResponse.options[i].repeatable;
      corbaconv_text_t::setCorbatext(option->defaultValue,corbaResponse.options[i].defaultValue);
      corbatext_corbaArrayToArray(corbaResponse.options[i].validValues, &option->validValues);

      response.filterOptions.insert(make_pair(*cc_name, *option)); // typecast to text_t
    }

  err =  (comerror_t) corbaError;
  /*
  collectserver *cserver = cservers.getcollectserver (collection);
  if (cserver != NULL) cserver->get_filteroptions (request, response, err, logout);
  else err = protocolError;
  */
}

void corbaproto::filter (const text_t &collection,
              FilterRequest_t &request,
              FilterResponse_t &response,
              comerror_t &err, ostream &logout) {
  //  cout << "Corbaproto::Filter" << endl;

  corbaFilterRequest corbaRequest;
  corbaFilterResponse corbaResponse;

  char *dummyv[1] = {""};
  int   dummyc = 0;
  corbatext_t_var corbaCollectPtr;
  corbatext_t     corbaCollection;
  corbaComError corbaError;

  // CORBA variables
  static CORBA::ORB_var orb = CORBA::ORB_init( dummyc , dummyv, "mico-local-orb" );
  static CORBA::BOA_var boa = orb->BOA_init( dummyc , dummyv, "mico-local-boa" );

  // Get ref from "naming service"
  ifstream in ("/tmp/account.objid");
  char ref[1000];
  in >> ref;
  in.close ();

  // startup corba
  static CORBA::Object_var obj = orb->string_to_object (ref);

  corbaiface_var lclient = corbaiface::_narrow( obj );

  corbaconv_text_t::fillUsString(collection,&corbaCollection.text);

  corbaconv_text_t::fillUsString(request.filterName,&corbaRequest.filter.text);
  corbatext_optionValueArrayToCorba(request.filterOptions, corbaRequest.filterOptions);
  corbatext_arrayToCorbaArray(request.docSet, &corbaRequest.docSet);
  corbaRequest.filterResultOptions = request.filterResultOptions;
  corbaconv_text_t::getCorbatext(request.requestParams,corbaRequest.requestParams);
  corbaconv_text_t::getCorbatext(request.refParams,corbaRequest.refParams);
  corbaRequest.getParents = request.getParents;
  corbatext_setToCorbaArray(request.fields, &corbaRequest.fields);

  corbaResponse.numDocs = response.numDocs;
  corbaresponse_resultDocInfoToCorba(response.docInfo, corbaResponse.docInfo);

  lclient->filter (corbaCollection, corbaRequest, corbaResponse, corbaError);

  response.numDocs = corbaResponse.numDocs;
  response.isApprox = corbaResponse.isApprox;
  corbaresponse_resultDocInfoToC(corbaResponse.docInfo, response.docInfo);

  err = (comerror_t) corbaError;
  /*
  collectserver *cserver = cservers.getcollectserver (collection);
  if (cserver != NULL) cserver->filter (request, response, err, logout);
  else err = protocolError;
  */
  //  cout << "Corbaproto::Filter" << endl;

}

void corbaproto::get_document (const text_t &collection,
                   const DocumentRequest_t &request,
                   DocumentResponse_t &response,
                   comerror_t &err, ostream &logout) {
  //  cout << "Corbaproto::Get Document" << endl;

  /*  collectserver *cserver = cservers.getcollectserver (collection);
  if (cserver != NULL) cserver->get_document (request, response, err, logout);
  else err = protocolError;
  */

  char *dummyv[1] = {""};
  int   dummyc = 0;

  // CORBA variables
  static CORBA::ORB_var orb = CORBA::ORB_init( dummyc , dummyv, "mico-local-orb" );
  static CORBA::BOA_var boa = orb->BOA_init( dummyc , dummyv, "mico-local-boa" );

  // Get ref from "naming service"
  ifstream in ("/tmp/account.objid");
  char ref[1000];
  in >> ref;
  in.close ();

  // startup corba
  static CORBA::Object_var obj = orb->string_to_object (ref);

  corbaiface_var lclient = corbaiface::_narrow( obj );

  corbatext_t      corbaCollect;
  corbaDocRequest  corbaRequest;
  corbaDocResponse corbaResponse;
  corbaComError    corbaError;

  corbaconv_text_t::getCorbatext(collection,corbaCollect);
  corbaconv_text_t::getCorbatext(request.OID,corbaRequest.OID);
  corbaconv_text_t::getCorbatext(request.docType,corbaRequest.docType);
  corbaconv_text_t::getCorbatext(request.docFormat,corbaRequest.docFormat);

  lclient->getDocument(corbaCollect, corbaRequest, corbaResponse, corbaError);
  corbaconv_text_t::setCorbatext(response.doc,corbaResponse.doc);

  err = (comerror_t) corbaError;
}