This doesn't do anything useful yet, because we can't build with
--all-features because of the conflicting rustls/openssl features...

This does not matter much because users need to replace usages of these
anyway, but it's better to have it right here to not cause additional
confusion.

Because why not!

They only contain cached information and thus don't need to be included
in comparison and identity operators.

Fixes #123.

This allows to use them interchangably when looking up keys in hash sets
and dicts.

This moves InnerJid into Jid and reformulates BareJid and FullJid in
terms of Jid.

Doing this has the key advantage that FullJid and BareJid can deref to
and borrow as Jid. This, in turn, has the advantage that they can be
used much more flexibly in HashMaps. However, this is (as we say in
Germany) future music; this commit only does the internal reworking.

Oh and also, it saves 20% memory on Jid objects.

Fixes #122 more thoroughly, or rather the original intent behind it.

See release notes [1] for details.

   [1]: https://codeberg.org/jssfr/rxml/releases/tag/v0.10.0

This is useful for printing with quotes without copying any data.

This provides a non-copying API, which is generally favourable. The
other accessors were removed, because the intent was to provide this
"most sensible" API via the "default" (i.e. shortest, most concisely
named) functions.

This provides standard-library-like output.

This introduces a str-like type for each of these, which will allow
returning a ref instead of the copied data from various methods in
{Full,Bare}Jid.

The use of a macro ensures that all types are declared consistently.

This seems to be related to an update of chrono. 32-bit sizes verified
using `cargo test --target i686-unknown-linux-gnu`.

This allows constructs like:

```rust
let residual = match Iq::try_from(stanza) {
  Ok(iq) => return handle_iq(..),
  Err(Error::TypeMismatch(_, _, v)) => v,
  Err(other) => return handle_parse_error(..),
};
let residual = match Message::try_from(stanza) {
  ..
};
let residual = ..
log::warn!("unhandled object: {:?}", residual);
```

The interesting part of this is that this could be used in a loop over a
Vec<Box<dyn FnMut(Element) -> ControlFlow<SomeResult, Element>>, i.e. in
a parsing loop for a generic XML/XMPP stream.

The advantage is that the stanza.is() check runs only once (in
check_self!) and doesn't need to be duplicated outside, and it reduces
the use of magic strings.

This should improve performance a little.

Note that this is a breaking change, as it changes the struct definition
and now requires additional fields when constructing the struct.

These became warnings in a recent nightly.

The TryFrom/TryInto imports were missed in
4089891f6c96bb025de8c9a77b2e58b568534a74, but the rest are truly
redundant.

Since Rust 1.76, and some much older nightly, there have been
improvements to the niche computation, which leads to smaller types
which can encode the same amount of data, variants, and such.

This fixes the tests on this compiler version.

Signed-off-by: Maxime “pep” Buquet <pep@bouah.net>

Signed-off-by: Maxime “pep” Buquet <pep@bouah.net>

Signed-off-by: Maxime “pep” Buquet <pep@bouah.net>

Signed-off-by: Maxime “pep” Buquet <pep@bouah.net>

Signed-off-by: Maxime “pep” Buquet <pep@bouah.net>

Heavily based on JoinJabber.org's CoC.

Signed-off-by: Maxime “pep” Buquet <pep@bouah.net>