Add STL iterators to Vector (and maybe Matrix)

[BigUglySpider]

EmuMath::Vector

As Vector is effectively a wrapped std::array (although this is not an EmuMath guarantee), it seems reasonable to allow the STL container interface to be used with it. This is especially the case for the few functions which break usual Emu library naming conventions to mimic STL functions (such as at instead of At).

Under current implementations, this will be extremely trivial for value-containing Vector types. Reference-containing Vector types will need some additional work.

EmuMath::Matrix

Matrices already provide a flattened index method of access, which provides column-major access regardless of a Matrix's actual major-storage order.

• Changing this to a contiguous access is being considered, although it is preferred to maintain a consistent access interface across all Matrix types regardless of column-major order.

An STL iterator implementation will likely be in contiguous order to support a method of contiguous flattened access, and provide a similar interface to the Vector implementation.

As of this issue's post, it is uncertain whether an iterator implementation will be provided for Matrix.

---

Proposal for EmuMath::Vector::iterator (and variants)

As std::array storage is not guaranteed by Vector, it would be preferable to implement a custom iterator for all kinds of Vector, instead of conditionally choosing between std::array::iterator (and variants) or a custom iterator.

Implementation

• A simplistic template struct which takes an EmuMath::Vector typearg.
  • A std::enable_if_t trigger should be used to guarantee the provision of EmuMath::Vector types only, or alternatively a partial specialisation (std::enable_if_t is more semantically clear for this).
• Stores a (private) pointer to a Vector's stored_type.
• Provides a public interface to the value_type
  • For example, using value_type = Vec::value_type;, using pointer_type = Vec::value_type*;, etc...
  • This allows both value-containing and reference-containing Vectors to operate under the same interface, with the same semantics as general Vector access, and keeping the stored_type hidden to prevent easy nefarious use of contained reference wrappers.
• This approach allows this to be a random_access_iterator, providing the same level of permission as a std::array.
• This should explicitly be a public template, and not defined within the Vector body itself. This is to allow for easy access to the iterator type for Vector specialisations.

[BigUglySpider]

Addressed as of commit d4b90245fe84297b57fa18a8bec1e66a5f4be595 (for EmuMath::Vector).

Matrix implementation is still undecided, but no decision is being made for now. It will likely be decided after mutation (and related operations) is complete.

Closing this issue as a result; if Matrix STL iterator support is considered desirable, another issue should be made.

[BigUglySpider]

STL Iterators have been added to Matrix as of commit 0c0800af7fcc2b8a84db0de42a75233bdb05a76d, pull request #46.