hpicgs / yats Goto Github PK

There should be an include task.h that imports names into the global namespace that are used in Tasks such as Input Output and OutputBundle. The alias name should be shorter like in out bundle.

Add tests to Taskcontainer that test if the data is correctly transferred between nodes.

This should behave like a type trait and should take a tuple of input or output objects and should return true if the ID is different in all objects.

Rename all names in all files to snake_case. This also includes file names but excludes template parameter names.

We have multiple situations where we check if something is valid and then fail the compilation. This can not be tested with googletest because these tests are not compilable.
We need some kind of CMake function that adds targets and tries to compile them. This target should fail if these files can be compiled.

Rename library and implementation from fiblib to yatslib and also the tests.

On travis we build only release not release and debug like on Appveyor. Fix this by editing the travis.yml

std::enable_if uses default void so remove all occurrences of void as a type parameter.

The library should only be present on windows and should configure an include directory to yats/include.

This function should take a tuple and a class as a template parameter and should work like http://en.cppreference.com/w/cpp/utility/make_from_tuple

AppVeyor does not run on push unlike travis that does it.

CPPCheck might be usefull finding problems, it might be a good idea to do this with travis.

The type_trait has_run should work like http://en.cppreference.com/w/cpp/types/is_class and should test if the given argument has a function with the name "run" that can have an arbitrary amount of parameters.

This requires SFINAE and is not easy to implement

The add function inside the Pipeline should check with the type trait has_run if the Task has a run function and fail with a static_assert if possible.

The lambda task can be added using the add function of the Pipeline. It should create a dummy task that works like every other node.

gcc and clang still use C++98. The cmake project should be configured to always use C++14.

Static code analysis might be helpful to find bugs in the future.

Make sure that every Abstract type that exists uses has a virtual destructor and is not copyable or moveable when its children are not copyable or moveable.

We need the type traits is_shared_pointer that works like http://en.cppreference.com/w/cpp/types/is_class but is true when the type is a unique_ptr with arbitrary owned object

We need the type traits is_unique_pointer that works like http://en.cppreference.com/w/cpp/types/is_class but is true when the type is a unique_ptr with arbitrary owned object

Update GoogleTest and set up the new version as subrepository. Use a stable tag for this purpose and test if this works with Visual Studio 2015.5.

The pipeline and the add function contains a name parameter and stores the data in a map. Remove the name completely and store the data in a vector. Also adapt the build function in AbstarctTastConfigurator.

Make helper should be better sorted and documented. Also check if every type is actually used.

This for each should take a variable number of arguments and apply a type trait to all of them. I don't know the interface for this.

Implement Input template class that takes a type T and a c string. This class should construct implicit from T and should have a converting operator to T. The string should be parsed at compile time.

Also change every Node to Task.

I find the names InputConnector and OutputConnector more suiting for the current names InputProxy and OutputProxy. May I rename them?

Split each .h that works with templates into a .h and .inl. The .inl should be included at the end of the .h and should not include anything themselves. Only the .h should have a #pragma once.

Appveyor should build pull requests.

The run function should be allowed to return a single Output object without a OutputBundle.

We need an Implementation of std::oberver_ptr http://en.cppreference.com/w/cpp/experimental/observer_ptr that does not rely on C++17. Implement one yourself or search one on the Internet but also think about the license.

Remove functional.h and replace its usage with a reinterpret_cast to void*. This is not unsafe at the position Functional is currently used but it removes an additional allocation.

Move every private implementation in every class to protected.

Add a way to check at compile time if a connection is possible and fail compilation if they are not.

We need a function which hashes a std::string / c string at compile time and returns a size_t. Additionally we should provide a user_literal with the same functionality.

We should discuss how we want to deal with the long waiting times for OSX builds on Travis.

Options:

• leave it as is and wait for jobs to be scheduled
• limit OSX to build only release or debug
• remove OSX from CI (probably worst of the ideas)

Derive from a helper class instead of typing using = Helper..... I am not 100% sure but this might remove the need of always writing Helper:: before every type or constant.

There are includes in this project that check the compiler version and define optional keywords introduced in C++11 and C++14. For example there is a line:
#define final
that activates when the compiler does not know this keyword. There is a checked in include and also some cmake code that tries to generate one.

namespace name should be yats

The Abstract connectors should check if they have a common type at run time and throw if not.

I find the function names input and output misleading. input does not "input" somthing and output does not output something. I suggest to rename the functions to getInput and getOutput.

Our CI services should run unit tests and check for their result. There is already a test target, that runs every unit test and that can be used.

Add basic description in Readme.md and also add Table of ci services.

Find out why this isn't happening. We need this to enforce all-builds-need-to-pass for PRs.

The build function from AbstarctTaskCOnfigurator contains the complete graph structure that has to be transported to the Scheduler to reuse these information.

Both classes must be typed with the parameter type and have a common base class AbstractConnector. This issue has priority.

The type_trait has_options should work like http://en.cppreference.com/w/cpp/types/is_class and should test if the given argument has a function with the name "options" that takes no parameters and returns some kind of option object. The type of the option object should also be an parameter to has_options.

This requires SFINAE and is not easy to implement.

Convert the CMake target yatslib to a header only target as shown in the lecture.

We need an Implementation of std::optional that does not rely on C++17. Implement one yourself or search one on the Internet but also think about the license.