Makes DataGroup valid if any NamedData isValid().

DataGroup is a collection of NamedData, with constant names & indices
for the entries.  When a DataGroup is assigned via operator= (and at
other times), we assert on DataGroup::isValid(), which now returns true
if any of the NamedData isValid().

The UnitTests have been expanded to illustrate expected and incorrect
usage of DataGroup.
Adds UnitTest for partial initialization of DataGroup.
Revert the change to DataGroup::isValid.

The original code asserts that all of the NamedData have the same
validity.
Renames NamedData::isValid to isInitialized.

"Valid" could have different interpretations.  The function tests
whether or not the NamedData object has an IndexDirectory, but not
the existence of anything in that IndexDirectory or the correctness of
any data associated with names/indices.  "isInitialized" is less
likely to be misinterpreted in these ways.

Also, updates documentation and assert messages for clarity.
NamedData asserts on existence of m_directory before accessing it.
Renames DataGroup::isValid to isInitialized.

With the renaming of NamedData::isValid to isInitialized,
DataGroup::isValid should be renamed for consistency.
Also, this avoids the possible confusion users might have about the
meaning of "valid", e.g., whether or not a DataGroup is valid if it
contains bad data.

Also updates documentation and assert messages for clarity.
Removes whitespace at ends of lines in DataGroup.h and NamedData.h
Rename variable for clarity and move comment in DataGroupTests.

The test had Datagroups data, data2, data3, data5.  This renames data5
to data4 so the reader isn't looking for the missing value in the
series.

Also, moves the comment about why data=data4 is ok to the line that
does the assignment.
Re-adds documentation on immutability of DataGroup's data layout.

The const-ness of the entries is actually a function of NamedData, not
of DataGroup, but the user of DataGroup should be made aware of that
immutability.
Reverts NamedData::isValid name-change in commit 1a773da.

Keeps the documentation changes from that commit.
Removes CommonDevice::setInput and its single argument constructor.

CommonDevice should be passed an initial DataGroup on construction, to
setup the DataGroup that will be passed to/from the device.  By allowing
CommonDevice to be constructed without the initial DataGroup, extra
functionality was required to check whether or not that data had been
set.  The only class that used the single-argument CommonDevice
constructor was PoseIntegrator, which did so just for convenience.

Instead, PoseIntegrator now gets the DataGroup in its constructor,
which is called from MultiAxisDevice.  MultiAxisDevice gets the data
from its member RawMultiAxisDevice (which is a CommonDevice).  To do so,
MultiAxisDevice's constructor is now a friend function of
RawMultiAxisDevice.  Also, CommonDevice::getInitialData has a non-const
version.

As a bonus, this reduces the number of places in the code that we
check the validity of a DataGroup, a function which is being refactored.
Removes DataGroup::isInitialized/isValid because it is not needed.

DataGroup::isInitialized (recently renamed from isValid), was being used
in DataGroup::operator= to check if all of the member NamedData were
valid before assigning from them.  That test was not necessary because
NamedData::operator= performs the same validity check.

After removing direct calls to DataGroup::isInitialized, all of the
DataGroup's UnitTests worked without further changes, demonstrating how
the assertions are still being performed (just in NamedData).

The other places isInitialized was used were:
1) in InputComponent to test the input data (unnecessary because the
LockedContainer::set will call DataGroup::operator=), and
2) in CommonDevice's addInputConsumer and pushInput to check the
initial data and input data, respectively.

When a DataGroup is being passed between a CommonDevice and an
InputConsumerInterface, the same DataGroup object should be used for
initialization and each time pushInput is called, which should ensure
that the DataGroup's NamedData are always valid.  Also, if the
InputConsumerInterface to which the input is being pushed assigns the
DataGroup to a member variable in handleInput (like InputConsumer
setting the DataGroup into a LockedContainer), the assignment will cause
an assertion anyway (if any of the DataGroup's NamedData are not valid).
Make CommonDevice's DataGroups protected so derived classes can access.

Derived classes can currently access the data through, for example,
getInputData, but that function should be refactored next.  It makes
sense that a Device could access its own data without having to
override the CommonDevice's data variables.
Removes unused functions and adds documentation for CommonDevice.

CommonDevice had two functions that were not being called, a non-const
version of getInitialInputData, and a const version of getInputData.
They have been removed for simplicity and to simplify refactoring of
getInputData into getter/setter.

Also, adds documentation to CommonDevice's un-documented functions, and
updates some of the documentation that was there.
Access to CommonDevice's DataGroups is now through getters/setters.

Previously, getInputData would return a reference for modification of
the DataGroup, which did not match the style throughout OSS.

The getters/setters are protected, and meant to be used by the friend
scaffolds, as described in the documentation for the functions.  This
change does not affect the PushInput/PullOutput functionality.  This is
how the scaffold will set m_inputData from the device's SDK, so that
DataGroup can be pushed to the input consumers.

Note that derived classes can access the DataGroup member variables
directly...(so can the friend scaffolds, but that looks odd).
Merge remote-tracking branch 'origin/master' into fix/datagroup-validity
Merge branch 'master' into fix/datagroup-validity
Reverts the changes to getters/setters for CommonDevice's DataGroups.

Now that the member variables are protected, the getter/setter idiom
does not seem necessary.  We can continue to return a non-const
reference.
Finish reverting CommonDevice's DataGroup access functions.

Forgot that two of the three functions were originally const.
Makes CommonDevice's DataGroups private.

Now the accessors must be used for a subclass device or its scaffold to
access the device's m_inputData, m_outputData, or m_initialInputData.