Error reading int data, MIN_VALUE value returned.

error when trying to request example; 5.4
works if u enter 5

This post was edited by 5678 on Nov 21 2014 08:27pm

5.4 isn't an int

Don't PM me with this crap.

If you want to input 5.4, then you shouldn't be reading in integers. Read in doubles.

You are reading only integers. 5.4 is a double.

So, I have been trolling people who have done this in the past. Anyone who blatantly begs for code, or shows no interest in learning will get code from me. But it will be insanely ridiculous int he amount of abstraction and complexity it offers for the most mundane of tasks. A few weeks ago, I did someones assignment for reading in a couple unique numbers from keyboard. However, I abstracted it in a way that you could configure how many numbers, the range of numbers, and then abstracted it more to where you could basically swap out any interface with another and get completely new functionality from the code.

So, this guys assignment is pretty much a derivative of that assignment I did before. So, I am going to show you how easily good code can be tweaked and repurposed if you design it well the first time. I had to make a few minor adjustments. Mainly, before I made my NumberReaders based on the primitive int. Well, this was slopy. I should have made them more abstract. Now they work off the abstract Number class, which now I can read ANY type of number I want. Which means, I can modify it to read in doubles like this guy wants. What follows will be an expaination of the code

SO we start off with the base INumberReader interface. This exposes one method to readNumbers. This allows for any application that wishes to be a NumberReader to specify how it will read these numbers, without any of its comsumers carryign about the implementation details. The idea is simple: someone wants you to read numbers, they don't care how. Just read them.



Next we will use a Factory pattern to generate the NumberReaders. This lets a consuming application create a new NumberReader without carrying about how. It isn't a NumberReader expert. It doesn't need to know how to make one, so we will supply it an interface that will expose a createNumberReader method so that they can get a NumberReader whenever they want without needing to know implementation details.




Now, there are some things a NumberReader needs. But all NumberReaders are not the same. So let's make those things configurable so that we can be more dynamic with how our NumberReader will work. The things a NumberReader needs in order to do its job is the range of numbers it can input, the amount of numbers it can input, and then of course HOW it is going to input. This means we can control whether they are inputed from the console, a file, or any datasource really. We can just give it a stream to the input or output source.





Next we have the implementation of the NumberReaderConfig. This one is for a DoubleReader, but not just a DoubleReader, these is for a StaticDoubleReader. All of these values are static and not changed. If we ever want to change them, we just need to update the constants in the constants class.

To be continued.

Now we are getting into the implementation of a NumberReader. We will start with an abstract base. Each NumberReader will be different, but there are some stuff each NumberReader must do. We will encapsulate that in the base, and expose abstract methods to be implemented by whichever concrete class we create later to give it unique functionality. The things every NumberReader will do is expose some input and output methods to its children and read its config file, which is supplied via dependency injection through the constructor. Notice that this abstract class doesn't deal with any specific Number. It is a base for ANY type of NumberReader.



Next we have our implementation for a DoubleReader. But there can be many types of DoubleReaders, so again this is just an abstract class to establish the base for which all DoubleReaders will use. This one establishes what is a valid Number, and how to read a Number. Note that now we are dealing with Doubles instead of Numbers. The base does not implement readNumbers, as that is a more specific operation that other concrete DoubleReaders will implement.



Here we have our concrete ComparableDoubleReader. This implementation implements the abstract readNumbers method. It provides the implementation for this specific kind of DoubleReader.



And of course, our consumers will want to be able to create these types of DoubleReaders, but won't necesarily know of care how they are made. So let's give an implementation of the INumberReaderFactory we created earlier so that we can create some ComparableDoubleReaders

More to follow....

Now it is time to set up our application to read some numbers



We start with an abstract NumberReaderApplicationBase. This will accept a factory and a config file from its contructor. It's one method, execute, simply creates a NumberReader with the NumberReaderFactory using the NumberReaderConfig, and then calls readNumbers. Note how everything is using interfaces, and is completely abstract and generic. ANY NumberReaderApplication can use this base.



Now we have a concreate implementation of a NumberReaderApplication. This simply supplies the implementations of the factory and config. Now, in a perfect world, you would use some dependency injection framework to handle this at runtime, but for the sake of simplicity we are just going to manually inject them like this. Notice this is the FIRST time we have every specifically used an actual implementation of any of these interfaces. The entire NumberReader Framework above this point was strictly interfaces.




And last but not least, a simple driver which constructs a new application and executes it.


And before you ask me, OP, the above solution does EXACTLY what you want it to do.

1) inputer and printer are both streams inside INumberReaderConfig, so it's harder to build a GUI or web app or web service to leverage the core code
2) configuration options should really come from a config file. what happens when OP deploys this to his linux box and decides he wants to change the number range? he'd have to recompile the code instead of altering a config file
3) i don't see any logging anywhere. what happens when we notice a lot of CPU usage on the box and narrow it down to this program, and notice someone added a concrete DoubleReader implementation which is flawed and loops infinitely? if we have log files, we can set up alerts to notify us of the errors, or at least help trouble shoot the issue without having to get out a debugger.
4) you're not providing any feedback to the user or log if the user doesnt enter a double. you just keep on trucking. our customers will keep calling in tier 1 support asking why it doesnt work when they type in "pi" or "e" or "two" or "(1+2)". and since there's no documentation, they're gonna bring in tier 2 support, and guess what? they know the developer's phone number.
5) elbows too pointy
6) no multi-language support. your strings should all come from an NLS file so developers dont have to recode it just to support spanish, french, korean, etc.


2/10 would not bang.

This post was edited by carteblanche on Nov 21 2014 10:47pm

You are absolutely right. This was the initial commit. Those features have already been prioritized and added to the backlog. The development team will start working on a maintenance release next sprint.

This post was edited by Minkomonster on Nov 21 2014 10:24pm