utile | python package which eases your codeflow using decorators | Reactive Programming library

I have a view in a laravel project where I have to print the sum of some array columns.

I Have this kind of code to achieve the result:

Hello, I'm new to C.

I want to "export" and use a typedef struct in other files but it seems that it doesn't works a lot.

I have those kind of errors

Since there is no Wix equivalent to Netfx.wixext for .NET Core (i.e. specifying built in Ids to detect and require runtimes), I can't seem to find a way to correctly install .NET Core and also account for various conditions such as a newer version existing in the same version family (i.e. 3.1).

I've tried to utilize the .NET Core installer executable directly in a burn project, but the problem arises that detection only seems to be able to be achieved with Directory or File searches. This results in failing to detect build version differences correctly since I can't detect "3.1.*".

I tried to build a custom action for the Wix Bundle to programmatically detect and set properties based upon installed .NET Core versions -- But of course I realized that Burn bundles cannot have custom actions.

What other options do I have to install runtimes and detect future version of the same .NET Core Family (Major.Minor)?

Here is the snippet of wix code which is relevant:

I am trying to set up a MongoDB Docker container to use as a local database for testing, but I am facing issues.

For running the container, I used following command:

docker run -d --name mongodb -p 27017:27017 -e MONGO_INITDB_ROOT_USERNAME="root" -e MONGO_INITDB_ROOT_PASSWORD="password" -v C:\projects\docker\volumes\mongotmp:/data/db mongo:4.4.4

I used -e to pass the root username and password environment variables, but I am not able to connect to the database, I tried using this connection string:

mongodb://root:password@localhost:27017/?authSource=admin

When I execute a shell inside the container, and try to get the users with db.getUsers() I get an authentication error.

Edit 2: Updated to take care of the problems from the dput output.

I don't know why the dput output is not working, so here is a roundabout way of sharing the data.

A simple zip file of the data can be downloaded from here: link to zip file

The following code should then represent the data I was trying to share. Note that you will need to replace the path name for the downloaded zip file, and that the parse_file function will create a temporary directory:

I made 3 different packages with classes in them. One package is for simple fractions and another is for arrays of fractions. The smaller one is for implementing math functions mcm and MCD. The arrays of fractions main(fractioncollectionmain) doesn't print anything on screen when I run it. I'll leave ALL the code below. I hope someone can help!

util PACKAGE

MyMath class

I am trying to build a centos server with php on it I am using centos:7 image and in it install php dependencies. But that doesn't seem to work as every time, the build is successful but just after that the container shuts down.

Here is my docker-compose.yml

I'm quite far into the development of a game using SDL, OpenGL and C++ and am looking for ways to optimize the way the game switches between GLSL shaders for lots of different objects of different types. This is much more of a C++ question than an OpenGL question. However, I still want to provide as much context as I can, as I feel some justification is needed as to why the proposed Shader class I need, needs to be created / deleted the way that it is.

The first four sections are my justifications, journey & attempts leading up to this point, however my question can likely be answered by just the final section alone and I've intentionally written it as a bit of a tldr.

I've seen many implementations online of OpenGL shaders being created, compiled and deleted all in the same function when game objects are created during gameplay. This has proven to be inefficient and far too slow in particular sections of my game. Thus, I've required a system that creates and compiles shaders during a load-time and then intermittently uses/swaps between them during game-time before being deleted later.

This has lead to the creation of a class(Shader) that manages OpenGL shaders. Each instance of the class should manage one unique OpenGL shader each and contains some complex behavior around the shader type, where it's loaded in from, where it's used, the uniform variables it takes, etc.

With this said, the most important role of this class is to store the GLuint variable id that is returned from glCreateShader(), and manage all OpenGL calls that relate to the OpenGL shader with this id. I understand that this is effectively futile given the global nature of OpenGL(as anywhere in the program could technically call glDeleteShader() with the matching id and break the class), however for the purposes of intentionally encapsulating all OpenGL calls to very specific areas throughout the entire codebase this system will drastically reduce code-complexity.

The most "automatic" way to manage this GLuint id, would be to invoke glCreateShader() on the object's construction and glDeleteShader() on the object's destruction. This guarantees(within OpenGL limits) that the OpenGL shader will exist for the entire lifetime of the C++ Shader object and eliminates the need to call some void createShader() and deleteShader() functions.

