[Search for users]
[Overall Top Noters]
[List of all Conferences]
[Download this site]
| Title: | ObjectBroker Development - BEA Systems' CORBA |
| Notice: | See note 2 for kit locations; note 4 for training |
| Moderator: | RECV::GUMBEL d |
|
| Created: | Thu Dec 27 1990 |
| Last Modified: | Fri Jun 06 1997 |
| Last Successful Update: | Fri Jun 06 1997 |
| Number of topics: | 2482 |
| Total number of notes: | 13057 |
2459.0. "QuickStart: two problems" by STKAI1::T_ANDERSSON (Tomas Andersson) Mon Mar 24 1997 07: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 */
====================================
| T.R | Title | User | Personal
Name | Date | Lines |
|---|
| 2459.1 | why do think it should be perfect? | LEMAN::DONALDSON | Froggisattva! Froggisattva! | Mon Mar 24 1997 09:01 | 9 |
| 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.
|
| 2459.2 | | STKAI1::T_ANDERSSON | Tomas Andersson | Mon Mar 24 1997 10:04 | 8 |
|
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 -
|
| 2459.3 | | REQUE::BOWER | Peter Bower, ObjectBroker | Tue Apr 01 1997 10:48 | 2 |
| This is PTR 16-3-255.
|