class Repository : public Container {

Contained_ptr lookup_id(const char * search_id);

PrimitiveDef_ptr get_primitive(PrimitiveKind kind);

StringDef_ptr create_string(ULong bound);

SequenceDef_ptr create_sequence(CORBA::ULong bound,

IDLType_ptr element_type);

ArrayDef_ptr create_array(ULong length,

IDLType_ptr element_type);

};

...

main(int argc, char *const *argv)

{

CORBA::Boolean ret;

// Initialize the ORB

CORBA::ORB_var orb = CORBA::ORB_init(argc, argv);

// Declare the library object

library_var library_object;

// Declare an interface repository pointer

CORBA::Repository_var rep_object;

try {

// Attempt to bind to the interface repository

rep_object = CORBA::Repository::_bind();

}

// Check for errors

catch(const CORBA::Exception& excep) {

cout << "Error binding to interface repository" << endl;

return(0);

}

// Locate the add_book operation definition. Can the operation be

// located without first locating the interface?

CORBA::Contained_var add_req = rep_object

->lookup_id("Library::add_book");

try {

// Bind to the library object.

library_object = library::bind();

}

// Check for errors

catch(const CORBA::Exception& excep) {

cout << "Error binding to library object" << endl;

return(0);

}

// Create a request, initializing the operation name.

Request_var req = library_object->_request(add_req->name());

...

class Request {

public:

CORBA::Object_ptr target() const;

const char* operation() const;

CORBA::NVList_ptr arguments();

CORBA::NamedValue_ptr result();

CORBA::Environment_ptr env();

void ctx(CORBA::Context_ptr ctx);

CORBA::Context_ptr ctx() const;

CORBA::Status invoke();

CORBA::Status send_oneway();

CORBA::Status send_deferred();

CORBA::Status get_response();

CORBA::Status poll_response();

...

};

class Object {

...

Status _create_request(Context_ptr ctx,

const char * operation,

NVList_ptr arg_list,

NamedValue_ptr result,

Request_ptr request,

Flags req_flags);

Request_ptr _request(Identifier operation);

...

};

class Context {

public:

const char *context_name() const;

CORBA::Context_prt parent();

CORBA::Status create_child(const char *name,

CORBA::Context_ptr&);

CORBA::Status set_one_value(const char *name,

const CORBA::Any&);

CORBA::Status set_values(CORBA::NVList_ptr);

CORBA::Status delete_values(const char *name);

CORBA::Status get_values(const char *start_scope,

CORBA::Flags,

const char *name,

CORBA::NVList_ptr&) const;

public:

Long count() const;

NamedValue_ptr add(Flags);

NamedValue_ptr add_item(const char *name, Flags);

NamedValue_ptr add_value(const char *name, const Any&, Flags);

NamedValue_ptr item(Long);

Status remove(Long);

Status free_out_memory();

public:

const char *name() const;

Any *value() const;

Flags flags() const;

{

public:

Any();

Any(const Any&);

Any(TypeCode_ptr tc, void *value, Boolean release=0);

~Any();

Any& operator=(const Any&);

// Overloaded operators for all data types

void operator<<=(Short);

void operator<<=(UShort);

void operator<<=(Long);

void operator<<=(ULong);

...

TypeCode_ptr type();

const void *value() const;

static Any_ptr _nil();

static Any_ptr _duplicate(Any *ptr);

static void _release(Any *ptr);

// Streaming operators to write Anys to stdout, etc.

ostream& operator<<(ostream&, const Any&);

istream& operator>>(istream& strm, Any& any);

istream& operator>>(istream& strm, Any_ptr& any);

...

...

// Assumes that req has been set to Request

// Create TypeCode for structure

CORBA::StructMemberSeq members;

members.length(2);

members[0].name = (const char *)"author";

members[0].type = CORBA::TypeCode::_duplicate(CORBA::_tc_string);

members[1].name = (const char *)"title";

members[1].type = CORBA::TypeCode::_duplicate(CORBA::_tc_string);

bookTypeCode = orb->create_struct_tc(

"book", "book", members);

// Write out author and title to a MarshalOutBuffer

CORBA::MarshalOutBuffer buf;

buf << argv[1]; // Author

buf << argv[2]; // Title

bookValue.replace(bookTypeCode, buf);

// Get Argument list from request.

CORBA::NVList_var arguments = req->arguments();

arguments->add_value("book", bookValue, CORBA::ARG_IN);

// Set result

// NOTE: All parameters types (IN, OUT, INOUT and RETURN) need

// to be set so that DII knows the data types of all

// arguments.

CORBA::Boolean ret=0;

CORBA::NamedValue_var result(req->result());

CORBA::Any_var resultAny(result->value());

resultAny->replace(CORBA::_tc_boolean, &result);

// Execute the function

req->invoke();

CORBA::Environment_var env = req->env();

if ( env->exception() )

cout << "Exception occured" << endl;

else {

// Get the return value;

ret = *(CORBA::Boolean *)resultAny->value();

}

cout << "Return value from invoke: " << (int)ret << endl;

return(1);

class ORB {

...

typedef sequence<Request_ptr> RequestSeq;

Status send_multiple_requests_oneway(const RequestSeq &);

Status send_multiple_requests_deferred(const RequestSeq &);

Boolean poll_next_response();

Status get_next_response();

...

};