// serwer corbowy pod mico/C++ (12.2015)
//

#include <iostream>
#include <fstream>
#include <CORBA.h>
#include "Hello.h"
     
using namespace std;

class HelloImpl 
  : virtual public ::POA_HelloApp::Hello {
public:
  int licznik;
  ::HelloApp::long_seq_box* seq;

  HelloImpl() { 
    licznik= 0; seq= 0;
  }
  ~HelloImpl() { 
    CORBA::remove_ref(seq);
  }

  ::HelloApp::long_seq* met1( const ::HelloApp::long_seq& s1 ) {
    int s1_len= s1.length();
    ::HelloApp::long_seq* s2w= new ::HelloApp::long_seq;
    s2w->length(s1_len);
    *s2w= s1;
    return s2w;
  }

  CORBA::Any* zwrocCokolwiek( CORBA::Long tryb ) {
    CORBA::Any* a= new CORBA::Any;
    if (tryb==1) {
      (*a) <<= (CORBA::Long)123;
    }
    if (tryb==2) {
      (*a) <<= "qqq www eee";
        // na pewno deep copying ????
    }
    if (tryb==3) {
      ::HelloApp::long_seq s;
      s.length(3);
      s[0]= 111;
      s[1]= 222;
      s[2]= 333;
      (*a) <<= s;
        // na pewno deep copying ????
    }
    if (tryb==4) {
      ::HelloApp::long_seq_box* sb= new ::HelloApp::long_seq_box;
      //(*a) <<= sb->_value();
        // to dziala, ale chyba nie o to chodzi...
      //(*a) <<= sb;
        // to sie, niestety, nie kompiluje pod mico...
	// nie da sie tego zrobic ?!?!?!?!?
	// moze to blad gcc/mico (ze ta linia sie nie kompiluje) ?!
      ::HelloApp::long_seq& s= sb->_value();
      s.length(2);
      s[0]= 1111;
      s[1]= 2222;
      (*a) <<= sb->_value();
      CORBA::remove_ref(sb);
        // tak sie usuwav VT i VB !!!
	// (nie mozna przez delete lub zm. automat. !)
	// jest tez CORBA::add_ref() ...
	// po new refcount==1 (ze specyfikacji C++/Corba !)
    }
    return a;
  }

  // seq - to pole serwanta;
  //   uzywamy go do "podczepiania" arg metody pod serwanta
  //   zarzadzanie pamiecia przy pomocy refcount, 
  //     dlatego uzywamy long_seq_box, a nie long_seq...
  //
  void zapiszSeq( ::HelloApp::long_seq_box* s1 ) {
    CORBA::remove_ref(seq); // usuwamy poprzedni ob. podczepiony pod seq
    CORBA::add_ref(s1); // refcount ++
    seq= s1;
  }
  ::HelloApp::long_seq_box* odczytajSeq() {
    CORBA::add_ref(seq); // bez tego ob. by zniknal...
    return seq;
  }
  void pomnozRazy( CORBA::Double wsp ) {
    if (seq==0) return;
    ::HelloApp::long_seq& s=  seq->_value(); 
      // "s" to ref. C++-owa do "zawartosci" ob. seq
      // ta zawartosc jest typu long_seq
    int len= s.length();
    for(int i=0; i<len; i++) s[i]*=wsp;
  }


};

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);
    PortableServer::POAManager_var mgr = poa->the_POAManager();
    mgr->activate();

    HelloImpl hello_servant;
    CORBA::Object_var hello_obj= poa->servant_to_reference(&hello_servant);
    CORBA::String_var s= orb->object_to_string(hello_obj);
    
    // okazuje sie ze w przypadku ValueBox nie jest konieczna fabryka VT !!!
    //   jest konieczna dla "zwyklych" valuetypes...

    ofstream plik; plik.open("Hello.ior", ios::out|ios::trunc);
    plik << s << endl;

    orb->run();
  } catch (...) {cout << "ERROR" << endl;}
}