The \r in the print command moves the caret back to the start of the line so it overwrites the previous count. The format pads the current index with the required number of zeroes so the overwrite is always of the same number of total characters.

It’s a pretty simple piece of code but it can make life just that little bit easier.

Is awesome…

However the argument still needs to be passed and if there are multiple options this can be a pain, code like an ArgsReader class help alleviate the stress.

It’s used in the fashion displayed below, where the statics are just a set of public strings used as keys to identify the argument type.

public static void main(String[] args){
    ArgsReader reader = new ArgsReader();
    reader.addFlag("-h",        Statics.HELP, "Prints argument descriptions");
    reader.addFlag("--help",    Statics.HELP);
    reader.addProperty("-i",    Statics.INPUT, "An input value");
    reader.addFlag("-l",        Statics.FLAG, "A flag to change some response");
    reader.loadArgs(args);
    if(reader.hasFlag(Statics.HELP)){
        System.out.println(reader.helpText());
        System.exit(0);
    }
    if(!reader.hasProperty(Statics.INPUT)){
        System.out.println("No input");
        System.exit(1);
    }
    String input = reader.getString(Statics.INPUT);
    if(reader.hasFlag(Statics.FLAG)){
        //do something with input
    }else{
        //do something different with input
    }
}


Running this with the line

java [java class with main] -i "Some input" -l

Will use the input value of "Some Input" with the flag set as true

The full code listing of the ArgsReader class is:

import java.util.ArrayList;
import java.util.Hashtable;

/**
* Class used to read arguments from the command line, for example:<br/>
*       &emsp;ArgsReader reader = new ArgsReader();<br/>
*       &emsp;reader.addFlag("-h", "HELP", "Prints argument descriptions");<br/>
*       &emsp;reader.addFlag("--help", "HELP");<br/>
*       &emsp;reader.addProperty("-i", "INPUT", "Some input file");<br/>
*       &emsp;reader.loadArgs(args);<br/>
*       &emsp;if(reader.hasFlag("HELP")){<br/>
*           &emsp;&emsp;System.out.println(reader.helpText());<br/>
*           &emsp;&emsp;System.exit(0);<br/>
*       &emsp;}<br/>
*       &emsp;if(reader.hasProperty("INPUT")){<br/>
*           &emsp;&emsp;System.out.println(reader.getString("INPUT"));<br/>
*           &emsp;&emsp;System.exit(0);<br/>
*       &emsp;}<br/>
* @author Max Dupenois
*/
public class ArgsReader {

    private class Argument {

        private boolean hasValue;
        private String propertyName;
        private String description;
        private String value;

        public Argument(String propertyName, boolean hasValue) {
            this(propertyName, hasValue, "");
        }

        public Argument(String propertyName, boolean hasValue, String description) {
            this.propertyName = propertyName;
            this.hasValue = hasValue;
            if (!this.hasValue) {
                this.value = "false";
            }
            this.description = description;
        }

        private void setValue(String value) {
            this.value = value;
        }
    }
    private Hashtable<String, Argument> propertyNameToArgument;
    private Hashtable<String, String> keyToPropertyName;

    public ArgsReader() {
        keyToPropertyName = new Hashtable<String, String>();
        propertyNameToArgument = new Hashtable<String, Argument>();
    }

    public void addProperty(String key, String propertyName) {
        this.addProperty(key, propertyName, "");
    }

    public void addProperty(String key, String propertyName, String description) {
        if (keyToPropertyName.containsKey(key)) {
            throw new IllegalArgumentException("Already have property with key: '" + key + "'");
        }
        if (!propertyNameToArgument.containsKey(propertyName)) {
            Argument argument = new Argument(propertyName, true, description);
            propertyNameToArgument.put(propertyName, argument);
        }
        keyToPropertyName.put(key, propertyName);
    }

    public void addFlag(String key, String propertyName) {
        this.addFlag(key, propertyName, "");
    }

    public void addFlag(String key, String flagName, String description) {
        if (keyToPropertyName.containsKey(key)) {
            throw new IllegalArgumentException("Already have property with key: '" + key + "'");
        }
        if (!propertyNameToArgument.containsKey(flagName)) {
            Argument argument = new Argument(flagName, false, description);
            propertyNameToArgument.put(flagName, argument);
        }
        keyToPropertyName.put(key, flagName);
    }

