Instead of having several AI* classes, it turned out to be easier to
have a namespace: this allows me to define the classes in llcommon but
add (new) 'add' and 'add_modal' functions to 'AIAlert' in llui.
This is needed to avoid a collision with the 'add' functions in
LLNotificationsUtil.
The new add/add_modal makes it a lot easier to just show a caught
alert, prepending or appending new text: it turns out that that is
way more common then a re-throw.
Adjusted code as appropriate.
In order to remove code duplication, and as prove of concept,
I redid the linden_genepool archetype export and import (from the Edit
Appearance Floater), using AIXML and AIAlert.
The import/export code did shrink significantly, and became a lot
simpler. Although a new file pair (aixmllindengenepool.{cpp,h}) is
added to define the (de)serialization of the linden_genepool XML format,
that code is now centralized in one place, and still a lot simpler.
As a bonus however, every possible error is now semi-automatically
reported to the user with all details that might help to overcome
the problem, like file names and system errors.
The AIXML* classes provide an Object Oriented way to serialize objects
to and from an XML file. Documentation is added at the top of aixml.cpp
These classes will be used by AIMultiGrid.
This fixes quoted strings, like <tag>"Hello \"World\""</tag>,
which otherwise might not be processed correctly because
the XML_CharacterDataHandler isn't guaranteed to be called
exactly once per element. It certainly isn't when a string
contains entities, ie: <tag>"'Hello \"World\"'"</tag>
certainly fails to be unescaped with the old code.
Moreover, the old unescape code things that a singly quote
is actually a quoted string (not noting that begin and end
quote are the same) and destructs all " entities; also
fixed with this commit.
A system to throw errors that allow for easy error reporting to the user
by showing a translated pop-up alert box with the error message.
The messages use strings.xml for translation and allow the usual
replacement args (ie [FILE] is replaced with a filename).
The exceptions can be cascaded, by adding more (translated) text
when caught and then re-throwing the result.
Macros are being used to support adding a function name prefix
to a message of the current function that the exception is thrown
from.
The syntax is:
<macro>(<line>); to show 'line'
<macro>(<alert>, <line>); to append 'line' to a caught alert.
<macro>(<line>, <alert>); to prepend 'line' to a caught alert.
where <macro> is one of:
THROW_ALERT, THROW_MALERT, THROW_FALERT, THROW_FMALERT,
THROW_ALERTE, THROW_MALERTE, THROW_FALERTE, THROW_FMALERTE, where
M = modal, F = Function name.
and where <line> is one of:
<xmldesc>
<xmldesc>, AIArgs<args>
where <xmldesc> is a string literal that will be looked up
in strings.xml, and <args> is:
(<key>, <replacement>)[<args>]
There are more variations of the macros to throw an arbitrary
class (append _CLASS), include an int code (append C) or
to store the current errno as code (append E).
For example, THROW_MALERTC(code, ...), or THROW_FALERT_CLASS(Foobar, ...),
where the ... is the same as for the macros above.
Documentation and example usage has been added to aialert.h.
* Add LLMD5::clone(unsigned char const*), the inverse of LLMD5::raw_digest.
* Add LLMD5::clone(std::string const&), the inverse of LLMD5::hex_digest.
* Add LLMD5::isFinalized(), returns true if the object is finalized.
* Turn all binary operators into inline friends in the class.
* Fix operator<< to take a LLMD5 const& instead of a LLMD5&.
These changes are needed for / used by AIMultiGrid.
These includes are needed. The current code includes them
in .cpp files *before* including these include files, but
that is not very clean, and not useful.
Actually including what a header file needs makes it more
clear what it drags in, it doesn't drag in more then before.
It also allows to include these headers without having to
includes needed for the included header file in a specific
order, in every .cpp file.
