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

Changed SSupport.cpp to Support.cpp
Added mkdir -p ./lib in Makefile
Switched CBZIP2.h to BZIP2.h in Capsule.cpp

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.

Adding metadata m_SerialSize in CGroup for potential preallocation of
serialized metadata.

Removing any template functionality. Incompatible with C and Fortran
support with void*.

Need to work on tracking milestones.

Modified CGroup.m_Variable to allow for Global Dimensions and Offsets
and const members at creation

Modified CGroup member functions to allow creating new Variables and
Attributes

Added a C-API test case ./examples/hello/C/helloFStream.c


To do:

Need to test C-API and new CGroup

Added CCFLAG -Woverloaded-virtual in Makefile. It was on in a MAC
systems (maybe CLANG?), off in Ubuntu.  

Testing sending buffers from all to rank=0

Added files include/public/ADIOS_C.h, src/public/ADIOS_C.cpp (with
std::exception handling), examples/hello/helloADIOS_C.c (not yet tested)

Working on CFStream.cpp testing vector<char> as buffer

Need to define types supported for C++, C, Fortran

Need to defined XML specs


To do:

Test added file examples/hello/helloADIOS_C.c

Test class CFStream implementation assuming MPI