Web++: A C++ Web Framework
132 subscribers
440 photos
36 videos
20 files
177 links
Web++ Framework (A C++ web framework to ease the pain of web development)

Using modern C++20/23.
GitHub: https://github.com/the-moisrex/webpp

I've been working on this project since 2019...
Download Telegram
Which one is the best alternative to static_assert(false, "oops")?

With these, you can make the static_assert(false), type-dependent; thus instead of evaluating it at point of compiling the function, it gets evaluated when the function's type is known which means if constexpr statements work in that time.

And also there's a std::dependent_false proposal which in this code is an alternative for always_fasle.

Click here to see the code
Replace a template parameter of a templated type from A to B.

With this you are able to change a template parameter of a type from the old type to the new type that you specify.

This is particularity good for when you have want to change the allocator type from current allocator to the new allocator you want without knowing the templated type.

The source code

I'm going to use this to identify, and change your allocator type after finding the best allocator that matches your needs; but this thing is good for other template meta programmings as well.

Of course this has some limitations as well. For example if your templated type includes "auto" or "decltype(auto)" or any non-type template parameters, you will have a problem. This code only works on templated types that their types are types themselves and won't work on types that include template template (template <template...> typename) template parameters.
Meet tuple_filter; it helps you filter the types inside a std::tuple or any tuple-like type based on a C++20 concepts (or older versions if you'd like).

Unfortunately we're not able to directly pass a C++20 concept as a template so the user of this type has to pass a template<typename> typename template struct containing static constexpr bool value.

See the source code on the Compiler Explorer

I've also implemented this in another way long ago while implementing the"extension system" of this project.
Here's the source code of that implementation on GitHub.
Github removing bans for Iranian residence.

Good, now can we remove the git and browser's proxy configurations for github!
Honestly I didn't expected github to do this; now I know other companies CAN do this but they just DON'T WANT TO.

Nat Friedman Tweet about this
My Reply to that tweet
Github blog post about this
I introduce you "recursively_replace_template_parameter" type which does exactly what the name says (suggest a better name if you know any).

It recursively replaces template parameters from the specified template type to the new specified template type.

This is particularly good for example when you want to replace std::allocator with std::pmr::polymorphic_allocator in a series of types.

For example, you can replace vector<string> with pmr::vector<pmr::string> with it.

On Godbolt
GitHub Link
Web++: A C++ Web Framework
I introduce you "recursively_replace_template_parameter" type which does exactly what the name says (suggest a better name if you know any). It recursively replaces template parameters from the specified template type to the new specified template type. …
And the code for those 4 TMP utilities are this. 😁

I should/could also add the non-type template parameter replacer as well, but the I don't need it; at least not yet.

You can find the source at the core/std/type_traits.hpp file in Web++ project.

Template meta programming could be better if the language maker do something about it. You can do really interesting stuff with it.

The purpose of this utility that I made was to make sure my allocator_pack can correctly and recursively replace all the allocators in the specified type with the new allocator type that we find is the best choice there.

This way, the fastest allocator in the allocator pack (or I should call it resource pack maybe) is chosen without the user (or the library) explicitly telling it what allocator it should use.
These two parts could've been much easier to write if C++ would let us to use template-specialization inside non-namespace scopes as well.
YouTube is finding one of my videos violating copyright;
It's me during live coding, the sound of my keyboard typing.

I guess I typed a music πŸ˜‚

https://youtu.be/W9qYYFHcm2k?t=2267
Oops, I broke GCC again!
Web++: A C++ Web Framework
Oops, I broke GCC again!
This git commit message should be a meme! Right? 😁
How much planning is too much planning? I do plan things a lot, sometimes too much! And that wastes so much time.
Specially when you're working on a big project that takes a long time to complete, you find out that you are wasting way too much time on rewriting the bad decisions of your past. And I think that is why I overthink some decisions now.
Doing small projects makes you think short term, but doing big projects makes you think way too much in the future than necessary.
I think we have to balance it by doing one big main project and many little smaller projects at the same time.
You have to be careful though. The joy of finishing smaller projects may overcome the joy of the big project's journey; and that's dangerous for your big project's health πŸ˜‰
I just found out that I've had two different types of "HTTP request" types and I've been maintaining both of them.
They have totally difference ideas behind them.
And also I have a "context" type as well which is essentially an "extendable request" type.

I even confused myself!

I'm having a hard time merging them. One of them wasn't even being used in the process while other parts of the library assumed it was that type.

And it worked. Why? because in the first type I required "req.headers" to be present which is a "vector of header fields" while the other type had "req.headers()" function.

The tests were passing because I didn't have a "concept" for "Headers".
3 type traits in web++ I had to add:
1. prepend_parameter: add a template parameter to the beginning of a tuple-like list.
2. append_parameter: append to the end.
3. unique_parameters: remove the duplicate types in a tuple-like templated type.

The code on the Compiler Explorer.