Conference pamsrc::objectbroker_development

2459.0. "QuickStart: two problems" by STKAI1::T_ANDERSSON (Tomas Andersson) Mon Mar 24 1997 04:29

 The following problem occurs with QuickStart, OBB v2.7-11 and NT v4.0.

 The IDL file listed below contains three interfaces, CTest1 - CTest3.
 CTest1 objects are related to a number of CTest2 objects, which in
 turn are related to a number of CTest3 objects. The relationships
 have been modelled in the form of a sequence attribute. Because
 QuickStart does not support sequences of objects, we are dealing
 with a sequence of longs, and a getObjTestX() which takes an index
 as an argument.

	typedef sequence<long> seqCTest3;
	attribute seqCTest3 hasTest3Objects;

 The problem is that the source code generated for the second 'has'
 attribute features a spelling error(?).

 The source code for hasTest2Objects is correct:

	OBB_QUICK_LOGTXT ("unbound sequence ret_hasTest2Objects");
	OBB_QUICK_LOGPARAM (format_ulong, OBB_QUICK_INDENT * 4,
	"ret_hasTest2Objects->_maximum", ret_hasTest2Objects->maximum());
	OBB_QUICK_LOGPARAM (format_ulong, OBB_QUICK_INDENT * 4,
	"ret_hasTest2Objects->_length", ret_hasTest2Objects->length());
	for( int k1 = 0 ; k1 < 5 ; k1++ ) {
        	OBB_QUICK_PRINTF((logfile, "        hasTest2Objects[%d]: "
		OBB_PF_LONG "\n", k1, (* ret_hasTest2Objects)[k1]));
	} // for( k1 )

 But the source code for hasTest3Objects appears to be incorrect:

	OBB_QUICK_LOGTXT ("unbound sequence hasTest3Objects");
	OBB_QUICK_LOGPARAM (format_ulong, OBB_QUICK_INDENT * 4,
	"hasTest3Objects->_maximum", hasTest3Objects->maximum());
	OBB_QUICK_LOGPARAM (format_ulong, OBB_QUICK_INDENT * 4,
	"hasTest3Objects->_length", hasTest3Objects->length());
	for( int k2 = 0 ; k2 < 5 ; k2++ ) {
        	OBB_QUICK_PRINTF((logfile, "        hasTest3Objects[%d]: "
		OBB_PF_LONG "\n", k2, (* ret_hasTest3Objects)[k2]));
	} // for( k2 )

 Note e.g. 'hasTest3Objects->_maximum', which ought to be
 'ret_hasTest3Objects->_maximum'?!?

 Of course, it's easy to modify the code manually before compilation.



 The second problem occurs e.g. when the server returns zero items
 in an output sequence. The following example illustrates the
 dilemma: 

    OBB_QUICK_LOGTXT ("unbound sequence ret_hasTest2Objects");
    OBB_QUICK_LOGPARAM (format_ulong, OBB_QUICK_INDENT * 4,
"ret_hasTest2Objects->_maximum", ret_hasTest2Objects->maximum());
    OBB_QUICK_LOGPARAM (format_ulong, OBB_QUICK_INDENT * 4,
"ret_hasTest2Objects->_length", ret_hasTest2Objects->length());
    for( int k1 = 0 ; k1 < 5 ; k1++ ) {
        OBB_QUICK_PRINTF((logfile, "        hasTest2Objects[%d]: "
OBB_PF_LONG "\n", k1, (* ret_hasTest2Objects)[k1]));
    } // for( k1 )

 This will crash because the '5' in the for loop is hard coded here.
 From our perspective, it would certainly be nice if the '5' was
 replaced with '(CORBA::Long)ret_hasOperations->length()'...



 Here are the IDL and CXX files:

====================================
OBJATTR.IDL
====================================

module objattr
{
  typedef sequence<long> seqCTest2;
  typedef sequence<long> seqCTest3;
  interface CTest2;
  interface CTest3;

  interface CTest1 {
    attribute long aLongAttr;

    attribute seqCTest2 hasTest2Objects;
    CTest2 getObjTest2(in long index);
  };

  interface CTest2 {
    attribute short aShortAttr;
    attribute CTest1 itsTest1Object;

    attribute seqCTest3 hasTest3Objects;
    CTest3 getObjTest3(in long index);
  };

  interface CTest3 {
    attribute float aFloatAttr;

