A decompression and compression library.
Bear in mind that all code samples and the Decomp Library itself are all compiled using
-std=c++20Also to use this simply do:
#include<https://raw.githubusercontent.com/robertshepherdcpp/Decomp/main/main.cpp> int main() { // ... }The incryption and decryption are in the stack manipulation namespace:
namespace stack_manipulatioin { [[nodiscard]] auto decryption(); [[nodiscard]] auto encryption(); }The interface:
The decryption and encryption functions(the main part of this library) accept a node to decrypt. for instance:
namespace { // returns an decrypted node. node<T> decrypt(node<T>& node_); // decrypt the node. returns and encrypted node. node<T> incrypt(node<T>& node_) // encrypt the node. }it is recommended to pass in a program_stack whose variable defininition looks like this:
program_stack<T> p; // should initialize. In core guidlines.you can then use a spacialised function for a program stack like this:
template<typename T> [[nodiscard]] auto go_through_stack_encrypt(program_stack<T>& stack_p)or
template<typename T> [[nodiscard]] auto go_through_stack_decrypt(program_stack<T>& stack_p)this then performs all of the work for you. E.g. going through the stack looping over passing a node of the stack to the encrypt or decrypt function.
there is a function decompression that looks like this:
template<typename T> [[nodiscard]] auto incryption(node<T>& v_t) -> node<T> { auto x = v_t.data_associated_with_node; v_t.data_associated_with_node = static_cast<int>(x); //v_t = v_t.next; // v_t.current_node = start_node; }and a compression function that looks like this:
template<typename T> [[nodiscard]] auto decryption(node<T>& v_t) -> node<T> { auto x = static_cast<T>(v_t.data_associated_with_node); v_t.data_associated_with_node = x; // v_t = v_t.current_node.next; }There is also a container namespace for all the containers:
namespace containers { template<int T, int... Ts> struct binary { int bit; binary<Ts...> bits; auto output_bits() // just ouputs binary { std::cout << bit; std::cout << "\nOutputed bit: " << bit; bits.output_bits(); } }; template<int T> struct binary<T> { int bit; auto output_bits() { std::cout << bit; std::cout << "\nOutputed bit: " << bit; } }; auto make_binary(auto x) -> int { return static_cast<int>(x); } struct Hash { Hash(auto i) { auto x = make_binary(i); } }; } // end of namespace containers.There is also a formatting element to the Decomp library that looks like this:
formt::format f("Hello my name is {}", 'R'); onl(); formt::format xyz("Good Afternoon {}", "C++"); onl(); formt::format abc("Good Afternoon {}", 42);or you can just use:
formt::func(/*pass in parameters like would do for object coration*/);both work the same but just one creates an object and the other one doesnt. But in the objects creation it actually defers the variadic template parameters to the formt::func function. So it doesnt matter what you do. You could allocate it like this:
formt::format* xyz("std::cout << {} << std::endl;", "Hello C++");and then deallocate the object:
delete xyz;but this is not advised and a smart pointer like a std::unique pointer should be prefered instead of handling raw pointers. for example:
std::unique_ptr<formt::format>(/*Normal Parameters or constructor aguements*/);There is also a binary and bits namespace called:
namespace binary_and_bits {/*Implementation...*/}and it has several containers like:
template<typename T> struct binary{auto Print();} // specialisations of binary, e.g., for one and two. auto make_binary(auto T); struct one{}; struct two{};