Date: prev next · Thread: first prev next last
2016 Archives by date, by thread · List index


On 11/23/2016 02:01 PM, Jan Holesovsky wrote:
Stephan Bergmann píše v St 23. 11. 2016 v 12:51 +0100:
The Java UNO runtime represents UNOIDL enum values as non-null
references to specific Java class instances (where those classes are
derived from com.sun.star.uno.Enum).  The bytecode generated for those
classes contains functions that map from enum integer values (as
obtained through the UNO bridges) to instances of those classes.  For
invalid values, that bytecode happens to return null references (it
could also throw exceptions, say).  So Java code confronted with an
extended UNOIDL enum will likely throw NullPointerExceptions and fail.

From the code I've read now, I see no indication that we would be
throwing NullPointerExceptions for the wrong values:

  ridljar/com/sun/star/uno/Enum.java

just happily returns whatever it was asked for:

    /**
     * Get the integer value of an enum value.
     * @return   the integer value.
     */
    public final int getValue() {
        return m_value;
    }

That's not the code I was talking about. See handleEnumType (codemaker/source/javamaker/javatype.cxx) for the generated Java fromInt methods.

Also

  com.sun.star.Blah.BlehEnum var = something(...);

where something() was extended in LibreOffice to return an additional
com.sun.star.Blah.BlehEnum's value should be fine, as the 3rd party
extension is supposed to use the jar's from LibreOffice it is running
against (ie. the new ones that contain the addition) - so all is
transparent there, right?

An extension will use the jars from the LO installation it is installed in. A 3rd party app (esp. when run on a different machine) could use older jars.

Or where exactly is the code that makes sure it throws, please?

What "code that makes sure it throws"?

For client code that means:  When consuming such an integer value it
must be prepared to be presented with a value it does not know.  And
when producing such an integer value it must be prepared that any
consumer does not know the value.  Code written in such a way that it
does not support those requirements is broken.

Sure, but that's a completely different argument from my point of
view :-) - ie. semantic; not a language / technology limitation.

Not sure what you want to say with that. What /I/ wanted to say is, yes, exactly, there's a semantic difference between the non-extensible enum and extensible constant group/underlying integer approaches. Chose the one that is supposed to fit your problem better.

Considering that everybody introduces just constants and not enums in
the new code anyway (because of the 'extending enums is painful'
argument), I am proposing to open up the enums for additions for 5.3 as
a general (semantically) incompatible change, so that we don't have to
do the 'SomethingBlah2' dance every time we need to add stuff to an
enum.

First of all, not every concept is better modelled with a constant group than with an enum. The choice needs thought, of course, and there's likely been various mis-choices across the API.

Second, enums just can't technically be extended compatibly in the same way that constant groups can be; see the Java fromInt issue above.

But whether we "have to do the 'SomethingBlah2' dance" is somewhat detached from those technical issues: If we consider the pros of doing an incompatible change higher than the cons, we do such a change.

Context


Privacy Policy | Impressum (Legal Info) | Copyright information: Unless otherwise specified, all text and images on this website are licensed under the Creative Commons Attribution-Share Alike 3.0 License. This does not include the source code of LibreOffice, which is licensed under the Mozilla Public License (MPLv2). "LibreOffice" and "The Document Foundation" are registered trademarks of their corresponding registered owners or are in actual use as trademarks in one or more countries. Their respective logos and icons are also subject to international copyright laws. Use thereof is explained in our trademark policy.