This is all well and good, however problems soon arise when considering what happens if this object is copied. What if a copy of this object is destructed? That means that glDeleteShader() will be called and effectively break all copies of the shader object.

What about simple mistakes like accidentally invoking std::vector::push_back() in a vector of Shaders? Various std::vector methods can invoke the constructor / copy constructor / destructor of their type, which can result in the same problem as above.

Okay then... how about we do create some void createShader() and deleteShader() methods even if it's messy? Unfortunately this just defers the above problem, as once again any calls that modify the OpenGL shader will desynchronize / outright break all copies of a shader class with the same id. I've limited the OpenGL calls to glCreateShader() and glDeleteShader() in this example to keep things simple, however I should note that there are many other OpenGL calls in the class that would make creating various instance/static variables that keep track of instance copies far too complicated to justify doing it this way.

The last point I want to make before jumping into the class design below is that for a project as large as a raw C++, OpenGL and SDL Game, I'd prefer if any potential OpenGL mistakes I make generate compiler errors versus graphical issues that are harder to track down. This can be reflected in the class design below.

It is for the above reasons that I have elected to:

• Make the constructor private.
• Provide a public static create function that returns a pointer to a new Shader object in place of a constructor.
• Make the copy constructor private.
• Make the operator= private (Although this might not be necessary).
• Make the destructor private.
• Put calls to glCreateShader() in the constructor and glDeleteShader() in the destructor, to have OpenGL shaders exist for the lifetime of this object.
• As the create function invokes the new keyword(and returns the pointer to it), the place with the outside call to Shader::create() must then invoke delete manually (more on this in a second).

To my understanding, the first two bullet points utilize a factory pattern and will generate a compiler error should a non-pointer type of the class be attempted to be created. The third, fourth and fifth bullet points then prevent the object from being copied. The seventh bullet point then ensures that the OpenGL Shader will exist for the same lifetime of the C++ Shader object.

The only thing I'm not a huge fan of in the above, is the new/delete calls. They also make the glDeleteShader() calls in the destructor of the object feel inappropriate given the encapsulation that the class is trying to achieve. Given this, I opted to:

• change the create function to return a std::unique_ptr of the Shader type instead of a Shader pointer.

The create function then looked like this:

Consider the following code where the Writer_I acts as an interface. Other classes which fulfil the contract of writing element types in correct form can derive from it. Here, printf and streams are chosen as policies, and Calculator as user.

That interface is somehow stored in Calculator and write_i hides all the ugly details of templates so that class member functions remain clean. Most things remain known at compile time, and inline-able.

I know this is a classic case of virtual + derivation based polymorphism where a non-templated interface can be stored inside Calculator and write member function is called. But having known the type at compile time, and still deferring resolution to run time seems bad. It hints that some run time value will affect the chosen method of writing while that is not the case.

One way could be to make Calculator a template and keep its implementation in a cpp file and include the cpp file in tests. That's just nasty. Every method of Calculator will have a useless template <> on the top. And it's getting instantiated only once. (Twice if you could tests, but then if the only reason to make Calculator a template was tests, I'd say that tests are being too intrusive.)

I saw the talk https://www.youtube.com/watch?v=mU_n_ohIHQk (Meta Polymorphism - Jonathan Boccara - Meeting C++ 2020 Opening Keynote) https://meetingcpp.com/mcpp/slides/2020/meta_polymorphism_pdf3243.pdf

which showed a technique with std::any (which will store the Writer_I instance reference) + lambda (which contains the actual Impl type) + function pointer (which can be called later). Slides 79-83. I tried but got stuck real quick: How to have a function pointer to a generic lambda?

My solution, after all these futile attempts out of curiosity, would be to use iterator pattern and free the Calculator from the responsibility of "writing". Calculator should just be calculating data, not writing it. That solves the problem! Caller gets the data by running iterator++ and writes it any way it likes. Or may not even write it, but just test the numbers directly. Calculator remains a non template, thus in cpp files.

But if there's any way to achieve what I intend with the current design, I'd be happy to see it. I know there are some contradictory constraints, like using type erasure which may internally use virtual but curiosity is allowed on Stack Overflow, right (; ?

https://godbolt.org/z/W74833

EDIT: to clarify, here the user class is Calculator which should not be a template. All writers can remain in headers and need not be hidden. For CRTP, it is actually needed in main to know what each writer implementation does.