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

Decongest CGroup for Variable creation and value setting

Partial testing and debug of XML read implementation to allow "< >" in
names. Required to allow STL containers as types (e.g.
"vector<double>").

Back to std::shared_ptr in CGroup members. std::make_pair calls the copy
constructor by default. Will keep track of std::shared_ptr counts.

Added more checks for debug version to guarantee exceptions.

To do: 
Add and test more types.
Add Capsule class and support.

Changes in CVariable and CVariableTemplate:
Replace CVariable with CVariableBase
Replace CVariableTemplate<> (it's obvious) with CVariable<>

Added file functions/GroupFunctions.cpp for helper functions to
decongest CGroup, especially those related to variable and transport
selections from lookup table structs (see SSupport.h).

Added exception to "using" in doc/CodingGuidelines

Switched all shared_ptr in CGroup members to the more restrictive
unique_ptr

To-do:
Modify CGroup and SetMembers in ADIOSFunctions so groupName is
identified before CGroup. This will allow an emplace on m_Groups map for
unique_ptr.

Added: m_HostLanguage as const reference (need to use move constructor,
not copy when inserting to map).

Modified: m_Attributes is now a map

Testing VariableTemplate Get and Set

Worked with int* and std::vector<int> (not need to pass a size with
vector)

To do:
Add variable Support for CGroup::SetVariable function
Add SSupport Datatypes as a function of host language.
Test "vector<int>" < > in XML Config file

Must use polymorphism of the CVariable class with Get and Set? 
Union should be avoided as it doesn't preserve actual memory size of
variable type (always returns the largest).

Resolve Conflixt
	doc/Doxyfile

Added ./examples/hello/helloFStream.cpp and Modified Makefile to test
Hello in ADIOS Write function

Added more context in ./doc/CodingGuildelines and README files

Changed definition of Variable and VariableTemplate to always allow a
void* type. Might be a better way?


To do:
Test void* to int* or double* conversion
Test check for "<>" in XML Config file

Changed ./public/mpidummy.c to ./public/mpidummy.cpp

Corrected a bug in ADIOSFunctions.cpp InitXML function, string
xmlFileContent was created twice

Need to test the XML parser: ADIOSFunctions.cpp GetSubtring function to
support > in tag attributes, e.g. name="<myname>" >

transform classes (e.g. NetCDF4, PHDF5, BZIP2, etc.)
Added debug mode member variable in ADIOS, CGroup classes for additional
checking, expect slower code.

Changed Doxyfile to print inclusion diagrams
Reorganized code to allow mpidummy.h inclusion replacing mpi.h for
single source object.

1) Eliminated MPI and NonMPI separate functions and Transports

2) All Transport classes extend CTransport

3) Using mpidummy.h header for non-mpi compilation. Will need to include
it in the adios namespace (currently C)


To do:
Makefile
Hello all Transports
BP File

Added Transform Classes headers, need to implement


Need to modify Makefile to account for transform directories under
/include and /src

Changed Monitor function in ADIOS and Group so it can take an ostream
Edited Makefile to allow nompi and full libraries 
Edited ./doc/Doxyfile to include more graphs