    public void loadArgs(String[] args) throws IllegalArgumentException {
        String key;
        String propertyName;
        String value;
        Argument argument;
        for (int i = 0; i < args.length; i++) {
            key = args[i];
            if (keyToPropertyName.containsKey(key)) {
                propertyName = keyToPropertyName.get(key);
                argument = propertyNameToArgument.get(propertyName);
                if (argument.hasValue) {
                    if (args.length <= i + 1) {
                        throw new IllegalArgumentException("Key '" + key + "' for property '" + propertyName + "' requires a value");
                    }
                    value = args[i + 1];
                    argument.setValue(value);
                    i++; // skip next as it is not an argument
                } else {
                    argument.setValue("true");
                }
            } else {
                throw new IllegalArgumentException("'" + key + "' not a recognised key");
            }
        }
    }

    public String getString(String propertyName) {
        if (!propertyNameToArgument.containsKey(propertyName)) {
            return null;
        }
        return propertyNameToArgument.get(propertyName).value;
    }

    public boolean hasProperty(String popertyName) {
        if (!propertyNameToArgument.containsKey(popertyName)) {
            return false;
        }
        return (propertyNameToArgument.get(popertyName).value != null);
    }

    public boolean hasFlag(String flagName) {
        if (!propertyNameToArgument.containsKey(flagName)) {
            return false;
        }
        return getBoolean(flagName);
    }

    public int getInt(String propertyName) {
        return Integer.parseInt(getString(propertyName));
    }

    public double getDouble(String propertyName) {
        return Double.parseDouble(getString(propertyName));
    }

    public float getFloat(String propertyName) {
        return Float.parseFloat(getString(propertyName));
    }

    public boolean getBoolean(String propertyName) {
        return Boolean.parseBoolean(getString(propertyName));
    }

    private String[] getKeys(String propertyName) {
        ArrayList<String> keys = new ArrayList<String>();
        for (String key : keyToPropertyName.keySet()) {
            if (keyToPropertyName.get(key).equals(propertyName)) {
                keys.add(key);
            }
        }
        return keys.toArray(new String[keys.size()]);
    }

    public String helpText() {
        StringBuffer helpText = new StringBuffer();
        String[] keys;
//        String key;
        boolean firstKey;
        boolean firstProperty = true;
        String description;
        for (String propertyName : propertyNameToArgument.keySet()) {
            if (!firstProperty) {
                helpText.append("\n");
            }
            keys = getKeys(propertyName);
            firstKey = true;
            for (String key : keys) {
                helpText.append((!firstKey ? ", " : "") + key);
                firstKey = false;
            }
            helpText.append("\t\t" + propertyName);
            description = propertyNameToArgument.get(propertyName).description;
            if (description != null && description.length() > 0) {
                helpText.append("\t\t" + description);
            }
            firstProperty = false;
        }
        return helpText.toString();
    }
}


<?php
class Database {
    protected $password, $username, $server, $db_name, $connection, $debug;
    public function __construct($server, $db_name, $username, $password) {
        $this->server = $server;
        $this->db_name = $db_name;
        $this->username = $username;
        $this->password= $password;
        $this->debug = false;
    }
    public function setDebug($debug) {
        $this->debug = $debug;
    }
    public function getServer() {
        return $this->server;
    }
    public function getUsername() {
        return $this->username;
    }
    public function getDBName() {
        return $this->db_name;
    }
    public function getConnection() {
        return $this->connection;
    }
    
    public function connect() {
        $this->connection= mysql_connect($this->server, $this->username,$this->password)
            or die('Could not connect: ' . mysql_error());
        mysql_select_db($this->db_name, $this->connection);
    }
    
    public function close() {
        if($this->connection) mysql_close($this->connection);
    }
    
    
    public function lastId() {
        return mysql_insert_id($this->connection);
    }
    
    public function __destruct() {
        $this->close();
    }
    public function free($result) {
        mysql_free_result($result);
    }
    
