// + co do wyciekow pamieci: spojrz do Hello2.cc...
//
#include <iostream>
//#include <stdlib.h>
#include <CORBA.h>
#include "Hello2.h"
using namespace std;
// impl. VT qqq oraz fabryki VT qqq
class qqqImpl
: virtual public ::OBV_HelloApp::qqq,
virtual public ::CORBA::DefaultValueRefCountBase {
public:
qqqImpl() {}
void nic() {}
};
class qqqFactoryImpl
: virtual public ::CORBA::ValueFactoryBase {
public:
CORBA::ValueBase*
create_for_unmarshal() {
return new qqqImpl;
}
};
class HelloImpl
: virtual public ::POA_HelloApp::Hello {
public:
int licznik;
HelloImpl() {
licznik= 0;
}
char* sayHello() {
return CORBA::string_dup("a ku ku !!!");
}
char* sayHello2( const char* we ) {
exit(0); // chwilowo, na uzytek valgrind-a
return 0;
}
CORBA::Long podajLiczbe() {
return licznik++;
}
::HelloApp::Hello::long_seq* met1( const ::HelloApp::Hello::long_seq& s1 ) {
int s1_len= s1.length();
::HelloApp::Hello::long_seq* s2w= new ::HelloApp::Hello::long_seq;
// czy na pewno nie powinnismy tego zwalniac ???
// jak sprawdz. czy nie ma wycieku pamici? (valgrind??)
// wszyst. jedno czy sa "()" przy new...
s2w->length(s1_len);
// to jest konieczne ? (nawet jesli robic *ws2= s1;)
// bez tego jest segm. fault ?!?!?!?!
//for (int i=0; i<s1_len; i++) (*ws2)[i]=s1[i];
// czy nie da sie prosciej przepisac? np. *ws2= s1; TAK!!
*s2w= s1;
if (s1_len>=2) {
(*s2w)[0]= 123;
(*s2w)[1]= 321;
}
return s2w;
}
::HelloApp::Hello::macierz* zwrocMacierz( CORBA::Long w, CORBA::Long k ) {
// w - l. wierszy, k - l. kolumn
::HelloApp::Hello::macierz *mac= new ::HelloApp::Hello::macierz;
mac->length(w); for(int i=0; i<w; i++) (*mac)[i].length(k);
// mamy pusta macierz (przypadkowe wartosci!)
for(int i=0; i<w; i++)
for(int j=0; j<k; j++)
(*mac)[i][j]=123.123;
return mac;
}
::HelloApp::Hello::S_arr_slice* met2(
const ::HelloApp::Hello::S_arr v1
) {
::HelloApp::Hello::S_arr_slice* ret= ::HelloApp::Hello::S_arr_alloc();
// KONIECZNIE trzeba uzyc S_arr_alloc() !!!
/*
ret[0].i1= 123;
ret[0].s1= (const char*)"A ku ku 1";
ret[1].i1= 123;
ret[1].s1= (const char*)"A ku ku 2";
ret[2].i1= 123;
ret[2].s1= (const char*)"A ku ku 3";
// ok
// uwaga: tu NIE nalezy uzywac (*ret) !!!
*/
for(int i=0; i<3; i++) ret[i]= v1[i];
// tutaj ret i v1 to normalne tablice (a nie przec. op. []) !
// nie ma lepszej metody kopiowania v1 do ret... ?
return ret;
}
::HelloApp::Hello::S_seq* met3( const ::HelloApp::Hello::S_seq& v1 ) {
::HelloApp::Hello::S_seq* ret= new ::HelloApp::Hello::S_seq;
ret->length(v1.length());
*ret= v1;
return ret;
}
::HelloApp::qqq* met4( ::HelloApp::qqq* v1 ) {
::HelloApp::qqq* ret= new qqqImpl;
// qqqImpl dziedziczy m.in. z ::OBV_HelloApp::qqq
// ale ::OBV_HelloApp::qqq jest cialge klasa abstrak.
// dlatego trzeba dziedziczyc jeszcze z czegos!!
// przekazywanie VT przez par v1
// zacznie dzialac dopiero po zarejestrowaniu factory !!
if(v1!=0)
ret->i1(v1->i1());
else
ret->i1(123);
ret->s1("A ku ku !!!");
return ret;
}
};
int main(int argc, char ** argv)
{
try {
CORBA::ORB_ptr orb= CORBA::ORB_init(argc, argv);
CORBA::Object_var poaobj= orb->resolve_initial_references("RootPOA");
PortableServer::POA_var poa = PortableServer::POA::_narrow(poaobj);
CORBA::release(poaobj);
PortableServer::POAManager_var mgr = poa->the_POAManager();
mgr->activate();
qqqFactoryImpl* fact= new qqqFactoryImpl;
orb->register_value_factory("IDL:HelloApp/qqq:1.0", fact);
// dopiero po zarej. tej fabryki
// zaczna dziala VT przychodzace do serwera!!
HelloImpl hello_servant;
CORBA::Object_var hello_obj= poa->servant_to_reference(&hello_servant);
cout << orb->object_to_string(hello_obj) << endl;
// string zwracany przez object_to_string trzeba zwalniac!!
// podobnie ref do ob. Corby - specyfika C++...
cout << "przed orb->run()" << endl;
orb->run();
cout << "po orb->run()" << endl;
} catch (...) {cout << "ERROR" << endl;}
}