    attribute CTest2 itsTest2Object;
  };

};
#pragma repository_id( "objattr::seqCTest2",
"7b7b569a9e43.02.9d.60.dd.a7.00.00.00")
#pragma repository_id( "objattr::seqCTest3",
"7b7b569a9e44.02.9d.60.dd.a7.00.00.00")
#pragma interface_id( "objattr::CTest1",
"7b7b569a9e45.02.9d.60.dd.a7.00.00.00")
#pragma attribute_id( "objattr::CTest1::aLongAttr",
"7b7b569a9e46.02.9d.60.dd.a7.00.00.00", 1,
"7b7b569a9e47.02.9d.60.dd.a7.00.00.00", 2)
#pragma attribute_id( "objattr::CTest1::hasTest2Objects",
"7b7b569a9e48.02.9d.60.dd.a7.00.00.00", 3,
"7b7b569a9e49.02.9d.60.dd.a7.00.00.00", 4)
#pragma operation_id( "objattr::CTest1::getObjTest2",
"7b7b569a9e4a.02.9d.60.dd.a7.00.00.00", 5)
#pragma interface_id( "objattr::CTest2",
"7b7b569a9e4b.02.9d.60.dd.a7.00.00.00")
#pragma attribute_id( "objattr::CTest2::aShortAttr",
"7b7b569a9e4c.02.9d.60.dd.a7.00.00.00", 1,
"7b7b569a9e4d.02.9d.60.dd.a7.00.00.00", 2)
#pragma attribute_id( "objattr::CTest2::itsTest1Object",
"7b7b569a9e4e.02.9d.60.dd.a7.00.00.00", 3,
"7b7b569a9e4f.02.9d.60.dd.a7.00.00.00", 4)
#pragma attribute_id( "objattr::CTest2::hasTest3Objects",
"7b7b569a9e50.02.9d.60.dd.a7.00.00.00", 5,
"7b7b569a9e51.02.9d.60.dd.a7.00.00.00", 6)
#pragma operation_id( "objattr::CTest2::getObjTest3",
"7b7b569a9e52.02.9d.60.dd.a7.00.00.00", 7)
#pragma interface_id( "objattr::CTest3",
"7b7b569a9e53.02.9d.60.dd.a7.00.00.00")
#pragma attribute_id( "objattr::CTest3::aFloatAttr",
"7b7b569a9e54.02.9d.60.dd.a7.00.00.00", 1,
"7b7b569a9e55.02.9d.60.dd.a7.00.00.00", 2)
#pragma attribute_id( "objattr::CTest3::itsTest2Object",
"7b7b569a9e56.02.9d.60.dd.a7.00.00.00", 3,
"7b7b569a9e57.02.9d.60.dd.a7.00.00.00", 4)

====================================
OBJATTRCLIENT.CXX
====================================

#if defined(OBB_QUICK)
/*******************************************************************
 * Created Mon Mar 17 11:05:08 1997 by OBB V2.7-11 (COMPILE/GENERATE)
 *******************************************************************
 */

//
//
// Client Main
// -----------
//
// This module contains the main() for a Client based on objattr.idl
// and objattr.iml that was generated by Digital Equipment Corporation's
// ObjectBroker.
//
// This module was generated using ObjectBroker's QuickStart commands.
//
//

#include <obbquick.hxx>
#include "objattr.hxx"

static CORBA::Boolean objattr_CTest1Invoke (void);
static CORBA::Boolean objattrCTest1getObjTest2 (objattr::CTest1_var &
CTest1Obj);
static CORBA::Boolean objattrCTest1aLongAttr (objattr::CTest1_var &
CTest1Obj);
static CORBA::Boolean objattrCTest1hasTest2Objects (objattr::CTest1_var
& CTest1Obj);
static CORBA::Boolean objattr_CTest2Invoke (void);
static CORBA::Boolean objattrCTest2getObjTest3 (objattr::CTest2_var &
CTest2Obj);
static CORBA::Boolean objattrCTest2aShortAttr (objattr::CTest2_var &
CTest2Obj);
static CORBA::Boolean objattrCTest2itsTest1Object (objattr::CTest2_var &
CTest2Obj);
static CORBA::Boolean objattrCTest2hasTest3Objects (objattr::CTest2_var
& CTest2Obj);
static CORBA::Boolean objattr_CTest3Invoke (void);
static CORBA::Boolean objattrCTest3aFloatAttr (objattr::CTest3_var &
CTest3Obj);
static CORBA::Boolean objattrCTest3itsTest2Object (objattr::CTest3_var &
CTest3Obj);
static void gen_seq1 (objattr::seqCTest2 & set_hasTest2Objects);
static void gen_seq2 (objattr::seqCTest3 & set_hasTest3Objects);

//
//
//  ROUTINE NAME: Main
//
//  FUNCTIONAL DESCRIPTION:
//
//      This is a platform independent main.
//
//

