msd_soap_saclient.cc

//---------------------------------------------------
// msd_soap_saclient.cc
// 
// Project: PDBe API Framework 
// Module:  C++ Client example PDBe API Webservice (SOAP) Server 
//
// To build:
//    make wsaclient 
//
// SOAP User Layer
// Last updated: 25 February 2004 10:17
// (C) Siamak Sobhany
//---------------------------------------------------
// 
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// To run msd api web services as a multi-threaded stand-alone server:
//  ./msd_soap_service parrot.ebi.ac.uk 8100
//
// Then run this client:
//  /ebi/msd/work/siamak/apache/cgi-bin/msd_soap_saclient
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

#include "msd_soapH.h"
#include "msd_soap_service.nsmap"
#include "Lpp.hh"

#include <iostream>
#include <string.h>
using namespace std;
//
//      PDBe Data Warehouse client for msd API Web Services
//
// To access a stand-alone server on a port: msd_soap_service[] = "IP:PORT";
// use "http://" to include HTTP header: msd_soap_service[] = "http://IP:PORT";
// const char msd_soap_service[] = "parrot.ebi.ac.uk:8099"
// const char msd_soap_service[] = "http://parrot.ebi.ac.uk:8099";



//const char msd_soap_service[] = "http://phoenix.ebi.ac.uk:8099/cgi-bin/msd_soap_service.cgi";
//const char msd_soap_service[] = "http://parrot.ebi.ac.uk:8444"; // .cgi?6758
//const char msd_soap_service[] = "http://www.ebi.ac.uk/msd-srv/msdsoap";
const char msd_soap_service[] = "http://www.ebi.ac.uk/msd-srv/msdsoapd";
//const char msd_soap_service[] = "http://web6-node2.ebi.ac.uk:8444";
//const char msd_soap_service[] = "http://web6-node1.ebi.ac.uk:8555";
const char endpoint[] = "http://websrv.cs.fsu.edu/~engelen/varparam.cgi";
#define N 1000
#define M 8

// Client side root methodes:


//t__root*& t__root::operator[](int i)
//{ static t__root *p = this;   // trick: we don't expect the operator to be applied, but we need a method
//  return p;
//}

#ifndef SO_NOSIGPIPE
// Not present in 10.1.x kernel/headers
#define SO_NOSIGPIPE 0x1022
#endif
static void *dime_write_open(struct soap *soap, const char *id, const char *type, const char *options)
{ FILE *handle = NULL;
  // we can return NULL without setting soap->error if we don't want to use the streaming callback for this DIME attachment
  handle = fopen((char*)soap->user, "wb");
  if (handle)
    printf("Streaming image id=%s type=%s into file %s\n", id, type, (char*)soap->user);
  else
  { soap->error = SOAP_EOF; // could not open file for writing
    soap->errnum = errno; // get reason
  }
  return (void*)handle;
}

static void dime_write_close(struct soap *soap, void *handle)
{ fclose((FILE*)handle);
}

static int dime_write(struct soap *soap, void *handle, const char *buf, size_t len)
{ size_t nwritten;
  while (len)
  { nwritten = fwrite(buf, 1, len, (FILE*)handle);
    if (!nwritten)
    { soap->errnum = errno; // get reason
      return SOAP_EOF;
    }
    len -= nwritten;
    buf += nwritten;
  }
  return SOAP_OK;
}


