root/trunk/examples/util/config/RegEx.d

/*******************************************************************************

    License:    Boost Software License, v. 1.0
                Academic Free License, v. 3.0
                BSD License

    Authors:    Marcin Kuszczak, www.zapytajmnie.com (author's christian site)
                This software is inspired and partially based on Boost C++
                library named 'program_options' and created by Vladimir Prus.

    Version:    0.9.1
    Date:       30-Apr-2008

    History:    0.9.0 (08-Oct-2007) -   initial public version

    Description:
                This example shows how a user-defined class can be parsed using
                specific mechanism -- not the iostream operations used by default.

                A new class 'magic_number' is defined and the 'validate' method is overloaded
                to validate the values of that class using Boost.Regex.
                To test, run

                regex -m 123-456
                regex -m 123-4567

                The first invocation should output:

                The magic is "456"

                and the second invocation should issue an error message.

 ******************************************************************************/

import std.stdio;

import doost.util.config.ProgramOptions;
import doost.util.config.CommandLineStorage;
import doost.util.config.Converter;
import doost.util.config.Value;

//------------------------------------------------------------------------------

/*******************************************************************************
    Completely non-sensical class just for usage in example.
 ******************************************************************************/
class MagicNumber {
public:
    this(int first, int second) {
        this.first  = first;
        this.second = second;
    }

    int first;
    int second;
}

/*******************************************************************************
    Overload the 'parseValue' function for the user-defined class.
    It makes sure that value is of form XXX-XXX where X are digits and converts
    the second group to an integer. This has no practical meaning, meant only
    to show how regex can be used to validate values.
 ******************************************************************************/
MagicNumber parseValue(TypedValue!(MagicNumber) owner, char[] str) {
    string s = str.dup;
    string pattern=r"\d\d\d-\d\d\d";

    std.regexp.RegExp re = std.regexp.search(s, pattern);
    if (re is null)
        throw new InvalidOptionValueException(s, pattern);
    if (re.match(0) != s)
        throw new InvalidOptionValueException(s, pattern);

    return new MagicNumber(to!(int)(str[0..3]), to!(int)(str[4..$]));
}

/*******************************************************************************
    Program entry point
 ******************************************************************************/
void main(char[][] args) {
    try {
        auto desc= new RegularOptions("Allowed options");
        desc.options()
            ("help", "produce a help screen")
            ("version,v", "print the version number")
            ("magic,m", define!(MagicNumber)(r"\d\d\d-\d\d\d").parser(&parseValue), "magic value (in NNN-NNN format)")
            ;

         auto po =  (new ProgramOptions).next(
                        (new CommandLineStorage(args))
                            .options(desc)
                    );

        po.connect;


        if ("help" in po) {
            writefln("Usage: regex [options]");
            writefln(desc);
            return 0;
        }

        if ("version" in po) {
            writefln("Version 1.");
            return 0;
        }

        if ("magic" in po) {
            writefln("The magic is \"", po["magic"].as!(MagicNumber)().first, "\" and \"", po["magic"].as!(MagicNumber)().second, "\"");
        }

        po.disconnect;
    }
    catch(ProgramOptionsException e) {
        writefln(e);
    }
}