Conflicts:
Cargo.toml
src/converter.rs
src/transmutable.rs
Merged the code duplication removal from transmutable into the changes
made to handle the conversion in a safer fashion.
The previous code was relying on the to_be and to_le functions from the
standard library. These now rely on macros that I wrote to handle the
bit packing and unpacking. These were macros and not functions because
it is really hard to define the types and capabilities needed to
turn them into general functions. As such, the macros should never be
published publically and the Converters should be used for conversions.
The Transmutable property should be used for serialization and internally
the primitive types, Elements, all use the Converter functions and any
other objects should use the Transmutable primitives to build their
binary forms.
An into_bytes function, which just called as_bytes, was decided as not
being needed because it would require that the Transmutable trait have
the requirement of being Sized. This may not be desirable in the future,
so for now there is no into_bytes. It can easily be added later with
a change to 9 lines of code.
The Sigils library will now only be compiled in and able to convert
math structures if the convert_sigils feature is selected.
use_std would have also been set as a feature, but the library heavily
uses std::collections::vec::Vec. Until a non-std version of a collection
has been written, then this needs to be used.
This was changed to make everything easier to use. The mutable buffers
were not working well for combined types. It was move to a growable array
to make these more advanced combined types, other structures, easier to
implement.
This added the ability to more easily print Vectors and Quaternions.
This also fixes some style issues.
Missing documents will now cause warnings when building.
A Vector can now be converted to and from bytes of data.
I'm not entirely sure that the structure bytes do not have to
be handled for endianess, but the underlying basic types are
correctly handled.
Tests and and example have also be created. The tests lib file was split
into a converter test file and a transmutable test file.
There is now a ByteSized trait that can be used to specify how many
bytes it takes to represent a piece of data. This has been implemented
for all of the primitive number types. With this information Transmutable
was able to create a Vector2 wrapper that will need to be tested. If it
works then soon after Vectors and other Sigils types can be turned into
Transmutable types.
This also has the changes for the original tests and example
to use the new ByteSized information.
Numbers can be converted to and from bytes in both
BigEndian and LittleEndian styles. This does not yet take care of
the other mathematical structures provided by Sigil.
Also, no tests of these capabilities have been written yet.
