GitLab

An empty list (m_) has no pointer so cannot be referenced. Instead we
now return a null pointer (which is no problem for UList)

- the size_ was not being adjusted in two assignment operators:
      PackedList<nBits>::operator=(const PackedList<nBits>&)
      PackedList<nBits>::operator=(const UList<label>&)

- provides a convenient (and lazy) means of removing entries

- resize with factor 2 as per DynamicList

Old insertion speed:
    1000000 in 0.61 s
    2000000 in 2.24 s
    3000000 in 3.97 s
    4000000 in 5.76 s
    5000000 in 7.54 s
    6000000 in 9.41 s
    7000000 in 11.5 s

New insertion speed:
    1000000 in 0.01 s
    2000000 in 0.02 s
    3000000 in 0.01 s
    4000000 in 0.02 s
    5000000 in 0.01 s
    6000000 in 0.01 s
    7000000 in 0.01 s

- now that I re-examined the code, the note in commit 51fd6327
  can be mostly ignored

  PackedList isMaster(nPoints, 1u);
  is not really inefficient at all, since the '1u' is packed into
  32/64-bits before the subsequent assignment and doesn't involve
  shifts/masking for each index

  The same misinformation applies to the PackedList(size, 0u) form.
  It isn't much slower at all.

  Nonetheless, add bool specialization so that it is a simple assign.

- this builds on Mattijs' commit 968f0bbd but with a first()
  as well.

- Added both to FixedList, IndirectList, UIndirectList and *PtrList and
  since they can certainly be useful there. Did not add to BiIndirectList,
  since I'm not sure what it should mean there. Did not add to PackedList,
  since it's not clear how useful they'd be yet in these contexts (and I'm
  not sure how it would interact with the iterator proxy implementation).

- Note: STL defines front() and back() for these methods.

- allow construct with Xfer container for the addressing

- Replaced non-const addressing() method in BiIndirectList with
  resetAddressing() method as per IndirectList

- use shift-right instead of shift-left formulation to avoid wrong behaviour
  with non-optimized compilation when the packed items fit exactly in the
  available number of bits.

Mark Olesen authored Jul 23, 2009 and Andrew Heather committed Jul 23, 2009

- use shift-right instead of shift-left formulation to avoid wrong behaviour
  with non-optimized compilation when the packed items fit exactly in the
  available number of bits.

- Read a bracket-delimited list, or handle a single value as list of size 1.
  Mostly useful for handling command-line arguments.
  eg,
      if (args.options().found("patches"))
      {
          patches = readList<word>(IStringStream(args.options()["patches"])());
      }
  can handle both of these:
      -patches  patch0
      -patches \( patch1 patch2 patch3 \)

- DynamicList gets append methods as per List
- misc cosmetic changes

- PackedList comments
- solution.C verbosity about new solver syntax on master only

- TODO: binary output is still a bit silly

- If the underlying type is contiguous, FixedList hashes its storage directly.
- Drop labelPairHash (non-commutative) from fvMeshDistribute since
  FixedList::Hash does the right thing anyhow.
- Hash<edge> specialization is commutative, without multiplication.
- Hash<triFace> specialization kept multiplication (but now uLabel).
  There's not much point optimizing it, since it's not used much anyhow.

Misc. changes

- added StaticAssert to NamedEnum.H
- label.H / uLabel.H : define FOAM_LABEL_MAX, FOAM_ULABEL_MAX with the
  values finally used for the storage.  These can be useful for pre-processor
  checks elsewhere (although I stopped needing them in the meantime).

- catch people using silly template sizes for FixedList, PackedList

- compare iteratorBase == iteratorBase by value, not position
  thus this works
      list[a] == list[b] ...

- compare iterator == iteratorBase and const_iterator == iteratorBase
  by position, not value. The inheritance rules means that this works:
      iter == list.end() ...
  this will compare positions:
      iter == list[5];
  Of course, this will still compare values:
      *iter == list[5];

- Hash returns unsigned
- FixedList templated on unsigned int
- include uLabel.H in UList, HashTable etc. so the output function is know
  throughout