- can stop producing content when the target number of entries has
  been reached.

- change return type to labelList instead an Xfer container.
  This allows return-value-optimization and avoids a surrounding
  allocation. This potentially breaks existing code.

- make PackedList and PackedBoolList moveable. Drop xfer wrappers.

- use allocator class to wrap the stream pointers instead of passing
  them into ISstream, OSstream and using a dynamic cast to delete
  then. This is especially important if we will have a bidirectional
  stream (can't delete twice!).

STYLE:

- file stream constructors with std::string (C++11)

- for rewind, explicit about in|out direction. This is not currently
  important, but avoids surprises with any future bidirectional access.

- combined string streams in StringStream.H header.
  Similar to <sstream> include that has both input and output string
  streams.

- Introduce writeList(Ostream&, label) method in various List classes to
  provide more flexibility and avoid hard-coded limits when deciding if a
  list is too long and should be broken up into multiple lines (ASCII only).

- The old hard-code limit (10) is retained in the operator<< versions

- This functionality is wrapped in the FlatOutput output adapter class
  and directly accessible via the 'flatOutput()' function.

Eg,
    #include "ListOps.H"
    Info<< "methods: " << flatOutput(myLongList) << endl;

    // OR

    Info<< "methods: ";
    myLongList.writeList(os) << endl;

This reverts commit c5bea524.

This reverts commit b18f6cc1.

- easier to clean, avoid confusion with 'real' applications, etc.

- previously using an '|=' or '^=' would increase the list size to
  match the RHS. Now it only increases to last bit set.

- limit bit-wise operations to addressable range for minor efficiency
  improvement

- trim results from '&' and '^' operations for more consistent
  behaviour

The compact ASCII format is a block of index/value tuples for the
non-zero entries:

    { (index1 value1) (index2 value2) (index3 value3) }

For PackedList<1>, and thus PackedBoolList, the compact ASCII format is
a block of indices for the non-zero entries:

    { index1 index2 index3 }

Thus either of the following could be used - for PackedList<2>:

  - a list of all values:
        16(0 3 0 2 0 0 3 1 0 0 0 0 0 0 0 1)

  - a block of index/value tuples:
        {(1 3) (3 2) (7 3) (8 1) (15 1)}

For PackedList<1> and PackedBoolList, either of the following could be
used:

  - a list of all values, using any valid bool representation:
        16(0 1 0 true 0 0 t 1 0 n n 0 0 0 0 yes)

  - a block of the indices for non-zero entries:
        {1 3 7 8 15}

ENH: adjust internal storage of PackedList to ensure that all unused
     internal storage elements are guaranteed to always be bit-wise
     zero. This makes the PackedBoolList implementation easier, and
     also greatly eases much of the book-keeping.
     Bits are now also zeroed on PackedList::clear()

Note: in PackedList, require packing at least 2 items otherwise it is
     more efficient to use a normal list.