OBB_QUICK_MAIN

{
    OBB_QUICK_CLIENT_INIT;

    OBB_QUICK_OPENLOGFILE;

    OBB_QUICK_LOGTXT ("\n***** Client Started Execution *****\n");


    if (!objattr_CTest1Invoke())
     OBB_QUICK_LOGTXT ("\n***** Failure in CTest1 Interface *****");

    if (!objattr_CTest2Invoke())
     OBB_QUICK_LOGTXT ("\n***** Failure in CTest2 Interface *****");

    if (!objattr_CTest3Invoke())
     OBB_QUICK_LOGTXT ("\n***** Failure in CTest3 Interface *****");


    OBB_QUICK_LOGTXT ("\n***** Client Completed Execution *****");

    OBB_QUICK_CLOSELOGFILE;

    OBB_QUICK_EXIT;

}

//
//
//  ROUTINE NAME: objattr_CTest1Invoke
//
//  FUNCTIONAL DESCRIPTION:
//
//      Routine to invoke the operations on the CTest1 interface.
//
//

static CORBA::Boolean objattr_CTest1Invoke (void)

{
    // Local Data Declaration 
    objattr::CTest1_var M_objattr_CTest1Obj;
    CORBA::Object_ptr CTest1Obj;
    CORBA::Object_var CTest1ObjVar;

        //
    // This is a quick way of getting an object reference. The ideal way
    // is to find the object advertised in the advertisement registry.
    //

    CORBA::Char * CTest1Obj_str = "\
DEC::~100034502577b7b9bb80000029d60dda7000000000009a567b7b45\
9e0000029d60dda7000000000051000000000059a567b7b4a9e0000029d6\
0dda7000000000059a567b7b469e0000029d60dda7000000000019a567b7\
b479e0000029d60dda7000000000029a567b7b489e0000029d60dda70000\
00000039a567b7b499e0000029d60dda700000000004000009a567b7b459\
e0000029d60dda7000000020100005f8~~~~%00000%|";

    if (!StringifiedObjToRealObj (CTest1Obj_str,
                                  &CTest1Obj))
        return (CORBA_FALSE);

    // Assigned CTest1Obj to CTest1ObjVar to facilitate implicit release
when 
    //       the variable goes out of scope.
    CTest1ObjVar = CTest1Obj;
        CORBA::Environment ev;
    if ( CORBA::is_nil(CTest1Obj, ev) )
        {
        OBB_QUICK_LOGTXT ("\n\n CTest1Obj : NIL Object");
        return (CORBA_FALSE);

        }

    M_objattr_CTest1Obj = objattr::CTest1::_narrow(CTest1Obj);
    // Invoke operations on the CTest1 interface 
    if (!objattrCTest1getObjTest2 (M_objattr_CTest1Obj))
    OBB_QUICK_LOGTXT ("\n***** objattrCTest1getObjTest2 failure *****");

    if (!objattrCTest1aLongAttr (M_objattr_CTest1Obj))
    OBB_QUICK_LOGTXT ("\n***** objattrCTest1aLongAttr failure *****");

    if (!objattrCTest1hasTest2Objects (M_objattr_CTest1Obj))
    OBB_QUICK_LOGTXT ("\n***** objattrCTest1hasTest2Objects failure
*****");

    return (CORBA_TRUE);
}

//
//
//  ROUTINE NAME: objattr_CTest2Invoke
//
//  FUNCTIONAL DESCRIPTION:
//
//      Routine to invoke the operations on the CTest2 interface.
//
//

static CORBA::Boolean objattr_CTest2Invoke (void)

{
    // Local Data Declaration 
    objattr::CTest2_var M_objattr_CTest2Obj;
    CORBA::Object_ptr CTest2Obj;
    CORBA::Object_var CTest2ObjVar;

        //
    // This is a quick way of getting an object reference. The ideal way
    // is to find the object advertised in the advertisement registry.
    //

    CORBA::Char * CTest2Obj_str = "\
DEC::~100041902577b7b9cb80000029d60dda7000000000009a567b7b4b\
9e0000029d60dda7000000000071000000000079a567b7b529e0000029d6\
0dda7000000000079a567b7b4c9e0000029d60dda7000000000019a567b7\
b4d9e0000029d60dda7000000000029a567b7b4e9e0000029d60dda70000\
00000039a567b7b4f9e0000029d60dda7000000000049a567b7b509e0000\
029d60dda7000000000059a567b7b519e0000029d60dda70000000000600\
0009a567b7b4b9e0000029d60dda7000000020100007fe~~~~%00000%|";

    if (!StringifiedObjToRealObj (CTest2Obj_str,
                                  &CTest2Obj))
        return (CORBA_FALSE);

    // Assigned CTest2Obj to CTest2ObjVar to facilitate implicit release
when 
    //       the variable goes out of scope.
    CTest2ObjVar = CTest2Obj;
        CORBA::Environment ev;
    if ( CORBA::is_nil(CTest2Obj, ev) )
        {
        OBB_QUICK_LOGTXT ("\n\n CTest2Obj : NIL Object");
        return (CORBA_FALSE);

        }

    M_objattr_CTest2Obj = objattr::CTest2::_narrow(CTest2Obj);
    // Invoke operations on the CTest2 interface 
    if (!objattrCTest2getObjTest3 (M_objattr_CTest2Obj))
    OBB_QUICK_LOGTXT ("\n***** objattrCTest2getObjTest3 failure *****");

    if (!objattrCTest2aShortAttr (M_objattr_CTest2Obj))
    OBB_QUICK_LOGTXT ("\n***** objattrCTest2aShortAttr failure *****");

    if (!objattrCTest2itsTest1Object (M_objattr_CTest2Obj))
    OBB_QUICK_LOGTXT ("\n***** objattrCTest2itsTest1Object failure
*****");

    if (!objattrCTest2hasTest3Objects (M_objattr_CTest2Obj))
    OBB_QUICK_LOGTXT ("\n***** objattrCTest2hasTest3Objects failure
*****");

    return (CORBA_TRUE);
}

//
//
//  ROUTINE NAME: objattr_CTest3Invoke
//
//  FUNCTIONAL DESCRIPTION:
//
//      Routine to invoke the operations on the CTest3 interface.
//
//

static CORBA::Boolean objattr_CTest3Invoke (void)

{
    // Local Data Declaration 
    objattr::CTest3_var M_objattr_CTest3Obj;
    CORBA::Object_ptr CTest3Obj;
    CORBA::Object_var CTest3ObjVar;

        //
    // This is a quick way of getting an object reference. The ideal way
    // is to find the object advertised in the advertisement registry.
    //

    CORBA::Char * CTest3Obj_str = "\
DEC::~100030802577b7b9db80000029d60dda7000000000009a567b7b53\
9e0000029d60dda7000000000031000000000049a567b7b549e0000029d6\
0dda7000000000019a567b7b559e0000029d60dda7000000000029a567b7\
b569e0000029d60dda7000000000039a567b7b579e0000029d60dda70000\
0000004000009a567b7b539e0000029d60dda7000000020100004f0~~~~%\
00000%|";

    if (!StringifiedObjToRealObj (CTest3Obj_str,
                                  &CTest3Obj))
        return (CORBA_FALSE);

    // Assigned CTest3Obj to CTest3ObjVar to facilitate implicit release
when 
    //       the variable goes out of scope.
    CTest3ObjVar = CTest3Obj;
        CORBA::Environment ev;
    if ( CORBA::is_nil(CTest3Obj, ev) )
        {
        OBB_QUICK_LOGTXT ("\n\n CTest3Obj : NIL Object");
        return (CORBA_FALSE);

        }

    M_objattr_CTest3Obj = objattr::CTest3::_narrow(CTest3Obj);
    // Invoke operations on the CTest3 interface 
    if (!objattrCTest3aFloatAttr (M_objattr_CTest3Obj))
    OBB_QUICK_LOGTXT ("\n***** objattrCTest3aFloatAttr failure *****");

    if (!objattrCTest3itsTest2Object (M_objattr_CTest3Obj))
    OBB_QUICK_LOGTXT ("\n***** objattrCTest3itsTest2Object failure
*****");

    return (CORBA_TRUE);
}

//
//
//  ROUTINE NAME: objattrCTest1getObjTest2
//
//  FUNCTIONAL DESCRIPTION:
//
//      This is a jacket routine for getObjTest2.
//
//

static CORBA::Boolean objattrCTest1getObjTest2 (objattr::CTest1_var &
CTest1Obj)

{
    // Local Data Declaration 
    CORBA::Environment ev;
    objattr::CTest2_ptr ret_objattr_CTest2_ptr;
    CORBA::Long index;

    //  In or Inout Argument Initialization 
    index = 1;


    OBB_QUICK_LOGTXT ("\n\n***** Invoking CTest1Obj->getObjTest2
*****");
    ret_objattr_CTest2_ptr = CTest1Obj -> getObjTest2 (index,
        ev);
    // Handle any errors 
    if (IsException (ev,
        (CORBA::Char *)"objattr_CTest1_getObjTest2 failed\n"))
        {
            CORBA::release (ret_objattr_CTest2_ptr, ev);
            return(CORBA_FALSE);
        }


    OBB_QUICK_LOGTXT ("\nStringified ret_objattr_CTest2_ptr:");
    if (!PrintStringifiedObj (ret_objattr_CTest2_ptr))
        return (CORBA_FALSE);

    // Free memory allocated locally and in out or inout arguments
    CORBA::release (ret_objattr_CTest2_ptr, ev);
    // Handle any errors 
    if (IsException (ev,
        (CORBA::Char *)"CORBA::release failed\n"))
        return(CORBA_FALSE);


    return (CORBA_TRUE);
}

//
//
//  ROUTINE NAME: objattrCTest1aLongAttr
//
//  FUNCTIONAL DESCRIPTION:
//
//      This is a jacket routine for aLongAttr.
//
//

static CORBA::Boolean objattrCTest1aLongAttr (objattr::CTest1_var &
CTest1Obj)
{
    // Local Data Declaration 
    CORBA::Environment ev;
    CORBA::Long set_aLongAttr;
    CORBA::Long ret_aLongAttr;

    // Set the attribute 
        set_aLongAttr = 2;

    OBB_QUICK_LOGTXT ("\n\n***** Invoking CTest1Obj->aLongAttr *****");

    CTest1Obj->aLongAttr (set_aLongAttr,
                        ev);
    // Handle any errors 
    if (IsException (ev,
        (CORBA::Char *)"Attribute set_aLongAttr failed\n"))
        return(CORBA_FALSE);


    OBB_QUICK_LOGTXT ("\n\n***** Invoking CTest1Obj->aLongAttr *****");

    ret_aLongAttr = CTest1Obj->aLongAttr (
         ev);
    // Handle any errors 
    if (IsException (ev,
        (CORBA::Char *)"Attribute get_aLongAttr failed\n"))
        return(CORBA_FALSE);


    OBB_QUICK_LOGPARAM (format_long, OBB_QUICK_INDENT * 0,
"ret_aLongAttr", ret_aLongAttr);

    return (CORBA_TRUE);
}

//
//
//  ROUTINE NAME: objattrCTest1hasTest2Objects
//
//  FUNCTIONAL DESCRIPTION:
//
//      This is a jacket routine for hasTest2Objects.
//
//

static CORBA::Boolean objattrCTest1hasTest2Objects (objattr::CTest1_var
& CTest1Obj)
{
    // Local Data Declaration 
    CORBA::Environment ev;
    objattr::seqCTest2  set_hasTest2Objects;
    objattr::seqCTest2 * ret_hasTest2Objects;

    // Set the attribute 
    gen_seq1 ( set_hasTest2Objects);

    OBB_QUICK_LOGTXT ("\n\n***** Invoking CTest1Obj->hasTest2Objects
*****");

    CTest1Obj->hasTest2Objects (set_hasTest2Objects,
                        ev);
    // Handle any errors 
    if (IsException (ev,
        (CORBA::Char *)"Attribute set_hasTest2Objects failed\n"))
        return(CORBA_FALSE);


    OBB_QUICK_LOGTXT ("\n\n***** Invoking CTest1Obj->hasTest2Objects
*****");

    ret_hasTest2Objects = CTest1Obj->hasTest2Objects (
         ev);
    // Handle any errors 
    if (IsException (ev,
        (CORBA::Char *)"Attribute get_hasTest2Objects failed\n"))
        return(CORBA_FALSE);

    
    OBB_QUICK_LOGTXT ("unbound sequence ret_hasTest2Objects");
    OBB_QUICK_LOGPARAM (format_ulong, OBB_QUICK_INDENT * 4,
"ret_hasTest2Objects->_maximum", ret_hasTest2Objects->maximum());
    OBB_QUICK_LOGPARAM (format_ulong, OBB_QUICK_INDENT * 4,
"ret_hasTest2Objects->_length", ret_hasTest2Objects->length());
    for( int k1 = 0 ; k1 < 5 ; k1++ ) {
        OBB_QUICK_PRINTF((logfile, "        hasTest2Objects[%d]: "
OBB_PF_LONG "\n", k1, (* ret_hasTest2Objects)[k1]));
    } // for( k1 )

    delete ret_hasTest2Objects;

    return (CORBA_TRUE);
}


//
//
//  ROUTINE NAME: objattrCTest2getObjTest3
//
//  FUNCTIONAL DESCRIPTION:
//
//      This is a jacket routine for getObjTest3.
//
//

static CORBA::Boolean objattrCTest2getObjTest3 (objattr::CTest2_var &
CTest2Obj)

{
    // Local Data Declaration 
    CORBA::Environment ev;
    objattr::CTest3_ptr ret_objattr_CTest3_ptr;
    CORBA::Long index;

    //  In or Inout Argument Initialization 
    index = 8;

    OBB_QUICK_LOGTXT ("\n\n***** Invoking CTest2Obj->getObjTest3
*****");
    ret_objattr_CTest3_ptr = CTest2Obj -> getObjTest3 (index,
        ev);
    // Handle any errors 
    if (IsException (ev,
        (CORBA::Char *)"objattr_CTest2_getObjTest3 failed\n"))
        {
            CORBA::release (ret_objattr_CTest3_ptr, ev);
            return(CORBA_FALSE);
        }


    OBB_QUICK_LOGTXT ("\nStringified ret_objattr_CTest3_ptr:");
    if (!PrintStringifiedObj (ret_objattr_CTest3_ptr))
        return (CORBA_FALSE);

    // Free memory allocated locally and in out or inout arguments
    CORBA::release (ret_objattr_CTest3_ptr, ev);
    // Handle any errors 
    if (IsException (ev,
        (CORBA::Char *)"CORBA::release failed\n"))
        return(CORBA_FALSE);


    return (CORBA_TRUE);
}

//
//
//  ROUTINE NAME: objattrCTest2aShortAttr
//
//  FUNCTIONAL DESCRIPTION:
//
//      This is a jacket routine for aShortAttr.
//
//

static CORBA::Boolean objattrCTest2aShortAttr (objattr::CTest2_var &
CTest2Obj)
{
    // Local Data Declaration 
    CORBA::Environment ev;
    CORBA::Short set_aShortAttr;
    CORBA::Short ret_aShortAttr;

    // Set the attribute 
        set_aShortAttr = 1;


    OBB_QUICK_LOGTXT ("\n\n***** Invoking CTest2Obj->aShortAttr *****");

    CTest2Obj->aShortAttr (set_aShortAttr,
                        ev);
    // Handle any errors 
    if (IsException (ev,
        (CORBA::Char *)"Attribute set_aShortAttr failed\n"))
        return(CORBA_FALSE);


    OBB_QUICK_LOGTXT ("\n\n***** Invoking CTest2Obj->aShortAttr *****");

    ret_aShortAttr = CTest2Obj->aShortAttr (
         ev);
    // Handle any errors 
    if (IsException (ev,
        (CORBA::Char *)"Attribute get_aShortAttr failed\n"))
        return(CORBA_FALSE);


    OBB_QUICK_LOGPARAM (format_short, OBB_QUICK_INDENT * 0,
"ret_aShortAttr", ret_aShortAttr);

    return (CORBA_TRUE);
}


//
//
//  ROUTINE NAME: objattrCTest2itsTest1Object
//
//  FUNCTIONAL DESCRIPTION:
//
//      This is a jacket routine for itsTest1Object.
//
//

static CORBA::Boolean objattrCTest2itsTest1Object (objattr::CTest2_var &
CTest2Obj)
{
    // Local Data Declaration 
    CORBA::Environment ev;
    objattr::CTest1_ptr set_itsTest1Object;
    objattr::CTest1_ptr ret_itsTest1Object;

    // Set the attribute 
    //
    // This is a quick way of getting an object reference. The ideal way
    // is to find the object advertised in the advertisement registry.
    //

    CORBA::Char * objattr_CTest11Obj_str = "\
DEC::~100034502577b7b9eb80000029d60dda7000000000009a567b7b45\
9e0000029d60dda7000000000051000000000059a567b7b4a9e0000029d6\
0dda7000000000059a567b7b469e0000029d60dda7000000000019a567b7\
b479e0000029d60dda7000000000029a567b7b489e0000029d60dda70000\
00000039a567b7b499e0000029d60dda700000000004000009a567b7b459\
e0000029d60dda7000000020100005f8~~~~%00000%|";

    CORBA::Object_ptr objattr_CTest11Obj;
    if (!StringifiedObjToRealObj (objattr_CTest11Obj_str,
                                  &objattr_CTest11Obj))
        return (CORBA_FALSE);

    CORBA::Object_var objattr_CTest11ObjVar = objattr_CTest11Obj;
    set_itsTest1Object =  objattr::CTest1::_narrow(objattr_CTest11Obj);


    OBB_QUICK_LOGTXT ("\n\n***** Invoking CTest2Obj->itsTest1Object
*****");

    CTest2Obj->itsTest1Object (set_itsTest1Object,
                        ev);
    // Handle any errors 
    if (IsException (ev,
        (CORBA::Char *)"Attribute set_itsTest1Object failed\n"))
        return(CORBA_FALSE);


    OBB_QUICK_LOGTXT ("\n\n***** Invoking CTest2Obj->itsTest1Object
*****");

    ret_itsTest1Object = CTest2Obj->itsTest1Object (
         ev);
    // Handle any errors 
    if (IsException (ev,
        (CORBA::Char *)"Attribute get_itsTest1Object failed\n"))
        return(CORBA_FALSE);


    OBB_QUICK_LOGTXT ("\nStringified itsTest1Object:");
    if (CORBA::is_nil (ret_itsTest1Object, ev))
        {
        OBB_QUICK_LOGTXT ("          ret_itsTest1Object :
CORBA_OBJECT_NIL");
        }
    else
        {
        if (!PrintStringifiedObj (ret_itsTest1Object))
            return (CORBA_FALSE);
        }
    // Free the objectref we got from the server
    if (!ReleaseObjRef (set_itsTest1Object))
        return (CORBA_FALSE);

    return (CORBA_TRUE);
}


//
//
//  ROUTINE NAME: objattrCTest2hasTest3Objects
//
//  FUNCTIONAL DESCRIPTION:
//
//      This is a jacket routine for hasTest3Objects.
//
//

static CORBA::Boolean objattrCTest2hasTest3Objects (objattr::CTest2_var
& CTest2Obj)
{
    // Local Data Declaration 
    CORBA::Environment ev;
    objattr::seqCTest3  set_hasTest3Objects;
    objattr::seqCTest3 * ret_hasTest3Objects;

    // Set the attribute 
    gen_seq2 ( set_hasTest3Objects);

    OBB_QUICK_LOGTXT ("\n\n***** Invoking CTest2Obj->hasTest3Objects
*****");

    CTest2Obj->hasTest3Objects (set_hasTest3Objects,
                        ev);
    // Handle any errors 
    if (IsException (ev,
        (CORBA::Char *)"Attribute set_hasTest3Objects failed\n"))
        return(CORBA_FALSE);


    OBB_QUICK_LOGTXT ("\n\n***** Invoking CTest2Obj->hasTest3Objects
*****");

    ret_hasTest3Objects = CTest2Obj->hasTest3Objects (
         ev);
    // Handle any errors 
    if (IsException (ev,
        (CORBA::Char *)"Attribute get_hasTest3Objects failed\n"))
        return(CORBA_FALSE);

    
    OBB_QUICK_LOGTXT ("unbound sequence hasTest3Objects");
    OBB_QUICK_LOGPARAM (format_ulong, OBB_QUICK_INDENT * 4,
"hasTest3Objects->_maximum", hasTest3Objects->maximum());
    OBB_QUICK_LOGPARAM (format_ulong, OBB_QUICK_INDENT * 4,
"hasTest3Objects->_length", hasTest3Objects->length());
    for( int k2 = 0 ; k2 < 5 ; k2++ ) {
        OBB_QUICK_PRINTF((logfile, "        hasTest3Objects[%d]: "
OBB_PF_LONG "\n", k2, (* ret_hasTest3Objects)[k2]));
    } // for( k2 )

    delete ret_hasTest3Objects;

    return (CORBA_TRUE);
}

//
//
//  ROUTINE NAME: objattrCTest3aFloatAttr
//
//  FUNCTIONAL DESCRIPTION:
//
//      This is a jacket routine for aFloatAttr.
//
//

static CORBA::Boolean objattrCTest3aFloatAttr (objattr::CTest3_var &
CTest3Obj)
{
    // Local Data Declaration 
    CORBA::Environment ev;
    CORBA::Float set_aFloatAttr;
    CORBA::Float ret_aFloatAttr;

    // Set the attribute 
        set_aFloatAttr = 1.000000F;



    OBB_QUICK_LOGTXT ("\n\n***** Invoking CTest3Obj->aFloatAttr *****");

    CTest3Obj->aFloatAttr (set_aFloatAttr,
                        ev);
    // Handle any errors 
    if (IsException (ev,
        (CORBA::Char *)"Attribute set_aFloatAttr failed\n"))
        return(CORBA_FALSE);


    OBB_QUICK_LOGTXT ("\n\n***** Invoking CTest3Obj->aFloatAttr *****");

    ret_aFloatAttr = CTest3Obj->aFloatAttr (
         ev);
    // Handle any errors 
    if (IsException (ev,
        (CORBA::Char *)"Attribute get_aFloatAttr failed\n"))
        return(CORBA_FALSE);


    OBB_QUICK_LOGPARAM (format_float, OBB_QUICK_INDENT * 0,
"ret_aFloatAttr", ret_aFloatAttr);

    return (CORBA_TRUE);
}

//
//
//  ROUTINE NAME: objattrCTest3itsTest2Object
//
//  FUNCTIONAL DESCRIPTION:
//
//      This is a jacket routine for itsTest2Object.
//
//

static CORBA::Boolean objattrCTest3itsTest2Object (objattr::CTest3_var &
CTest3Obj)
{
    // Local Data Declaration 
    CORBA::Environment ev;
    objattr::CTest2_ptr set_itsTest2Object;
    objattr::CTest2_ptr ret_itsTest2Object;

    // Set the attribute 
    //
    // This is a quick way of getting an object reference. The ideal way
    // is to find the object advertised in the advertisement registry.
    //

    CORBA::Char * objattr_CTest22Obj_str = "\
DEC::~100041902577b7b9fb80000029d60dda7000000000009a567b7b4b\
9e0000029d60dda7000000000071000000000079a567b7b529e0000029d6\
0dda7000000000079a567b7b4c9e0000029d60dda7000000000019a567b7\
b4d9e0000029d60dda7000000000029a567b7b4e9e0000029d60dda70000\
00000039a567b7b4f9e0000029d60dda7000000000049a567b7b509e0000\
029d60dda7000000000059a567b7b519e0000029d60dda70000000000600\
0009a567b7b4b9e0000029d60dda7000000020100007fe~~~~%00000%|";

    CORBA::Object_ptr objattr_CTest22Obj;
    if (!StringifiedObjToRealObj (objattr_CTest22Obj_str,
                                  &objattr_CTest22Obj))
        return (CORBA_FALSE);

    CORBA::Object_var objattr_CTest22ObjVar = objattr_CTest22Obj;
    set_itsTest2Object =  objattr::CTest2::_narrow(objattr_CTest22Obj);


    OBB_QUICK_LOGTXT ("\n\n***** Invoking CTest3Obj->itsTest2Object
*****");

    CTest3Obj->itsTest2Object (set_itsTest2Object,
                        ev);
    // Handle any errors 
    if (IsException (ev,
        (CORBA::Char *)"Attribute set_itsTest2Object failed\n"))
        return(CORBA_FALSE);


    OBB_QUICK_LOGTXT ("\n\n***** Invoking CTest3Obj->itsTest2Object
*****");

    ret_itsTest2Object = CTest3Obj->itsTest2Object (
         ev);
    // Handle any errors 
    if (IsException (ev,
        (CORBA::Char *)"Attribute get_itsTest2Object failed\n"))
        return(CORBA_FALSE);

    OBB_QUICK_LOGTXT ("\nStringified itsTest2Object:");
    if (CORBA::is_nil (ret_itsTest2Object, ev))
        {
        OBB_QUICK_LOGTXT ("          ret_itsTest2Object :
CORBA_OBJECT_NIL");
        }
    else
        {
        if (!PrintStringifiedObj (ret_itsTest2Object))
            return (CORBA_FALSE);
        }
    // Free the objectref we got from the server
    if (!ReleaseObjRef (set_itsTest2Object))
        return (CORBA_FALSE);

    return (CORBA_TRUE);
}


static void
gen_seq1 (objattr::seqCTest2 & set_hasTest2Objects)
{
    // Local data declarations
    CORBA::Environment ev;

    set_hasTest2Objects.length(5);

    set_hasTest2Objects[0] = 3;
    set_hasTest2Objects[1] = 4;
    set_hasTest2Objects[2] = 5;
    set_hasTest2Objects[3] = 6;
    set_hasTest2Objects[4] = 7;
}


static void
gen_seq2 (objattr::seqCTest3 & set_hasTest3Objects)
{
    // Local data declarations
    CORBA::Environment ev;

    set_hasTest3Objects.length(5);

    set_hasTest3Objects[0] = 9;
    set_hasTest3Objects[1] = 10;
    set_hasTest3Objects[2] = 11;
    set_hasTest3Objects[3] = 12;
    set_hasTest3Objects[4] = 13;
}



#endif   /* OBB_QUICK */

====================================

TOmas, you seem to be treating QuickStart as some 
production-quality code generator. In my opinion it's
just to get you going and maybe as a source of
cut-and-paste.

It doesn't even support sequence<string>, or as you 
discovered, a sequence of objects!

John D.

 It wasn't my intention to sound critical. I realise that QuickStart
 is a 'bonus' thing. These two problems were forwarded to me from a
 customer with a nasty habit of trying to come up with new ideas all
 the time. I try to hold him back, believe me, but it's no use...

 - Tomas A -

    This is PTR  16-3-255.