Continued debugging BP1 Writer for a single variable write

see examples/hello/dataman and examples/hello/writer for working
examples

Reduced number of functions
Created BP1.h for common functionality and structs (with potential
reader)
Moved common functions to adiosFunctions adiosTemplates and BP1.h

To do:

Attribute var index
PG var index
Max Buffer size and transport handling

Tested memory leaks with valgrind for simple example
Verifying if variable index is written correctly

Added ./src/format/BP1Writer.cpp

To do:
Need to test for array index and payload write

BP1Writer: Continue working on functions to write data and metadata

Group: added Dims alias and SetDimensions function, so dimensions can be built from a Var List put in an std::initializer_list<Var>

Once the char* raw pointer is obtained with virtual Get, write
operations can be performed directly

include/functions/bp1Write.h

Added example/hello/dataman with API examples
Changed mpidummy.h due to an error in Titan compilation with g++

This version compiles. 
Tested with 2 write APIs:

under examples/hello/singleBP
helloSingleBP.cpp -> using ADIOS single manager class from ADIOS.h
helloSingleBP.cpp -> using ADIOS objects from ADIOS_OO.h

both generate a .bp file using a POSIX transport

To do:
Test compilation in other platforms/compilers
Add coverage test cases
Add the NULL transport (does nothing)
Work on SingleBP engine to generate bp format
XML config file support (to be defined)

Understanding BP file format and each record.

To do:

Move Metadata out of FStream transport. Keep it simple.

Finished working on WriteData and WriteMetadata functions

To do:

Need to work on Single (single heap capsule) engine

Heap -> allocate capsule buffers in heap memory
ShmSystemV -> allocate capsule buffers in shared memory using System V
shm

Implementing Write Functions in Engine
Implementing Write Functions in Capsule

To do:
Buffer Getter and Setters for each Capsule

Added Heap class deriving Capsule

Added Single class deriving Engine

Variable now has a pointer reference to a Transform object

Added Method struct needed for Engine

Introducing Engine

Defining Write API cases

Removed public directory

Renamed all files, structs and classes. 
Now using the standard describe in Classes / Structs under
doc/CodingGuidelines

Need to do:

Test two transports (POSIX, DataMan) simple examples (e.g.
examples/dataman/dataManNoXML.cpp)

Test XML parser, add functionality for tag content, need to decide on
transport 

Code coverage, test most of the current functionality to move on to
transform, bp format, etc.

Added Support for more than one transport
ReFormulated classes ADIOS, Group, Capsule, Variable including members
ownership ( CCapsule.m_Transports, ADIOS.m_Tranforms )

To do:
Test compilation 
Adjust to new naming convention (removing C and S)
Implement and test one variable compression

Added variable field for compressionLevel
Finished working on CGroup

To do:
Work on Write method (without transform first)
Test for more than two transports

Added more functions to the ADIOS class including template variadic
functions

Working on the CCapsule class


Need to work on CGroup.h and CGroup.cpp 

Working on class CGroup and CCapsule

Adding variadic functions Open and Write to pass different options as
different transport will require different arguments.

Rewriting class CCapsule, now representing a stream with a buffer,
metadata and a collection of CTransports.

Write API would focus on Streams, not Group. This is for consistency
with a Read API.

To do:

Finish reorganizing the code for compilation.

CDataMan now has a different constructor as CTransport need the name for
CCapsule operations. 

Added ./include/functions/CCapsuleTemplates.h Working on CCapsule using
template Write functions and a threaded version of memcpy (must be
tested with large data).


To do:

Test current code
Need to work on Metadata
Need to work on Attribute Write

Defining ADIOSFunctions.h and ADIOSFunctions.cpp functions called from
ADIOSTemplate.h. Once type is known, no need for templates.

Need to implement CCapsule WriteToBuffer function using raw data, void*
and sizeof

Working on Write function so CCapsule can write to its m_Buffer

Set include/transport/CDataMan.h and src/transport/CDataMan.cpp for
integration with DataMan TCP communication

Created examples/dataman/datamanNoXML.cpp for later testing of DataMan
transport method

Need to compare memcpy and insert performance for writing to a
vector<char> buffer

Removed Shared Memory for now. Need to think were to put these.

Removed priority and iterations mapping for transports for now.

Implementing CPOSIX (C FILE*) and CFStream (C++)

Added CCapsule parent class

Virtual functions can't use templates, using overloaded ones

1) Moved write out of transport

2) Moved transport and transform members into CCapsule

3) Completely rearranged CGroup to move functionality to CCapsule


To do:
Test template implementation.