if [ -z "${__stopwatch_sh_loaded}" ]
then
  __stopwatch_sh_loaded=yes

  __stopwatch_sh_VERSION="Stopwatch v0.1"
  __stopwatch_sh_DESCRIPTION="Stopwatch implementation supporting multiple tagged timers"
  __stopwatch_sh_COPYRIGHT=$( cat <<"END_OF_COPYRIGHT"

Copyright (c) 2000-2012, CyberLeo
All rights reserved.

Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:

    * Redistributions of the source code must retain the above copyright
      notice, this list of conditions, and the following disclaimer.
    * Redistributions in binary form must reproduce the above copyright
      notice, this list of conditions, and the following disclaimer in the
      documentation and/or other materials provided with the distribution.
    * Neither the name of the organization nor the names of its contributors
      may be used to endorse or promote products derived from this software
      without specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
HOWEVER CAUSED AND ON ANY THEORY OF LIABILTY, WHETHER IN CONTRACT, STRICT
LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

END_OF_COPYRIGHT
)

  [ "${kvs}" ] || {
    kvs="$(mktemp -t ".stopwatch.XXXXXXXX")"
    trap "rm -f '${kvs}'; exit" exit hup int term kill
  }
  want kvs

  stopwatch_help() {
    cat <<EOF >&2
${__stopwatch_sh_VERSION}
${__stopwatch_sh_DESCRIPTION}

${__stopwatch_sh_COPYRIGHT}

Usage: stopwatch <tag> <start|lap|stop|reset>

Simple bourne shell based stopwatch
Requires 'kvs' and the id 'stopwatch' therein
so make sure you set 'kvs' before sourcing this script if necessary.

After loading, the following commands are available:

Start a stopwatch
  stopwatch <tag> start

'Lap' a stopwatch (emit timer value without stopping)
  stopwatch <tag> lap

Stop a stopwatch; can be resumed later with 'start'
  stopwatch <tag> stop

Reset a stopwatch back to zero
  stopwatch <tag> reset

Internal functions available:

stopwatch_humany_duration <usec>
  Transform an integer number of microseconds into a human-readable string
  (Ex: 3d14h10m3.223s or 7m10.013s )

stopwatch_set_message_callback <command>
  Register a callback to format event messages emitted when a stopwatch is
  commanded. The callback will receive the following parameters:
    <command> - one of: starting, started, lap, get, stopping, stopped, reset
    <tag>     - stopwatch name
    <time>    - the current time on the stopwatch, if any
    <delta>   - the time since the last change or inquiry (for lap and stopping)
  The commands are as follows:
    starting  - called start while stopped
    started   - called start while running
    lap       - called lap while running
    get       - called lap while stopped
    stopping  - called stop while running
    stopped   - called stop while stopped
    reset     - called reset

EOF
    kill -ABRT $$
  }

  case "$(uname -s)" in
  Linux)
    _stopwatch_usec() {
      echo $(( $(date +%s%N) / 1000 ))
    }
    ;;
  FreeBSD)
    _stopwatch_usec() {
      "${_root}/lib/sh/usec" || echo $(( $(date +%s) * 1000000 ))
    }
    ;;
  *)
    echo "Unsupported platform: $(uname -s)" >&2
    exit 1
    ;;
  esac

  # Format stopwatch event messages (Can be overridden; see
  # 'stopwatch_set_message_callback')
  _stopwatch_message_callback() {
    command="${1}"
    tag="${2}"
    time="${3:+$(stopwatch_humany_duration ${3})}"
    delta="${4:+$(stopwatch_humany_duration ${4})}"
    printf "Stopwatch: "
    case "${command}" in
    starting)  printf "'%s' starts%s.\n" "${tag}" "${time:+ at ${time}}";;
    started)   printf "'%s' is already running.\n" "${tag}" ;;
    lap)       printf "'%s' is running: %s%s\n" "${tag}" "${time}" "${delta:+ (${delta} since last lap)}" ;;
    get)       printf "'%s' is stopped: %s\n" "${tag}" "${time}" ;;
    stopping)  printf "'%s' stops at %s%s.\n" "${tag}" "${time}" "${delta:+ (${delta} since last start)}" ;;
    stopped)   printf "'%s' is stopped%s.\n" "${tag}" "${time:+ at ${time}}" ;;
    reset)     printf "'%s' is reset to zero.\n" "${tag}" ;;
    *)         printf "No message for command %s\n" "${command}" ;;
    esac
  }

  # Set the message callback
  stopwatch_set_message_callback() {
    _stopwatch_registered_message_callback="${1:-_stopwatch_message_callback}"
    kvs_set stopwatch message_callback "${_stopwatch_registered_message_callback}"
  }

  # Fetch the message callback; default if unset
  stopwatch_get_message_callback() {
    [ "${_stopwatch_registered_message_callback}" ] ||
      _stopwatch_registered_message_callback="$(kvs_get stopwatch messsage_callback)"
    if [ "${_stopwatch_registered_message_callback}" ]
    then
      echo "${_stopwatch_registered_message_callback}"
    else
      _stopwatch_registered_message_callback=_stopwatch_message_callback
      echo _stopwatch_message_callback
    fi
  }

  # Try and format a passed integer number of seconds into something more
  # easily parseable by a human (like 6m10s or something)
  stopwatch_humany_duration() {
    local usec secs mins hurs days
    [ "${1}" -a "$(echo "${1}" | tr -Cd '0-9')" = "${1}" ] || return 255
    usec=$(( ${1} % 1000000 ))
    secs=$(( ${1} / 1000000 ))
    mins=0
    hurs=0
    [ "${secs}" -lt 60 ] || {
      mins=$(( ${secs} / 60 ))
      secs=$(( ${secs} % 60 ))
    }
    [ "${mins}" -lt 60 ] || {
      hurs=$(( ${mins} / 60 ))
      mins=$(( ${mins} % 60 ))
    }
    [ "${mins}" -gt 0 ] || mins=""
    [ "${hurs}" -lt 24 ] || {
      days=$(( ${hurs} / 24 ))
      hurs=$(( ${hurs} % 24 ))
    }
    [ "${hurs}" -gt 0 ] || hurs=""

    printf "%s%s%s%s.%03ds" "${days:+${days}d}" "${hurs:+${hurs}h}" "${mins:+${mins}m}" "${secs}" "$(( ${usec} / 1000 ))"
  }

  # Start a named stopwatch, but do nothing if the named stopwatch is already
  # running.
  stopwatch_start() {
    name="${1:-stopwatch}"
    [ "${nao}" ] || nao="$(_stopwatch_usec)"
    # Is the stopwatch running?
    if kvs_has_key stopwatch "${name}"
    then
      eval "$(stopwatch_get_message_callback) started ${name}"
    else
      # start the stopwatch
      accum="$(kvs_get stopwatch "${name}_accumulator")"
      kvs_set stopwatch "${name}" "${nao}"
      [ "${accum}" ] && kvs_set stopwatch "${name}_laptime" "${nao}"
      eval "$(stopwatch_get_message_callback) starting ${name} ${accum}"
    fi
  }

  # 'Lap' the named stopwatch: print out a line indicating how long the named
  # stopwatch has been running, but do not stop nor reset the stopwatch.
  stopwatch_lap() {
    name="${1:-stopwatch}"
    [ "${nao}" ] || nao="$(_stopwatch_usec)"
    # Is the stopwatch running?
    if kvs_has_key stopwatch "${name}"
    then
      # emit a line indicating how long it has been running
      start="$(kvs_get stopwatch "${name}")"
      accum="$(kvs_get stopwatch "${name}_accumulator")"
      laptm="$(kvs_get stopwatch "${name}_laptime")"
      delta="$(( ${nao} - ${start} ))"
      [ "${laptm}" ] && laptm="$(( ${nao} - ${laptm} ))"
      [ "${accum}" ] && delta="$(( ${delta} + ${accum} ))"
      kvs_set stopwatch "${name}_laptime" "${nao}"
      eval "$(stopwatch_get_message_callback) lap ${name} ${delta} ${laptm}"
    else
      accum="$(kvs_get stopwatch "${name}_accumulator")"
      eval "$(stopwatch_get_message_callback) get ${name} ${accum}"
    fi
  }

  # Stop the named stopwatch and print out a line indicating how long it had
  # been running up until that point; do not reset the stopwatch.
  stopwatch_stop() {
    name="${1:-stopwatch}"
    [ "${nao}" ] || nao="$(_stopwatch_usec)"
    if kvs_has_key stopwatch "${name}"
    then
      start="$(kvs_get stopwatch "${name}")"
      accum="$(kvs_get stopwatch "${name}_accumulator")"
      delta="$(( ${nao} - ${start} ))"
      diffs="${delta}"
      [ "${accum}" ] && delta="$(( ${delta} + ${accum} ))"
      kvs_set stopwatch "${name}_accumulator" "${delta}"
      kvs_unset stopwatch "${name}"
      kvs_unset stopwatch "${name}_laptime"
      eval "$(stopwatch_get_message_callback) stopping ${name} ${delta} ${diffs}"
    else
      accum="$(kvs_get stopwatch "${name}_accumulator")"
      eval "$(stopwatch_get_message_callback) stopped ${name} ${accum}"
    fi
  }

  # Reset the named stopwatch back to zero.
  stopwatch_reset() {
    name="${1:-stopwatch}"
    [ "${nao}" ] || nao="$(_stopwatch_usec)"
    kvs_unset stopwatch "${name}"
    kvs_unset stopwatch "${name}_accumulator"
    kvs_unset stopwatch "${name}_laptime"
    eval "$(stopwatch_get_message_callback) reset ${name}"
  }

  stopwatch() {
    [ "${1}" -a "${2}" ] || stopwatch_help;
    nao="$(_stopwatch_usec)"
    case "${2}" in
    [Ss][Tt][Aa][Rr][Tt])  stopwatch_start "${1}"  ;;
    [Ll][Aa][Pp])          stopwatch_lap "${1}"    ;;
    [Ss][Tt][Oo][Pp])      stopwatch_stop "${1}"   ;;
    [Rr][Ee][Ss][Ee][Tt])  stopwatch_reset "${1}"  ;;
    *)                     stopwatch_help          ;;
    esac
  }
fi