/*
* Safe input example:
* If your compiler is not up to date for C++ 11, some of this stuff might not work for you.
* If that's the case, try just the topmost example - this should work.
*/

#include <iostream>

template <class StreamIn> void SafeInput(StreamIn & Object,
    std:: istream & InputStream = std:: cin) {
    for ( ;; ) {
        if (InputStream >> Object) return;
        else {
            InputStream.clear();
            InputStream.ignore(std:: numeric_limits<std:: streamsize>:: max(), '\n');

            std:: cerr << "Invalid input: try again.\n";
        }
    }
}

/*
* As complicated as it looks, it isn't that bad to use.
* You simply call the function as you would any other, but you specify the type of the first
* parameter in angle brackets - look, here's an example:
*/

int main(int, char **) {
    int A = 0;
    std:: cout << "The current value of 'A' is: " << A;
    std:: cout << "\nInput the new value of 'A': ";

    SafeInput<int> (A);

    std:: cout << "The new value of 'A' is " << A;

    return 0L;
}

/*
* Likewise, if 'A' was a 'char' instead, you would call 'SafeInput<char>(A);',
* and the same for any type that you can get input for with std:: cin.
*/

/*
* That's not too bad-  copy all the above and compile to try it out yourself.
* You should not be able to crash your program with input, and it should rather reset and prompt
* the user again.
*
* What happens is this:
* 1: Prompt the user for input.
* 2: If the fail bit of std:: cin was not set, (called InputStream in this function),
*    break and return.
* 3: Else, reset the stream of all errors, and ignore.
* 4: Print an error message, and repeat.
*
* But we can make it better.
* This works great for some basic stuff, but what if you have some sort of restriction
* on your input, as is commonly the case?
* We can use a neat function of the new C++11 standard, called lambdas to supply a predicate
* to test whether the input is okay, inline.
* See:

  http://en.cppreference.com/w/cpp/language/lambda

*
* Note: Syntax might get ugly here, don't worry. Even when we're done, it's still shorter
* than the alternative, which is typing out the entire function SafeInput inline with the
* predicate enclosed.
*/

/*
* We need to add another include this time - this will offer us a bit more flexibility in how we
* use this feature.
*/

#include <functional>
#include <iostream>

template <class StreamIn> void SafeInput(StreamIn & Object, std:: function<bool(const StreamIn &)>
    Predicate = nullptr, std:: istream & InputStream = std:: cin) {
    for ( ;; ) {
        if (InputStream >> Object) {
            if (Predicate == nullptr) {
                return;
            } else if(Predicate(Object) ) {
                return;
        } else {
            InputStream.clear();
            InputStream.ignore(std:: numeric_limits<std:: streamsize>:: max(), '\n');

            std:: cerr << "Invalid input: try again.\n";
        }
    }
}

int main(int, char **) {
    int A = 0;
    std:: cout << "The current value of 'A' is: " << A;
    std:: cout << "\nInput the new value of 'A': ";

    SafeInput<int> (A, [](const int A){
        return (A <= 100 && A >= 0)? true: false;
                                      } );

    std:: cout << "The new value of 'A' is " << A;

    return 0L;
}

/*
* In this case, we demonstrate the power of such a construct by letting us constrain input to the
* values in the interval [0, 100].
* You can alter the predicate function to evaluate anything, as long as the value returned
* is boolean. If you need to read external state, you can do that. mention the name in the lambda
* and capture by value:
* int y = 25;
* SafeInput <int> (a, [=](const int a) {
*   return A <= y? true: false;
*                                      } );
*/

/*
* Don't be intimidated by the syntax, especially if you've never seen these features before.
* The function accomplishes something rather trivial: get input and make sure that it meets some
* restriction.
* It works like this:
*
* 1: Get the type of the data we want to input:
*   SafeInput<int>
* 2: Get the datum that we actually want to change
*   SafeInput<int>(Value,
* 3: Get a pointer to a function, functor or a "lambda function", since std:: function lets us
*   use any, that returns a boolean and takes the type of the data we want to change as an argument.
*   SafeInput<int>(Value, [](const int SomeName){ return true } );
* 4: And close the function. The predicate (in this case always true) will be evaluated on each
*   input, if it's provided. Since this one is constantly true, we could have just left it out.
*   SafeInput<int>(Value);
* 5: Test if input is okay - the stream is okay. Assuming it is, if and only if the predicate
*   was supplied, evaluate that predicate and filer input based on that. If the predicate returns
*   false,  than prompt the user again.
* 6: If the stream isn't okay, prompt the user again.
*/

/*
* You should be able to copy- paste this entire file into your compiler in two parts.
* As ugly as this is, it's frankly more concise, readable, and safer than trying to validate
* input inline. If you can't compile the second one, than trust me, it's your compiler!
* Tested on GNU GCC 4.8.1, and the test version of the "Microsoft Visual C++ Compiler Nov 2012 CTP"
* Feel free to use this subject to the terms of the Do What The Fuck You Want to Public License.

    http://www.wtfpl.net/

* Cheers.
*/