Now Reading
Linux DCE, CORBA and DCOM Information

Linux DCE, CORBA and DCOM Information

2023-07-15 16:33:41


Linux DCE, CORBA and DCOM Information



Selling Linux Requires Promoting. It Issues to Me.
TM





Key Resource

There’s a wealthy choice of implementations of
CORBA
for Linux, together with one that’s centered on real-time operation,
two extra on fault-tolerance, and one other two aimed toward embedded
methods. If these options will not be necessary to you, however
Microsoft’s identify is, then check out DCOM & ActiveX for
Linux. Yep, its out there!

Applied sciences Much like CORBA

DCE
DCE,
quick for the Distributed Computing Setting, is a know-how
that may be a bit older than CORBA, however a very good bit extra secure and scalable.
Not solely does it supply the fundamental RPC mechanisms and IDL stub compilers
wanted to create distributed purposes, nevertheless it additionally affords safety &
authentication via Kerberos (an space that also displays weak point in
CORBA). In contrast to CORBA, it’s not a ground-up redesign of the rules of
distributed computing, is moderately a tightly built-in bundle of present
applied sciences. Quietly however powerfully fashionable in true large-scale,
enterprise-class purposes, its the bundle of alternative for the large boys.

FreeDCE is a port of
DCE to Linux
and is now in beta. Please word that the usage of Kerberos
is restricted exterior of the US, attributable to US encryption export legal guidelines.
Observe additionally that the distribution of pre-compiled binaries is made
tough by these identical points in addition to a license restriction.
To make use of FreeDCE, you have to be ready to compile it your self.
The

DCE FAQ
gives a very good overview of what DCE is, how its used,
and learn how to use it.

DCOM/ActiveX
Microsoft’s

DCOM & ActiveX for Linux
is being ported by
Software AG
and is accessible for beta-testing. Software program AG,
higher generally known as the makers of the AdabasD SQL database,
has a take care of Microsoft to help DCOM on a spread
of Unix OS platforms. (Observe: the Software program AG website
just isn’t solely tough to navigate, however can also be incessantly
reorganized. If you cannot discover the Linux DCOM beta,
attempt
here
.)

Observe: DCOM is *not* CORBA compliant, and it does not even attempt to be.
In reality, its just about completely and fully completely different. It
is listed right here as a result of it gives a number of the options that
CORBA gives, and since Microsoft is trying to promote it
as a competitor to CORBA. Observe that the favored business analyst
place is that DCOM just isn’t as superior as CORBA, nor anyplace
close to as sturdy or secure.



DCOM and CORBA Side by Side, Step by Step, and Layer by Layer

gives simply what its title suggests. Thorough and detailed.

RPC’s, PVM, Java-RMI
There are a number of different distributed applied sciences not
coated right here, however deserve point out. RPC’s (Distant Process
Calls) are the mental grand-daddy of CORBA and DCE,
and are a normal a part of the GNU C library. As a result of
RPC amenities are put in be default in all places, RPC’s
could be preferrred for the duty.

XML-RPC
is assortment of tasks that implement the RPC protocol
in XML, thus permitting for the straightforward debugging of community
classes. There are

XML-RPC implementations
for hottest programming languages
and environments.

PVM
(Parallel Virtual Machine)
,
MPI (Message Passing
Interface)
,
(see additionally

MPI
),
LAM-MPI (Local Area
Multicomputer)

are used within the scientific group
to resolve giant reminiscence and cpu-intensive numerical simulation
issues. PVM, MPI, and their kinfolk and cousins aren’t
utilized by the final enterprise computing group.
Observe, nonetheless, that the brand new high-performance cluster-computing,
SAN-fabric VIA
message-passing structure is slowly gaining floor within the
enterprise world, and is accessible on Linux within the type of
M-VIA.
Sadly, a bit kiboshed by Microsoft, although.


Sun’s Java-RMI (Remote Method Invocation)

is more-or-less a generally out there a part of Java, acquainted to
all Java programmers. It can
someday soon
inter-operate with CORBA
by supporting CORBA’s IIOP protocol.

