stringb | string handling with less dependencies | Script Programming library

"I would like to return this as an array of 3 numbers: 0.1875, 7.00, 8.800"

The three numbers are equal to and represented as 0.1875, 7 and 8.8.

Split the string and parse the numbers:

Using re.findall here is your friend:

Try this:

The problem you're asking about appears to be that the client tries to receive a response from the server after each send(). That will block until it can read at least one byte or the server closes the connection. Meanwhile, the server expects the client to send messages one right after another, without any responses to the odd-numbered messages.

That is symptomatic of a design problem. This ...

I am trying to send a message to the server, and if the server does not receive another message from client within 5 seconds, then send a warning to client, otherwise combine two messages and send back to client.

... may sound simple and seem to make sense, but in fact it is neither very simple nor very sensible. Suppose you have a well-intentioned client of of your service. It knows that the service expects two messages, one after the other, to which it will respond with a concatenation of the two. Why would such a client fail to send the expected second messages? The most likely explanations are

• it can't, because it is suspended, because a network link went down, because its host machine went down, or similar.
• it didn't, because it was killed before it could.
• it didn't, because it is buggy.

None of those is rescued by the server sending a warning message. (But if the client is killed before delivering the second message, then the server will probably see EOF on the socket and signal read-readiness.)

Moreover, suppose the client is suspended, the server sends a warning, and then the client resumes. When it tries to read the expected response from the server then it gets the warning message instead, or quite possibly the warning concatenated with the expected response. How is the client supposed to distinguish warning messages from normal responses?

I would suggest dropping the warnings altogether. The server can instead just disconnect non-responsive clients.

If you want to retain the warnings and continue to use just one socket then you need to augment your protocol to make the warning messages distinguishable and separable from normal responses. For example, the server's responses might be in two parts -- a response code identifying the message type, followed by a response body.

Alternatively, you might use separate sockets for the two distinct message streams, but I think that would be more complicated than you want to handle right now.

There are other issues with your code, though. The main ones are

• You seem to assume that send/write and recv/read calls will pair up so that the data sent from one side by one call is exactly what is received by one call on the other side. That is not at all a safe assumption. You are using a stream-oriented socket, and one of the characteristics of such a socket is that the data stream does not have any built-in message boundaries. If you want to divide the data into logically separate messages, then you need to layer that on top of the stream.

• You do not account for the fact that send/write and recv/read may (successfully) transfer fewer bytes than you request. Generally speaking, you need to pay attention to the return value of these functions and be prepared to use multiple calls to transfer all the bytes of a given transmission.

You can do something like this.

I think reasonable solution for smaller queries is to build UPDATE query and list of bound parameters dynamically while processing payload with logic that recognizes what was updated and what was left empty.

From my own experience this is clear and readable (if repetitive you can always iterate over struct members that share same logic or employ reflection and look at struct tags hints, etc.). Every (my) attempt to write universal solution for this ended up as very convoluted overkill supporting all sorts of corner-cases and behavioral differences between endpoints.

Foo and Bar are values. typeof operator can be used to get their type:

If you declare a variable 'a' as being of type 'A', you will not be able to access the properties of classes inheriting from A (like B). Let's say A is Animal and B is Baboon. Baboon inherits properties from Animal, so all variables instantiated with the Baboon type with have access to properties from both classes. But variables instantiated with the Animal type will only have access to the Animal properties. Here are some examples: https://medium.com/jay-tillu/inheritance-in-dart-bd0895883265

var_export() of supply detail will look like the following