int main(int argc, char **argv)
{   
 
  struct soap soap;
  xsd__base64Binary bindata;
  char *name;
  const char *url;
  //soap=soap_new();
  soap_init(&soap);
  //soap_set_omode(&soap, SOAP_XML_GRAPH);
  soap.userid="geoff";
  soap.passwd="cc12345678";

  //soap.proxy_port = 8080; 
  //soap_init2(&soap, SOAP_IO_KEEPALIVE, SOAP_IO_KEEPALIVE);
  //soap.socket_flags = MSG_NOSIGNAL;
  //soap.accept_timeout = 300;  
  //soap.send_timeout = 60; 
  //soap.recv_timeout = 60; 
  //soap_set_omode(&soap, SOAP_ENC_ZLIB);
  struct a__Map mi,mi2, mo;
  struct ArrayOfMap Ami, Amo;
  mi.__size = 3;
  mi.__ptr = (struct _item*)soap_malloc(&soap,mi.__size*sizeof(struct _item));
  mi.__ptr[0].key = new xsd__string("Hello");
  mi.__ptr[0].value = new xsd__string("world");
  mi.__ptr[1].key = new xsd__int(2);
  mi.__ptr[1].value = new xsd__boolean(true);
  mi.__ptr[2].key = new xsd__double(788.005670);
  mi.__ptr[2].value = new xsd__string("all right!");

  mi2.__size = 2;
  mi2.__ptr = (struct _item*)soap_malloc(&soap,mi2.__size*sizeof(struct _item));
  mi2.__ptr[0].key = new xsd__string("How are you");
  mi2.__ptr[0].value = new xsd__string("Universe");
  //mi.__ptr[1].key = new xsd__int(2);
  //mi.__ptr[1].value = new xsd__boolean(true);
  mi2.__ptr[1].key = new xsd__float(123.004567);
  mi2.__ptr[1].value = new xsd__int(78654);

  Ami.__size = 2;
  Ami.__ptr = (struct a__Map**)soap_malloc(&soap,Ami.__size*sizeof(struct a__Map*));
  Ami.__ptr[0] = &mi;
  Ami.__ptr[1] = &mi2;
  
  //soap.connect_flags  = SO_NOSIGPIPE; 
  //####struct ns4__varPolyParamTestResponse r;
  //struct t__queryResp rs;
  //ns4__msdExecQueryResponse rs;
  array rs1;
  //array rs2;
  ns4__msdGetResultResponse rs2;
    int n;
    xsd__anyType *p[M];
        xsd__anyType *pp[N];
        char* tmp;
        tmp=(char*)soap_malloc(&soap, strlen(msd_soap_service)+1);
        strcpy(tmp,msd_soap_service);
        p[0] = new xsd__anyURI(tmp);
        tmp=(char*)soap_malloc(&soap, strlen(endpoint)+1);
        strcpy(tmp,endpoint);
    p[1] = new xsd__string(tmp);
    p[2] = new xsd__boolean(false);
    p[3] = new xsd__dateTime(1234567);
    p[4] = new xsd__double(1234567.89);
    p[5] = new xsd__base64Binary("encoded in base64");
    p[6] = new xsd__hexBinary("encoded in hex");
    p[7] = new array(3);
    (*p[7])[0] = new xsd__int(7);
    (*p[7])[1] = new xsd__token("x");
        (*p[7])[2] = new xsd__float(1234.8765);
  //soap->keep_alive = 1; 
    char* tmp1;
        char* tmp2;
        tmp1=(char*)soap_malloc(&soap, strlen(msd_soap_service)+1);
        strcpy(tmp1,msd_soap_service);
        
        tmp2=(char*)soap_malloc(&soap, strlen("http://phoenix.ebi.ac.uk:8099/cgi-bin/msd_soap_service.cgi")+1);
        strcpy(tmp2,"http://phoenix.ebi.ac.uk:8099/cgi-bin/msd_soap_service.cgi");
    for (int n=0;n<N ;++n ){
    pp[n]= new array(12);
        (*pp[n])[0] = new xsd__float(1234.8765);
        (*pp[n])[1] = new xsd__int(7);
    (*pp[n])[2]= new xsd__string(tmp1);
        (*pp[n])[3]= new xsd__float(1234.8765);
        (*pp[n])[4]= new xsd__int(80);
    (*pp[n])[5]= new xsd__string(tmp2);
        (*pp[n])[6]= new xsd__float(99234.8765);
        (*pp[n])[7]= new xsd__int(66);
    (*pp[n])[8]= new xsd__string(tmp1);
        (*pp[n])[9]= new xsd__float(1234.8765);
        (*pp[n])[10]= new xsd__int(2345);
    (*pp[n])[11] = new xsd__string(tmp2);
         //for (int m=0;m<12 ;++m ){
          //(*pp[n])[m]->msd_sym=intern( msdConst("FieldNo"));
     //}
    }
  
  
  
  
  
  
  
  
  if (! &soap)
  {
   printf ("\nCan not allocate environment for Web services.\n");
   return (1);
  }
        //struct soap soap;
    //soap_init(&soap);
  int result;
  t__status stts;
  char* logstr= "api2/api255@msdsrchd"; //"search/search55@msdsrch1";//"api/api55@msdsrchd";
  //char* logstr= "api1/api155@msdsrchd";
  char* logs;
  logs = (char*)soap_malloc(&soap, strlen(logstr)+1);
  strcpy(logs, logstr); 
  char* sql;
  //char* statement="select /*+ INDEX_COMBINE(component component_id) */ *  from component where "
  //                   "component_id >= :f<int> and component_id <= 50000*:f<int>";
  
  //char* statement="select /*+ INDEX_COMBINE(atom_data accession_code) */ *  from WHOUSE1.atom_data where "
  //                   "atom_id >= 1 and atom_id <= 200"; // :f<int>

  char* statement="select *  from WHOUSE1.atom_data where "
                     "where atom_id >= 2010000  and atom_id <= 2016000 and 1*:f<int>=1"; // :f<int>
  
  sql = (char*)malloc(strlen(statement)+1);
  strcpy(sql, statement);
  char *argvNew[5];
  int pid;
  int nomtabs=35;
  printf("Content-type: text/html\r\n\r\n<html><h2>Client for PDBe API Framework Web Services from %s</h2><pre>\n", msd_soap_service);
  
  

  array * app_params;
  app_params = new array(3);
  (*app_params)[0]= new xsd__string("/ebi/msd/work/siamak/apache/cgi-bin/msd_main");
  (*app_params)[1]= new xsd__string(" > ");
  (*app_params)[2]= new xsd__string("/ebi/msd/work/siamak/apache/htdocs/appserv.txt");
  
  
  // Call appserver
  //char* app="/ebi/msd/work/siamak/apache/cgi-bin/msd_main > /ebi/msd/work/siamak/apache/htdocs/appserv.txt";
  //cmdexec = (char*)malloc(strlen(app)+1);
  //strcpy(cmdexec, app);
  
  
  
//~~~~~  if (soap_call_ns4__msdAppserv(soap, msd_soap_service, "urn:msd_soap_service#msdAppserv", 3, app_params, result)== SOAP_OK) //http://parrot.ebi.ac.uk:8099/cgi-bin/msd_soap_service#msdConninit
//~~~~~  { printf ("\nPDBe Application Server Service initialized...\n");
//~~~~~  }
//~~~~~  else
//~~~~~  { printf ("\nPDBe Application Server Service failed...(Error %d) \n", result);
//~~~~~ soap_print_fault(soap, stderr);
//~~~~~    soap_print_fault_location(soap, stderr);
//~~~~~  } 
  //t__status res;
  
  
  

int conn_res = -1;
int conn_resp = -1;
int res_res = -1;
int res_resp = -1;
int qry_res = -1;
int qry_resp = -1;
                                                                                                                                                                                                                //"msdsrchd","api1","api155"
if (soap_call_ns4__msdConnect(&soap, msd_soap_service, "urn:msd_soap_service#msdConnect", "MyConnection", conn_res)== SOAP_OK) //http://parrot.ebi.ac.uk:8099/cgi-bin/msd_soap_service#msdConninit
  { printf ("\nConnect initialized...%d\n", conn_res);
  conn_resp=0;
  }
  else
  { printf ("Connect failed ...(Error) %d \n", conn_res);
    conn_resp = 1;
        soap_print_fault(&soap, stderr);
    soap_print_fault_location(&soap, stderr);
  } 

if (conn_res == 0 && conn_resp == 0)
{if (soap_call_ns4__msdResultset(&soap, msd_soap_service, "urn:msd_soap_service#msdResultset", "MyConnection","MyQuery","MyResult", res_res)== SOAP_OK) //http://parrot.ebi.ac.uk:8099/cgi-bin/msd_soap_service#msdConninit
  { printf ("\nmsdResultset Set initialized...%d\n", res_res);
  res_resp=0;
  }
  else
  { printf ("msdResultset failed ...(Error) %d \n", res_res);
  res_resp =1;
        soap_print_fault(&soap, stderr);
    soap_print_fault_location(&soap, stderr);
  } 
}else
        { printf ("\nmsdResultset Set not called.\n");
    }




if (conn_resp == 0 && res_resp == 0)
{if (soap_call_ns4__msdQuery(&soap, msd_soap_service, "urn:msd_soap_service#msdQuery", "MyConnection","MyQuery","MyResult",sql, qry_res)== SOAP_OK) //http://parrot.ebi.ac.uk:8099/cgi-bin/msd_soap_service#msdConninit
  { printf ("\nmsdQuery called...%d\n", qry_res);
  qry_resp=0;
  }
  else
  { printf ("msdQuery failed ...(Error) %d \n", qry_res);
  qry_resp=1;
        soap_print_fault(&soap, stderr);
    soap_print_fault_location(&soap, stderr);
  } 

}else
        {printf ("\nmsdQuery not called.\n");
}


//~~~~*****if (soap_call_ns4__varPolyParamTest(&soap, msd_soap_service, "urn:msd_soap_service#varPolyParamTest", N, pp, r))
//~~~~*****      soap_print_fault(&soap, stderr);
//~~~~*****    else
//~~~~*****    {    ofstream outfile;
//~~~~*****         outfile.open("exec_queryClient.txt");
//~~~~*****              outfile << "Server has echoed:" << endl;
//~~~~*****              for (int i = 0; i < r.__size; i++)
//~~~~*****          {outfile << "p[" << i << "] = ";
//~~~~*****                pp[i]->print(outfile);
//~~~~*****                outfile << endl;
//~~~~*****                outfile << "r.param[" << i << "] = ";
//~~~~*****                r.param[i]->print(outfile);
//~~~~*****                outfile <<endl;
//~~~~*****           }
//~~~~*****         outfile.close();
//~~~~*****       
//~~~~*****       
//~~~~*****      
//~~~~*****    }
//~~~~*****    for (int i = 0; i < N; i++){
//~~~~*****               delete pp[i];
//~~~~*****     }
//~~~~*****  { if (soap_call_ns4__varStringParamTest(&soap, msd_soap_service, "urn:msd_soap_service#varStringParamTest", argc, argv, n))
//~~~~*****      soap_print_fault(&soap, stderr);
//~~~~*****    else
//~~~~*****      printf("Server has responded to %d strings\n", n);
//~~~~*****  }
//~~~~*****  



 int status= -1;
 int exec_resp=-1;
 //soap.keep_alive=0;
 if (conn_resp == 0 && res_resp == 0 && qry_resp == 0){
  soap.userid="geoff";
  soap.passwd="cc12345678";
 if (soap_call_ns4__msdExecQuery(&soap, msd_soap_service, "urn:msd_soap_service#msdExecQuery", "MyConnection","MyQuery","MyResult",50, status)== SOAP_OK) //http://parrot.ebi.ac.uk:8099/cgi-bin/msd_soap_service#msdConninit
  { printf ("\nmsdExecQuery initialized...%d\n", status);
    exec_resp=0;
  } 
  else 
   {printf ("msdExecQuery failed ...(Error %d)\n", status);
    exec_resp=1;
        soap_print_fault(&soap, stderr);
    soap_print_fault_location(&soap, stderr);}
 }else{printf ("msdExecQuery not called.\n");
}

int get_resp=-1;
if (exec_resp == 0)
{if (soap_call_ns4__msdGetResult(&soap, msd_soap_service, "urn:msd_soap_service#msdGetResult", "MyConnection","MyQuery","MyResult", rs2)) //http://parrot.ebi.ac.uk:8099/cgi-bin/msd_soap_service#msdConninit
  { printf ("GetResult failed ...(Error)\n");
    get_resp=1;
        soap_print_fault(&soap, stderr);
    soap_print_fault_location(&soap, stderr);
  } 
  else 
   {printf ("\nGetResult initialized...\n");
    get_resp=0;
        //ofstream outfile;
    //outfile.open("GetResultClient.txt");
    //outfile << "Server has echoed:" << endl;
    for (int i = 0; i < rs2.rs.cols; i++){ //__size
     //outfile << "rs.rs.__ptr[" << i << "] = ";
     for (int j = 0;j < rs2.rs.rows; j++)
     { rs2.rs.prs[i][j].print(std::cout); //__ptr[i]

     }
         //rs.__ptr[i]->fprint(outfile);
        
     //outfile <<endl;
    }
     //outfile.close();
}
}else{printf ("msdGetResult not called.\n");
}

int ou = -1;
if (get_resp == 0)
{if (soap_call_ns4__msdEndQueryPack(&soap, msd_soap_service, "urn:msd_soap_service#msdEndQueryPack", "MyQuery","MyResult", ou) == SOAP_OK) //http://parrot.ebi.ac.uk:8099/cgi-bin/msd_soap_service#msdConninit
  { printf ("\nEndSession initialized...%d\n", ou);
         
  } 
  else 
   { printf ("msdEndQueryPack failed ...(Error %d)\n", ou);
        soap_print_fault(&soap, stderr);
    soap_print_fault_location(&soap, stderr);
   }
   

}



//~~~~~~~if ((soap_call_ns4__msdExecQuery2(&soap, msd_soap_service, "urn:msd_soap_service#msdExecQuery2", "MyConnection","MyQuery","MyResult",50,sql,rs)) && qry_res != 0) //http://parrot.ebi.ac.uk:8099/cgi-bin/msd_soap_service#msdConninit
//~~~~~~~  { printf ("Query failed ...(Error)\n");
//~~~~~~~   status = 1;
//~~~~~~~       soap_print_fault(&soap, stderr);
//~~~~~~~    soap_print_fault_location(&soap, stderr);
//~~~~~~~  } 
//~~~~~~~  else 
//~~~~~~~   {printf ("\nQuery initialized...\n");
//~~~~~~~  status = 0;
//~~~~~~~       ofstream outfile;
//~~~~~~~    outfile.open("exec_queryClient2.txt");
//~~~~~~~    outfile << "Server has echoed:" << endl;
//~~~~~~~    for (int i = 0; i < rs.__size; i++){
//~~~~~~~     outfile << "rs.rs.__ptr[" << i << "] = ";
//~~~~~~~     rs.__ptr[i]->fprint(outfile);
//~~~~~~~        rs.__ptr[i]->print(std::cout);
//~~~~~~~     outfile <<endl;
//~~~~~~~    }
//~~~~~~~     outfile.close();
//~~~~~~~}
 




 
  //t__object obj;
//~~  t__status status;
//~~  
//~~  if (soap_call_ns4__create(soap, msd_soap_service, "urn:msd_soap_service#create", OTLCONNECT , "MyConnection", status)== SOAP_OK) //http://parrot.ebi.ac.uk:8099/cgi-bin/msd_soap_service#msdConninit
//~~  { printf ("\nCreated...%d\n", status);
//~~  }
//~~  else
//~~  { printf ("Create failed ...(Error)%d \n", status);
//~~    soap_print_fault(soap, stderr);
//~~    soap_print_fault_location(soap, stderr);
//~~  } 
//~~if (soap_call_ns4__lookup(soap, msd_soap_service, "urn:msd_soap_service#lookup", OTLCONNECT , "MyConnection", status)== SOAP_OK) //http://parrot.ebi.ac.uk:8099/cgi-bin/msd_soap_service#msdConninit
//~~  { printf ("\nlookup successed...%d\n", status);
//~~  }
//~~  else
//~~  { printf ("lookup failed ...(Error) %d \n", status);
//~~    soap_print_fault(soap, stderr);
//~~    soap_print_fault_location(soap, stderr);
//~~  } 


//~~~~~~~~ if(soap_call_ns4__msdGetTables_relations(soap, msd_soap_service, "urn:msd_soap_service#msdGetTablesRelations",logs,result)== SOAP_OK)
//~~~~~~~~  { printf ("\nSuccessfull Getting Relations...\n");
//~~~~~~~~  }
//~~~~~~~~  else
//~~~~~~~~  { printf ("Getting relations failed...(Error %d) \n", result);
//~~~~~~~~      soap_print_fault(soap, stderr);
//~~~~~~~~    soap_print_fault_location(soap, stderr);
//~~~~~~~~  }
//~~~~~~~~  if(soap_call_ns4__msdGetDatamodel(soap, msd_soap_service, "urn:msd_soap_service#msdGetDatamodel", logs,result)== SOAP_OK)
//~~~~~~~~  { printf ("\nSuccessfull Getting Data Model...\n");
//~~~~~~~~  }
//~~~~~~~~  else
//~~~~~~~~  { printf ("Getting Data Model failed...(Error %d) \n", result);
//~~~~~~~~      soap_print_fault(soap, stderr);
//~~~~~~~~    soap_print_fault_location(soap, stderr);
//~~~~~~~~  }
//~~~~~~~~  
//~~~~~~~~  //if(soap_call_ns4__msdLispEval(soap, msd_soap_service, "urn:msd_soap_service#msdLispEval",result)== SOAP_OK)
//~~~~~~~~  //{ printf ("\nSuccessfull System Call...\n");
//~~~~~~~~  // }
//~~~~~~~~  //else
//~~~~~~~~  //{ printf ("System call  failed...(Error %d) \n", result);
//~~~~~~~~  //  soap_print_fault(soap, stderr);
//~~~~~~~~  //  soap_print_fault_location(soap, stderr);
//~~~~~~~~  //}
//~~~~~~~~  /////////////////////////////////////////////////

//~~#######    soap.user = (void*)argv[1]; // soap.user is always available for user data
//~~#######    soap.fdimewriteopen = dime_write_open;
//~~#######    soap.fdimewriteclose = dime_write_close;
//~~#######    soap.fdimewrite = dime_write;
//~~#######    name = argv[1];  // this is the name of the image
//~~#######     // second argument is optional endpoint URL
//~~#######    soap.connect_timeout = 10;
//~~#######      if (soap_call_ns4__msdGetDime(&soap, msd_soap_service, "urn:msd_soap_service#msdGetDime", 1, name, bindata))
//~~#######      soap_print_fault(&soap, stderr);
//~~#######     else 
//~~#######      printf("Got file type=%s through streaming DIME\n", bindata.type?bindata.type:""); // image.__ptr = file handle and image.__size == 0 when streaming was used
//~~#######  
//~~#######  
//~~#######  
//~~#######  
//~~#######
//~~#######
//~~#######  int i, j, g;
//~~#######  ofstream outfile;
//~~#######  outfile.open("Map.txt", ofstream::out | ofstream::app);
//~~#######  if (soap_call_ns4__echoMap(&soap, msd_soap_service, "urn:msd_soap_service#echoMap", mi, mo))
//~~#######  { printf("echoMap FAULT...");
//~~#######    
//~~#######    soap_print_fault(&soap, stderr);
//~~#######    soap_print_fault_location(&soap, stderr);
//~~#######    
//~~#######  }
//~~#######  else
//~~#######  { g = 0;
//~~#######    if (mi.__size != mo.__size || !mo.__ptr)
//~~#######      g = 1;
//~~#######    else
//~~#######    { 
//~~#######      
//~~#######             for (i = 0; i < mi.__size; i++){
//~~#######        outfile << "mi.__ptr[" << i << "] = ";
//~~#######        mi.__ptr[i].key->print(outfile);
//~~#######             outfile <<" , ";
//~~#######         mi.__ptr[i].value->print(outfile);
//~~#######             outfile <<endl;
//~~#######         //printf( "%s" , mi.__ptr[i].key->__item); // need to check values here!
//~~#######         //printf( "%s" , mi.__ptr[i].value->__item);
//~~#######             }
//~~#######             
//~~#######    }
//~~#######    if (g==1)
//~~#######    { printf("Maps differ...");
//~~#######    }
//~~#######    else{
//~~#######             
//~~#######     
//~~#######             for (i = 0; i < mo.__size; i++){ // need to check values here!
//~~#######         outfile << "mo.__ptr[" << i << "] = ";
//~~#######         mo.__ptr[i].key->print(outfile);
//~~#######              outfile <<" , ";
//~~#######          mo.__ptr[i].value->print(outfile);
//~~#######              outfile <<endl;
//~~#######         }
//~~#######             
//~~#######        printf("PASS\n");
//~~#######     } 
//~~#######  }
//~~#######
//~~#######  if (soap_call_ns4__echoMapArray(&soap, msd_soap_service, "urn:msd_soap_service#echoMapArray", Ami, Amo))
//~~#######  { printf("echoMapArray FAULT...");
//~~#######    
//~~#######    soap_print_fault(&soap, stderr);
//~~#######    soap_print_fault_location(&soap, stderr);
//~~#######   
//~~#######  }
//~~#######  else
//~~#######  { g = 0;
//~~#######    if (Ami.__size != Amo.__size || !Amo.__ptr)
//~~#######      g = 1;
//~~#######    else
//~~#######    { for (i = 0; i < Ami.__size; i++){
//~~#######        outfile << "Ami.__ptr[" << i << "] = ";  // need to check values here
//~~#######        for (j = 0; j < Ami.__ptr[i]->__size; j++){
//~~#######              Ami.__ptr[i]->__ptr[j].key->print(outfile);
//~~#######              outfile <<" , ";
//~~#######          Ami.__ptr[i]->__ptr[j].value->print(outfile);
//~~#######              outfile <<endl;
//~~#######             }
//~~#######       }
//~~#######    }
//~~#######    if (g)
//~~#######    {printf("Map Arrays differ...");
//~~#######    }
//~~#######    else{
//~~#######      printf("PASS\n");
//~~#######     }
//~~#######  }
//~~#######  outfile.close();
//~~#######  
//~~#######  
//~~#######  
  
  
  
  
  printf("</pre></html>\n");
  //soap_dealloc(&soap,NULL);
  //soap_destroy(&soap);
  soap_end(&soap);
  soap_free(&soap);
  soap_done(&soap);
  return 0;
}

//
//      Namespace Definition Table
//

//struct Namespace namespaces[] =  
//{   // {"ns-prefix", "ns-name" [, "ns-pattern"]}  
//   {"SOAP-ENV", "http://schemas.xmlsoap.org/soap/envelope/"},  
//   {"SOAP-ENC", "http://schemas.xmlsoap.org/soap/encoding/"},  
//   {"xsi", "http://www.w3.org/2001/XMLSchema-instance", "http://www.w3.org/*/XMLSchema-instance"},  
//   {"xsd", "http://www.w3.org/2001/XMLSchema", "http://www.w3.org/*/XMLSchema"},  
//   {"t", "urn:msd_soap_types"},
//   {"h", "urn:msd_soap_handles"},
//   {"ns", "urn:msd_soap_service"},
//   {NULL, NULL}  
//};

---