CORBA Packages

AdaBroker (New Itemizing!)
AdaBroker is a
set of instruments and libraries for growing
purposes within the Ada programming language.
It gives an IDL parser, Ada code generator, the
CORBA-defined Ada mapping help packages.
AdaBroker is launched underneath the GPL.
ORBit
ORBit is
the ORB of alternative for the
Gnome venture. Particularly,
it’s notable and laudable in its makes an attempt to have very excessive
efficiency when used regionally, and to have a small footprint.
The choice to pursue the event of ORBit got here after
poor experiences with three of the ORB’s listed beneath. One
proved to have an unacceptable licensing restriction for
the GPL’ed Gnome venture, one other proved too fats and gradual,
and a 3rd was lacking crucial “C” language bindings.
In fact, your causes for selecting one bundle over one other
shall be completely different than these driving the Gnome choice, and
so the rejected packages shall stay unimpunged.
Observe, nonetheless, if you’re doing GUI programming in Gnome,
and wish to write graphical plugins or controls, it will
be the ORB that you just use. Consists of quite a lot of providers,
comparable to OAF for naming, and Bonobo for easy-to-use doc
and GUI programming interfaces.
OmniORB
OmniORB
from Oracle & Olivetti has an specific Linux port. Encompasses a
C++ IDL, makes use of IIOP and the IIOP has been examined with different ORB’s,
is multi-threaded, has a COS identify server.
OmniORB Supply is GPL’ed.

MICO

MICO
, the recursively named “Mico Is COrba”, implements a
C++ IDL, DII, DSI, IIOP, IR, a full BOA, a reputation server, help
for “Any” sorts, help for loadable modules. Features a
graphical IR browser. Supply is GPL’ed. Pre-compiled variations
can be found. Present work focuses on a WinNT port.

  • mico/E
    is an extension of mico for the Eiffel programming language.
