#
# javaIDL: typ "any"
#

# - dane Any tworzy sie przy pomocy DynAny
# - DynAny tworzy sie przy pomocy pseudoob. "DynAnyFactory" oraz TypeCode
# - TypeCode tworzy sie z $orb
# - jest to b. uciazliwe ...
# - DynAny jest opisane w 9 rozdz spec Corba2.3 !!!

# - metody DynAnyFactory:
#     create_dyn_any org.omg.CORBA.Any
#       + ogladanie istniejacego Any
#     create_dyn_any_from_type_code org.omg.CORBA.TypeCode
#       + tworzenie nowego Any

# - przy tworzeniu/ czytaniu Any
#   patrzymy na strukture danych jako na plaski ciag elementow/pol
#   wstawiamy je przez DynAny.next; DynAny.insert_*
#   czytamy przez DynAny.next; DynAny.get_*

# - podobnie do create_array_tc() dziala create_sequence_tc()
#   inne met. create_*_tc ???

# ---
package re java

set args [java::new {String[]} {} ""]
set orb [java::call org.omg.CORBA.ORB init $args [java::null]]
set daf [$orb resolve_initial_references "DynAnyFactory"]
set daf [java::call org.omg.DynamicAny.DynAnyFactoryHelper narrow $daf]
  # pobieramy ref do pseudoob. "DynAnyFactory"

# proc zwracajaca TC dla typu prostego
# args:
#   t = typ prosty, np long
proc getSimpleTC t {
  $::orb get_primitive_tc [java::field org.omg.CORBA.TCKind tk_$t]
}

# proc upraszczjaca tworzenie tabl. StructMember
# args:
#   spec = "pole1 TC1 pole2 TC2 ..."
# uwagi:
#   tc MUSZA byc w zmiennych!!! (wada tclBlend)
proc getStructMembers spec {
  set sm [java::new {org.omg.CORBA.StructMember[]} [expr {[llength $spec]/2}]]
  set i 0
  foreach {p tc} $spec {
    set e [java::new org.omg.CORBA.StructMember]
    $sm set $i $e
    java::field $e name $p
    java::field $e type $tc
    incr i
  }
  return $sm
}



## tworzenie tablicy ($orb create_array_tc)
#

set tc1 [$orb create_array_tc 30 [getSimpleTC float]]
  # 30 oznacza rozmiar tablicy (powinien byc >0)
  # tworzy TypeCode opisujace tablice 30 floatow

set dyn1 [$daf create_dyn_any_from_type_code $tc1]
  # tworzymy DynAny na podstawie TypeCode

$dyn1 component_count
  #% 30

# wypelniamy DynAny trescia ...
$dyn1 rewind
$dyn1 insert_float 123
$dyn1 next
$dyn1 insert_float 321

$dyn1 rewind
$dyn1 get_float
  #% 123.0
$dyn1 next
$dyn1 get_float
  #% 321.0

set a1 [$dyn1 to_any]
  # wyciagniecie Any z DynAny
  # $a1 to Any ...

[$a1 type] toString
  #% com.sun.corba.se.internal.corba.TypeCodeImpl@1e04cbf =
array[30]  = {
  float
}


## tworzenie struktury ($orb create_struct_tc)
#
if 0 {
TypeCode create_struct_tc(
	String id,
        String name,
        StructMember[] members)
Parameters:
	id - the repository id for the struct
	name - the name of the struct
	members - an array describing the members of the struct
}

# tworzymy opis pol struct...
set sm [java::new {org.omg.CORBA.StructMember[]} 2]
$sm set 0 [java::new org.omg.CORBA.StructMember]
$sm set 1 [java::new org.omg.CORBA.StructMember]
java::field [$sm get 0] name "a"
java::field [$sm get 0] type [getSimpleTC long]
java::field [$sm get 1] name "b"
java::field [$sm get 1] type [getSimpleTC float]

set tc2 [$orb create_struct_tc "IDL:mojastruct:1.0" "mojastruct" $sm]
  # tworzy TC opisujace strukture z dwoma polami...

set dyn2 [$daf create_dyn_any_from_type_code $tc2]

$dyn2 component_count
  #% 2

# wypelniamy struct trescia
$dyn2 rewind
$dyn2 insert_long 123
$dyn2 next
$dyn2 insert_float 123.123

# odczytujemy strukture
$dyn2 rewind
$dyn2 get_long
  #% 123
$dyn2 next
$dyn2 get_float
  #% 123.123001099
$dyn2 next
  #% 0
  # next zwraca bool: czy jest jeszcze jakis element

#join [java::info meth $dyn2] \n

set a2 [$dyn2 to_any]

[$a2 type] toString
  #% com.sun.corba.se.internal.corba.TypeCodeImpl@161f10f =
struct mojastruct = {
  long  a;
  float  b;
}


## zagniezdzenie struktury i tablicy
# - niezbedne jest DynAny.current_component podczas wypelniania trescia...
# - w tym przykladzie sa wystarczajace narzedzia do utworzenia
#   dowolnej/drzewiastej str. danych!!
#
set tc_a [getSimpleTC long]
set tc_b [$orb create_array_tc 10 [getSimpleTC float]]
set sm [getStructMembers "
  a $tc_a
  b $tc_b
"]; # (tc MUSI byc w zmiennej z uwagi na tclBlend!)

set tc3 [$orb create_struct_tc "IDL:mojastruct:1.0" "mojastruct" $sm]
set dyn3 [$daf create_dyn_any_from_type_code $tc3]
$dyn3 component_count
  #% 2

# wypelniamy trescia ...
$dyn3 seek 0
$dyn3 insert_long 123
$dyn3 seek 1
set dyn3a [$dyn2 current_component]
  # teraz wypelniamy trescia pole "b" - tablice...
$dyn3a rewind
$dyn3a insert_float 123.123
$dyn3a next
$dyn3a insert_float 321.321


## tworzenie sekwencji
# - zanim uzyjesz insert_* najpierw ustal dlugosc sekw. przez set_lenght !!!
#
if 0 {
TypeCode create_sequence_tc(
	int bound,
        TypeCode element_type)
Parameters:
	bound - the bound for the sequence, 0 if unbounded
	element_type - the TypeCode object describing the elements contained in the sequence
}

set tc1 [$orb create_sequence_tc 0 [getSimpleTC float]]
set dyn1 [$daf create_dyn_any_from_type_code $tc1]
set dyn1 [java::call org.omg.DynamicAny.DynSequenceHelper narrow $dyn1]
java::info class $dyn1
  #% org.omg.DynamicAny.DynSequence

$dyn1 set_length 3
  # tu ustalamy dlugosc sekwencji!!!

$dyn1 rewind
$dyn1 insert_float 111.111
$dyn1 next
$dyn1 insert_float 111.222
$dyn1 next
$dyn1 insert_float 111.333
$dyn1 next
  #% 0

#join [java::info meth $dyn1] \n