    /**
     * Used like sprintf to run mysql queries,
     * if the result is a single row it returns that,
     * otherwise it returns an array
     * %s for strings, %% for a percentage, %d for digits (integer)
     * %f for a float and %i to make no change to argument (ignore)
     * @param String sql query to run
     * @param [] arguments to pass to query
     */
    public static $queryargs;
    public function query($sql) {
        $sql = trim($sql);
        
        Database::$queryargs = func_get_args();
        //Remove the first argument
        array_shift(Database::$queryargs);
        $query = preg_replace_callback("/%./", create_function('$matches', '
            $type = $matches[0];
            switch($type){
            case "%s":
            return mysql_real_escape_string(array_shift(Database::$queryargs));
            break;
            case "%i":
            return array_shift(Database::$queryargs);
            break;
            case "%d":
            return intval(array_shift(Database::$queryargs),10);
            break;
            case "%f":
            return floatval(array_shift(Database::$queryargs));
            break;
            case "%%":
            return "%";
            break;
            default:
            return "";
            }'), $sql);
        Database::$queryargs = null;
        $result = mysql_query($query, $this->connection)
            or die(($this->debug?$query:"Query Failed")."<hr/>".mysql_error());
        
        preg_match("/^\W*(\w*)\W/", $sql, $matches);
        $type = $matches[1];
        
        switch($type) {
            case "SELECT":
            case "SHOW":
            case "DESCRIBE":
            case "EXPLAIN":
                $objects = array();
                while($obj = mysql_fetch_object($result)) {
                    $objects[] = $obj;
                }
                return $objects;
                break;
            default:
                return ($result);
        }
        $this->free($result);
    }

}
?>


^[1] You lucky lucky people.

The site to which this blog is attached uses .htaccess as part of its process and it serves 2 major purposes:

1. I use it to mask the fact that it runs on PhP ¹
2. Passes all requests to a single script which, based on the url, feeds the correct page

Why bother you ask? Well so I can use my own templating system and frankly because I’m a computer scientist and am really bad at not re-inventing the wheel.

So that I have a backup and some explanation of what I’ve done next time I look at it and swear at my incomprehensible code the following is a transcript of the major sections:

ErrorDocument 401 /err/401.html
ErrorDocument 403 /err/403.html
ErrorDocument 404 /err/404.html
ErrorDocument 500 /err/500.html

Basically where to route the user on a given error, not actually used as it should be entirely handled by the site-engine.

Options +FollowSymlinks
RewriteEngine on

Turns on the ability to forward the user to another location

RewriteCond %{http_host} ^www\.(.*) [NC]
RewriteRule ^(.*)$ http://%1/$1 [R=301,NC,L]

Makes www. unaccessible, this is just for some basic consistency across the site. The R=301 makes it an actual http redirect, the NC tells it to ignore case and the L tells it that this is the last command and the rest of the file should be ignored.

<FilesMatch "\.htaccess$">
Order deny,allow
Deny from all
Satisfy all
</FilesMatch>

This stops the .htaccess file itself from being accessible.

RewriteCond %{http_host} !^3void.com$ [NC]
RewriteRule ^(.*)$ $1 [NC,L]

This is to allow subdomains to be used normally without passing through the site-engine.

RewriteCond %{request_uri} ^\/js\/.*$ [NC]
RewriteRule ^(.*)$ $1 [NC,L]

This speeds up the javascript access by not sending it to the script, actually required for tiny mce and possibly other external libraries to work properly.

RewriteCond %{HTTP:RedirectedToGenPage} !^true$ [NC]
RewriteRule ^[PAGE-GENERATOR-SCRIPT].php(.*)$ / [F,NC,L]

Checks to see if we’ve already been sent to the [PAGE-GENERATOR-SCRIPT] and if we have we can stop processing and let it run as normal.

RequestHeader set RedirectedToGenPage "true"

Sets a header on the request saying we’ve now been sent to the [PAGE-GENERATOR-SCRIPT]. This is important because I don’t want the script to be accessible directly so people have to use the site as a normal site and can’t directly got to [PAGE-GENERATOR-SCRIPT].php?uri=[WHEREVER].

RewriteCond %{request_uri} !^.*[PAGE-GENERATOR-SCRIPT]\.php.*$ [NC,OR]
RewriteCond %{request_uri} ^\$ [NC]
RewriteCond %{QUERY_STRING} ^(.*)$ [NC]
RewriteRule ^(.*)$ /[PAGE-GENERATOR-SCRIPT].php?uri=$1&%1 [NC,L]

Performs the actual redirect, this time it’s not a proper http redirect, we just send the current request to [PAGE-GENERATOR-SCRIPT].php.

^[1] Not sure why I do this.

Posted from WordPress for Android