ORBacus (OmniBroker)
The ORBacus (OmniBroker) from
Object Oriented Concepts, Inc.
affords Java and C++ IDL mappings, in addition to IIOP, DII, DSI
(Dynamic Skeleton Interface),
COS, IR, nested methodology invocation, Dynamic Any. Has an
IDL-to-HTML converter for documentation. Helps threads.
Consists of naming service GUI. Third social gathering
instruments embody a COS Buying and selling Object Service and a scripting language.
Helps C++ threads. Supply code is accessible. Free for
non-commercial use, business use requires a license.
Full help contracts supplied.
OAK
The OAK CORBA
ORB
from
Paragon Software
is exclusive in that it helps Goal-C
bindings,and is thus appropriate to be used with NeXTStep/GnuStep.
Helps IIOP, BOA, DSI, DII, IR, COS. Consists of extensions
for fault tolerance and load-balancing, amongst many others.
OAK is a commercially supported product; they provide a free
trial analysis interval.
COOL ORB
The
COOL ORB
type Chorus
has design options, comparable to a small footprint (50KB),
real-time habits and synchronization providers, that focus
on use in embedded methods. Totally CORBAv2 compliant, affords
IIOP, DSI, DII and IR. Inter-operates with the opposite Refrain
embedded/real-time merchandise; in contrast to most different ORB’s listed
right here, this one is commercially supported. N.B. Refrain has been
acquired by Solar.
ILU
The
ILU (Inter-Language Unification)
ORB from XEROX.
The most recent model consists of help for IIOP, kernel threads,
encryption, and “Any”. Consists of IDL compilers for C++,
ANSI C, Python, Java, Widespread Lisp and Modula-3. ILU additionally
features a self-contained implementation of ONC RPC,
making it doable to make use of present RPC providers as ILU
objects. ILU additionally features a self-contained implementation
of HTTP, permitting CORBA-based internet servers and browsers to be
developed. (Extremely personalized, non-generic internet servers
have gotten more and more fashionable in embedded and
special-purpose purposes.) Code is accessible as freeware.
Watch out for the down-level code situated on the Linux
Sunsite (http://sunsite.unc.edu/pub/Linux/devel/corba/)
repository; go to the principle website for latest code.
Arachne
Arachne
springs out of an effort to develop reusable elements
for the medical area; the trouble continues and is evolving.
Thus, this isn’t solely an implementation; its an implementation
in energetic use by the builders themselves.
Arachne runs on quite a lot of platforms, together with 95/NT, Mac, SunOS,
HP/UX, however Linux is the first improvement platform.
It features a C++ ORB with DII, IR, Any, TypeCode, and
IIOP. It features a subset of COS, and an software
improvement help framework with GUI compnenets. Observe,
nonetheless, the IDL language mapping is

currently non-standard
.
Since this ORB implementation predates CORBA-2 and a few work
stays to replace it. IIOP has been examined in opposition to Visigenics
and ORBacus (OmniBroker).
A python-based software authoring atmosphere is in improvement.
TAO
The
TAO (The Ace ORB)
is a analysis automobile for outlining
real-time extensions to CORBA. TAO consists of an enhanced
C++ IDL compiler, a BOA, and an implementation of normal
IIOP on TCP/IP that has undergone restricted interoperability
testing with ORB’s from a number of distributors. Extra importantly,
it consists of RIOP (Actual-time IOP) extensions to GIOP,
applied on ATM and multi-gigabit {hardware}. It additionally
consists of deterministic real-time occasion service, a real-time
dispatcher/scheduler and an ROA (real-time object adapter).
TAO is affiliated with the

ACE (Adaptive Communications Environment)
, a venture
that has expertise with real-time communications in
telecom and avionics environments. The code is at present
(Sept 97) alpha-level, and runs on Linux, Solaris, and NT.
Electra
The Electra
Object Request Broker
gives V2 CORBA help, together with
BOA, DII, a Tcl/Tk DII, IIOP, a fault-tolerant COS identify server,
a GUI availability monitor, and an occasion channel for C++/Java,
permitting objects to subscribe to data servers.
One among Electra’s sturdy fits are its emphasis on fault-tolerance
and high-availability; consists of help for dependable multi-cast
& synchrony. Electra just isn’t but (Sept 97) very secure on Linux.
COPE
COPE is an ORB written
completely in Perl. It doesn’t present an IR (Interface Repository),
however can use third-party instruments for that function (comparable to ORBacus (OmniBroker)).
JacORB
The JacORB
is a CORBA ORB written completely in Java. Supplies a Java IDL
compiler, helps threads, IIOP, IR, a COS compliant identify service,
and an alpha-level implementation of the COS Occasion service.
Reported to run properly underneath Linux, and to be extra standards-compliant
than a number of the big-name CORBA merchandise. Free, underneath GPL.
Jorba
Jorba
is a CORBA implementation written completely in Java. It consists of
the ORB, DII, DSI, and an IDL compiler. The online web page states
that that is alpha-level code, with many features lacking. It
is supplied in supply type underneath GPL.
CORBAPlus
CORBAPlus
from ExpertSoft affords
a CORBAv2 implementation written in Java. Consists of help
for a Java IDL compiler, IIOP, DII, Any and typecodes. The licensing
phrases will not be completely clear, nevertheless it appears to be freely out there
for any use. Not clear if its been examined on Linux, however ought to
work. Help contracts supplied.
JavaIDL
The
JavaIDL
is a snapshot of SunSoft’s Java IDL compiler.
Features a generic ORB core. Capacity to run underneath Linux is
unsure, requires porting ??. Could require integration with
an ORB core??
Jylu
Jylu
implements the Xerox PARC ILU CORBA core in Java. Features a
Java IDL compiler. Doesn’t discuss IIOP, however does discuss the ILU
wire protocol (Solar RPC protocol??)..
Fnorb
The
Fnorb
is an experimental ORB written in Python. It doesn’t
present an IR (Interface Repository), however can use third-party instruments
for that function (comparable to ORBacus (OmniBroker)).
ROBIN
ROBIN
(RPC and Object Dealer Interface) implements a subset of
the CORBAv2.1 spec. Helps an IDL and DII, doesn’t
at present help IIOP. Deployed in, and focuses on knowledge
acquisition and management methods, together with embedded computer systems.
DOME
DOME from
Object Oriented Technologies
affords threading, callbacks, async operation, location
brokering, in addition to community screens & instruments.
Strengths: runs on a big number of platforms, and helps
many various networking protocols. Weaknesses:
This can be a pre-CORBA 2.0 ORB, and thus the programming
interfaces and protocols are proprietary and non-portable.
OOT affords a free model for Linux. The licensing phrases
are lower than clear: though business redistribution seems
to be prohibited, business in-house use seems to not be.
Bionic Buffalo
The Bionic Buffalo
affords a fundamental ORB w/ C bindings. This can be a business product;
A free model of the ORB, stripped of IIOP, is deliberate.

CORBA Companies

CORBA Services
are implementations of particular interfaces outlined by the
OMG.
These embody issues like safety, persistence,
transactions, question, object buying and selling, naming, occasions, concurrency management,
and collections. Extra providers are being outlined repeatedly.
Comparatively few of those have but to seem in business merchandise,
a lot much less in Open Supply or Freeware type. A number of the fundamental service,
comparable to naming and occasions, are sometimes included with the bottom CORBA
implementation, and are famous above the place relevant. The itemizing
beneath is for stand-alone implementations.

JTrader
JTrader is
an implementation, in Java, of the COS Buying and selling Object Service.
Merchants are objects that find out about providers: in contrast to utilizing the
COS naming service to search out an object by identify, one can use a dealer
to search out an object by the kind of service it affords. Comes with
graphical instruments to handle the service kind repository, the service
affords, and for performing queries. Requires ORBacus (OmniBroker) for
operation, must be (simply?) transportable to different ORB’s.
Carried out in Java, underneath the GPL.

Examples, Tutorials (New Part!)

A couple of intro examples to programming with corba. Extremely incomplete.
Pushes my very own efforts.

Gnome-Bonobo
Examples of programming with Bonobo within the gnome atmosphere
could be considered at

http://cvs.gnome.org/lxr/source/bonobo/samples/

Embrace samples of a easy echo server, a compound doc,
and a GUI management.
Bonobo-Hiya-World
Here lies a tar file containing
a easy ‘hello-world’ kind client-server implementation utilizing
bonobo, oaf and gnome. That is about as fundamental as you may get
within the gnome-bonobo world. It simply sends a easy string
message from the shopper to the server. Observe that this code is
straight-C, not C++ or Java or something.
Browse individual files here
corba-perf
Here lies a easy C++ hello-world
instance, completed up in in fundamental plain-vanilla corba, for the
OmniORB, OmniBroker and Mico ORB’s. Mentioned additional
within the ‘efficiency’ part beneath.

Evaluations

Beneath follows an outline of my private experiences with a few of
these packages. I’m not a testing & analysis laboratory.
I’m a fallible particular person, and can’t keep away from subjective feedback.
Your precise experiences will fluctuate.
Lately (October 97),
I attempted to obtain and use a few of these; the experiences are
not all optimistic.

DCOM/ActiveX
Not Tried. I actually am occupied with Corba and Java RMI,
not by also-rans. I’m additionally pissed off by Microsoft’s by
turns juvenile and malicious habits. Concern has additionally
been expressed that help for Linux/Unix will fade away
after an preliminary flurry of exercise, leaving builders
with no alternative however emigrate to Microsoft platforms.
This concern is enlivened by the truth that the Linux “beta”
has been that since earlier than October 97 — an awfully very long time.
OmniORB2
That is my preliminary favourite. Comes pre-compiled, installs
simply, and it really works. Comes with a number of easy “Hiya World”
examples, along with documentation for the examples,
which can be good for the novice CORBA person. Will get you going and
quick, provides you the sensation that you’re in command, and might
begin being productive creating corba apps.

One necessary strike in opposition to OmniORB2 is the dearth of help for
a number of the extra superior options like DSI and DII. Nevertheless,
(1) they’re engaged on it, and (2) chances are high good that you just
will not want these options till you begin attending to stratospheric
complexity ranges in your software.

MICO
Would not come pre-compiled, and thus requires you to construct it.
This results in construct issues for the unwary. In my case,
I’ve a moderately mangled (ahem, “extremely modified”) Linux system
attributable to years of hacking. Consequently, I skilled construct
issues, all of which I used to be finally in a position to overcome
by upgrading to current variations of gcc, g++-devel, and
binutils. For individuals who expertise related issues:
a sturdy advice to improve to a more moderen
g++-devel bundle (you want the newer header information in
/usr/embody).

Constructed MICO. Count on over an hour on a P133 …
this bundle, w/examples, is large.

Now, transferring on to issues that I loved:

  • The usage of a shared library is good … this retains the
    executables appreciable smaller than they could have been.
    (100KB for MICO, as in comparison with 750KB for OmniORB2).
  • Comes with a pile of instance code, beginning with absolutely the
    fundamentals (see demo/account, then demo/account2, and so on). Nice!
    I can truly perceive this!
  • The good factor was that the mailing checklist was fast to reply
    to my requests for help.
ORBacus (OmniBroker)
Would not come pre-compiled, and thus requires you to construct it.
This results in construct issues for the unwary. In my case,
I’ve a moderately mangled (ahem, “extremely modified”) Linux system
attributable to years of hacking. Consequently, I skilled construct
issues, all of which I used to be finally in a position to overcome
by upgrading to current variations of gcc, g++-devel, and
binutils. For individuals who expertise related issues:
a sturdy advice to improve to a more moderen
g++-devel bundle (you want the newer header information in
/usr/embody).

Like OmniORB2 and MICO, ORBacus comes with some good and
simple to grasp examples. The “howdy world” instance
is properly documented within the the postscript documentation,
though it might have been good to see just a few feedback
embedded within the supply, instantly.

The good factor was that the mailing checklist was fast to reply
to my requests for help.

ILU
Would not come pre-compiled, and thus requires you to construct it.
The construct labored, however the documentation is horrific.
Feeling emboldened by my success with OmniORB, I dived proper
in, and hit a submerged rock. There are not any newbie examples
that I may discover, and the documentation was lower than useful,
throwing round large phrases and large ideas that instantly despatched
me scurrying out of the pool. Hey, I’ve a PhD, and twenty++
years of programming expertise, and oodles of intestinal fortitude.
If I can not hack this, who can?

That is unlucky, since ILU affords the broadest language help
of all of the packages. The tutorial program in all fairness properly
documented, though fairly obtuse, with it is factories and all.
Sure, I do know what an object manufacturing facility is, however given how dramatically
completely different the tutorial is from the opposite CORBA implementations,
it makes me surprise if any code developed on ILU would ever have a
probability of being ported to a distinct CORBA implementation.

(A reader wrote in to remind me: ILU just isn’t CORBA, its an ORB with
CORBA help. Which means that whereas the identical ideas could apply,
the precise philosophies and strategy could be fairly completely different.)

COOL ORB
Have not gotten round to making an attempt this but.
TAO
Did not do this. The website states that that is alpha code,
and I’m not prepared for that.
Electra
Did not do this. The creator of the code said that it wasn’t
secure on Linux, and does not use Linux as a improvement platform.
This scared me off.

General Feedback

One frustration that I see straight away with CORBA is the occasion
that it use the CORBA sorts, like CORBA::Lengthy as a substitute of “lengthy”,
or CORBA::String_var as a substitute of “char *”. Whereas this can be what
the CORBA commonplace requires, and probably extra exact than the
considerably unfastened C++ sorts, it definitely does make the code more durable
to learn. And readability is extraordinarily necessary for constructing
easy to make use of & debug methods.

Interoperability

The three packages OmniORB2, ORBacus and Mico have been put
via a quite simple “Hiya, World” interoperability check.
A easy server was written; the server can echo again no matter
string is shipped to it. Equally, a easy shopper was
written that may contact the server, ship a message and
obtain a reply. Variations in implementation between
the three completely different packages have been surrounded by #ifdef’s
so {that a} single supply might be compiled for all three
ORB methods.

Inspecting the sources, it turns into apparent how nearly-identical,
and but pervasively completely different every of the packages is. Most
frustratingly, ORBacus chooses to implement the CORBA
namespace as CORBA_ moderately than CORBA::. Though this
is technically the extra right resolution (arguably the one
right resolution, see footnote),
it results in broad supply incompatibilities with the opposite
implementations. OmniORB2
implements just a few extensions to help threading, which is good,
however sadly requires the usage of the extensions to
function. Mico seems to be probably the most standards-compliant.
The code could be browsed here, or
downloaded as a tar.gz here.

All three implementations handed the inter-operability
check. Every of the three shoppers have been in a position to discuss contact
and trade messages with every of the three servers. Something
much less would have been unacceptable, as that is the entire level of
IIOP. Observe that this check was very simple & fundamental:
Not solely are the server and shopper bare-bones minimal, however
additionally the COS naming providers weren’t examined: the stringified
IOR was handed in a file.

Efficiency

The efficiency of three completely different CORBA implementations have been
in contrast on a easy “Hiya World” software. The code
could be examined here and could be downloaded
as corba-perf.tar.gz right here.
This code is attention-grabbing not just for measuring efficiency, however
additionally for evaluating the variations between completely different implementations.
A fast survey will present how related, and but frustratingly completely different,
the 2 implementations are.

The next outcomes have been obtained on a Pentium 133
w/ Linux 2.0.30 kernel & gcc 2.7.2.1,
OmniORB2 model 2.2.0,
ORBacus model 2.0b4,
and Mico model 0.93b3,
in October 1997:

CORBA           millisecs    compile time  binary measurement
Implementation   per name     (seconds)    (kiloBytes)
-------------------------------------------------------
OmniORB2          0.80           26         752
ORBacus        1.10           70        2100
Mico              4.20           60         102

Observe that these measurements have been taken in October 1997, and should no
longer be legitimate.

See Also

Clearly, OmniORB2 holds each the uncooked efficiency file,
in addition to the compile time file. Observe that each
ORBacus and OmniORB used statically linked libraries,
whereas Mico makes use of a shared library. This leads to each
smaller binaries for Mico, in addition to probably affecting
efficiency. One purpose why the ORBacus binaries are
significantly bigger is that ORBacus consists of significantly
extra operate than OmniORB. I imagine that OmniORB
could be constructed as a shared library, and, by the point you
learn this, ORBacus shall be as properly. Observe: the
shared-library model of ORBacus leads to binaries
within the 100K ballpark, and improves efficiency almost ten
p.c, most likely (virtually definitely) attributable to improved cache
hit ratios.

Many readers have written in to notice that ORBacus
could be compiled as a shared lib. Strive the next in
/config/Make.guidelines.in:

    CXX=g++
    CXXFLAGS= --no-implicit-templates -fhandle-exceptions -Wall
    AR=g++
    ARFLAGS= -shared -o
    RANLIB=:
    LIBEXT=.so

and within the shell,

  export LD_LIBRARY_PATH="`pwd`/lib:`pwd`/idl:`pwd`/naming:$LD_LIBRARY_PATH"
  configure
  make

The above desk exhibits efficiency for a shopper and server
operating on the identical machine. The desk beneath exhibits
efficiency over the community. One of many community machines
is an Intel 486DX4 w/ Linux 2.1.26, the opposite a Pentium-133
with Linux 2.0.30. Each machines have low-cost NE2000 10Base2
Ethernet playing cards. The column labelled “fastclient” has the
shopper operating on the quicker machine, and “slowclient” is
vice-versa.

     ------ NETWORK PERFORMANCE ---------
CORBA                 milliseconds per name
Implementation   native     fastclient     slowclient
-------------------------------------------------------
OmniORB2          0.80        2.30           2.30
ORBacus           1.10        3.00           3.15
Mico              4.20        8.50           7.90

Observe that in the entire community exams, CPU utilization didn’t
exceed 60%, indicating that the efficiency is bottle-necked
within the Ethernet {hardware}. Observe that the two.1.x sequence of
kernels are reputed to have considerably improved TCP-IP
efficiency.

Disclaimer: efficiency is one thing that the majority
implementors care about, and efficiency measurements are
by necessity dated. The above exams have been carried out in
October 1997, and newer variations could have considerably
improved efficiency traits.

Vital Observe: Earlier than making rash assumptions
in regards to the relative efficiency of those ORB’s, please word
that some (many?) business implementations seem like
a full order of magnitude slower than Mico!. See, for
instance, the
JacORB Performance Comparison
. The figures there point out
a ten-millisecond ping time for some fashionable business packages,
which may be very stunning, provided that the above exams will not be a lot
greater than a ping, run on gradual machines with dangerous Ethernet playing cards.
See additionally a touch that Linux holds the

world speed record for CORBA
.
A radical,

scientific investigation of CORBA performance

is being carried out by D. Schmidt.

Footnotes

At present, Solely the egcs-1.1.1 compiler helps namespaces;
GNU C++ variations 2.7 and a couple of.8.1 don’t. Sadly, egcs just isn’t (but)
widespread or extensively supported. Lack of namespace help places
a constraint on how the CORBA spec is interpreted, and the way
it may be applied. What many (most) CORBA implementations
do within the face of this compiler limitation is to
map CORBA modules to C++ courses (as a substitute of C++ namespaces,
as they need to have). This results in a technical violation of
the CORBA spec. Think about the instance:

module A {
      interface X { void xxx(); };
};

module B {
      interface Y : A::X { void yyy(); };
};

module A {
      interface Z : B::Y { void zzz(); };
};

This instance breaks any implementation that confuses courses with
namespaces. Let’s think about the code that will be generated:

class A {
   class X {
      void xxx();
   };
};
class B {
   class Y : digital public A::X {
      void yyy();
   };
};
class A {         // oops -- re-declaration -- a C++ syntax error
   class Z : digital public B::Y {
      void zzz();
   };
};

This drawback can’t be solved with a better IDL processor,
for the reason that varied modules could also be outlined in several information,
and never be compiled on the identical time.
An instance of a extra technically right implementation,
the one which ORBacus makes use of, is:

class A_X {
   void xxx();
};
class B_Y : digital public A_X {
   void yyy();
};
class A_Z : digital public B_Y {
   void zzz();
};

This implementation is supported within the CORBA spec:

3.13 Names and Scoping
[…]An identifier can solely be outlined as soon as in a scope. Nevertheless,
identifiers could be redefined in nested scopes. An identifier
declaring a module is taken into account to be outlined by its first
prevalence in a scope. Subsequent occurrences of a module
declaration throughout the identical scope reopen the module permitting
further definitions to be added to it.
[…]

Because of Marc Laukien of Object-Oriented Ideas, Inc.
for clarifying this.


Final up to date October 2001 by Linas Vepstas
(
linas@linas.org)

Copyright (c) 1996-2000 Linas Vepstas.

All logos on this web page are property of their respective house owners.

Permission is granted to repeat, distribute and/or modify this doc
underneath the phrases of the GNU Free Documentation License, Model 1.1;
with no Invariant Sections, with no Entrance-Cowl Texts, and with no
Again-Cowl Texts. A replica of the license is included on the URL
http://www.linas.org/fdl.html,
the net web page titled
“GNU Free Documentation License”
.

Go Back to the Enterprise Linux(TM) Page

Go Back to Linas’ Home Page

Best viewed with the Beast

Source Link

What's Your Reaction?
Excited
0
Happy
0
In Love
0
Not Sure
0
Silly
0
View Comments (0)

Leave a Reply

Your email address will not be published.

2022 Blinking Robots.
WordPress by Doejo

Scroll To Top