}

	set myhasstring yes
	my forget
	my RunWhenSetHooks
	return
    }

    method acceptable {} {
	debug.cmdr/parameter {}
	# Ask the validation type of the parameter for text about
	# acceptable values.
	return [{*}$myvalidate acceptable [self]]
    }

    method accept {x} {
	debug.cmdr/parameter {}
	try {
	    my ValueRelease [{*}$myvalidate validate [self] $x]
	    # If that was ok it has to be released also!
	    # XXX Or should we maybe immediately cache it for 'value'?

	myisundefined mynopromote myhasinverted

    # # ## ### ##### ######## #############
}

# # ## ### ##### ######## ############# #####################
## Ready
package provide cmdr::parameter 1.6

debug define cmdr/validate
debug level  cmdr/validate
debug prefix cmdr/validate {[debug caller] | }

# # ## ### ##### ######## ############# #####################

namespace eval ::cmdr::validate::boolean {
    namespace export default validate complete release acceptable
    namespace ensemble create
    namespace import ::cmdr::validate::common::fail
    namespace import ::cmdr::validate::common::complete-enum
}

proc ::cmdr::validate::boolean::release  {p x} { return }
proc ::cmdr::validate::boolean::default  {p}  {
    debug.cmdr/validate {}
    return no
}

proc ::cmdr::validate::boolean::acceptable {p} {
    debug.cmdr/validate {} 10
    return "Expected one of: yes, no, false, true, on, off, 0, or 1"
}

proc ::cmdr::validate::boolean::complete {p x} {
    debug.cmdr/validate {} 10
    return [complete-enum {yes no false true on off 0 1} 1 $x]
}

proc ::cmdr::validate::boolean::validate {p x} {

    fail $p DOUBLE "a double" $x
}

# # ## ### ##### ######## ############# #####################
## Any double in [0,100]

namespace eval ::cmdr::validate::percent {
    namespace export default validate complete release acceptable
    namespace ensemble create
    namespace import ::cmdr::validate::common::fail
}

proc ::cmdr::validate::percent::acceptable {p} {
    debug.cmdr/validate {} 10
    return "Expected a value in the range \[0...100\]."
}

proc ::cmdr::validate::percent::release  {p x} { return }
proc ::cmdr::validate::percent::default  {p}  {
    debug.cmdr/validate {}
    return 0
}
proc ::cmdr::validate::percent::complete {p x} {

proc ::cmdr::validate::str::complete {p x} { debug.cmdr/validate {} 10 ; return {} }
proc ::cmdr::validate::str::validate {p x} { debug.cmdr/validate {}    ; return $x }

# # ## ### ##### ######## ############# #####################
## File, existing and readable

namespace eval ::cmdr::validate::rfile {
    namespace export default validate complete release acceptable
    namespace ensemble create
    namespace import ::cmdr::validate::common::fail
    namespace import ::cmdr::validate::common::complete-glob
    namespace import ::cmdr::validate::common::one-path
}

proc ::cmdr::validate::rfile::acceptable {p} {
    debug.cmdr/validate {} 10
    return [one-path "readable file" ::cmdr::validate::rfile::Ok]
}

proc ::cmdr::validate::rfile::release  {p x} { return }
proc ::cmdr::validate::rfile::default  {p}   { return {} }
proc ::cmdr::validate::rfile::complete {p x} {
    debug.cmdr/validate {} 10
    complete-glob ::cmdr::validate::rfile::Ok $x

    return 1
}

# # ## ### ##### ######## ############# #####################
## File, existing and writable

namespace eval ::cmdr::validate::wfile {
    namespace export default validate complete release acceptable
    namespace ensemble create
    namespace import ::cmdr::validate::common::fail
    namespace import ::cmdr::validate::common::complete-glob
    namespace import ::cmdr::validate::common::one-path
    namespace import ::cmdr::validate::common::ok-directory
}

proc ::cmdr::validate::wfile::acceptable {p} {
    debug.cmdr/validate {} 10
    return [one-path "writable file" ::cmdr::validate::wfile::Ok]
}

proc ::cmdr::validate::wfile::release  {p x} { return }
proc ::cmdr::validate::wfile::default  {p}   { return {} }
proc ::cmdr::validate::wfile::complete {p x} {
    debug.cmdr/validate {} 10
    complete-glob ::cmdr::validate::wfile::Ok $x
}

    return 1
}

# # ## ### ##### ######## ############# #####################
## File, existing and read/writable

namespace eval ::cmdr::validate::rwfile {
    namespace export default validate complete release acceptable
    namespace ensemble create
    namespace import ::cmdr::validate::common::fail
    namespace import ::cmdr::validate::common::complete-glob
    namespace import ::cmdr::validate::common::one-path
    namespace import ::cmdr::validate::common::ok-directory
}

proc ::cmdr::validate::rwfile::acceptable {p} {
    debug.cmdr/validate {} 10
    return [one-path "read/writeable file" ::cmdr::validate::rwfile::Ok]
}

proc ::cmdr::validate::rwfile::release  {p x} { return }
proc ::cmdr::validate::rwfile::default  {p}   { return {} }
proc ::cmdr::validate::rwfile::complete {p x} {
    debug.cmdr/validate {} 10
    complete-glob ::cmdr::validate::rwfile::Ok $x
}

    return 1
}

# # ## ### ##### ######## ############# #####################
## Directory, existing and readable.

namespace eval ::cmdr::validate::rdirectory {
    namespace export default validate complete release acceptable
    namespace ensemble create
    namespace import ::cmdr::validate::common::fail
    namespace import ::cmdr::validate::common::complete-glob
    namespace import ::cmdr::validate::common::one-path
}

proc ::cmdr::validate::rdirectory::acceptable {p} {
    debug.cmdr/validate {} 10
    return [one-path "readable directory" ::cmdr::validate::rdirectory::Ok]
}

proc ::cmdr::validate::rdirectory::release  {p x} { return }
proc ::cmdr::validate::rdirectory::default  {p}   { return {} }
proc ::cmdr::validate::rdirectory::complete {p x} {
    debug.cmdr/validate {} 10
    complete-glob ::cmdr::validate::rdirectory::Ok $x

    return 1
}

# # ## ### ##### ######## ############# #####################
## Directory, existing and read/writable.

namespace eval ::cmdr::validate::rwdirectory {
    namespace export default validate complete release acceptable
    namespace ensemble create
    namespace import ::cmdr::validate::common::fail
    namespace import ::cmdr::validate::common::complete-glob
    namespace import ::cmdr::validate::common::one-path
    namespace import ::cmdr::validate::common::ok-directory
}

proc ::cmdr::validate::rwdirectory::acceptable {p} {
    debug.cmdr/validate {} 10
    return [one-path "read/writable directory" ::cmdr::validate::rwdirectory::Ok]
}

proc ::cmdr::validate::rwdirectory::release  {p x} { return }
proc ::cmdr::validate::rwdirectory::default  {p}   { return {} }
proc ::cmdr::validate::rwdirectory::complete {p x} {
    debug.cmdr/validate {} 10
    complete-glob ::cmdr::validate::rwdirectory::Ok $x
}

    return 1
}

# # ## ### ##### ######## ############# #####################
## Any path, existing and readable.

namespace eval ::cmdr::validate::rpath {
    namespace export default validate complete release acceptable
    namespace ensemble create
    namespace import ::cmdr::validate::common::fail
    namespace import ::cmdr::validate::common::complete-glob
    namespace import ::cmdr::validate::common::one-path
}

proc ::cmdr::validate::rpath::acceptable {p} {
    debug.cmdr/validate {} 10
    return [one-path "readable path" ::cmdr::validate::rpath::Ok]
}

proc ::cmdr::validate::rpath::release  {p x} { return }
proc ::cmdr::validate::rpath::default  {p}   { return {} }
proc ::cmdr::validate::rpath::complete {p x} {
    debug.cmdr/validate {} 10
    complete-glob ::cmdr::validate::rpath::Ok $x

    return 1
}

# # ## ### ##### ######## ############# #####################
## Any path, existing and read/writable.

namespace eval ::cmdr::validate::rwpath {
    namespace export default validate complete release acceptable
    namespace ensemble create
    namespace import ::cmdr::validate::common::fail
    namespace import ::cmdr::validate::common::complete-glob
    namespace import ::cmdr::validate::common::one-path
    namespace import ::cmdr::validate::common::ok-directory
}

proc ::cmdr::validate::rwpath::acceptable {p} {
    debug.cmdr/validate {} 10
    return [one-path "read/writable path" ::cmdr::validate::rwpath::Ok]
}

proc ::cmdr::validate::rwpath::release  {p x} { return }
proc ::cmdr::validate::rwpath::default  {p}   { return {} }
proc ::cmdr::validate::rwpath::complete {p x} {
    debug.cmdr/validate {} 10
    complete-glob ::cmdr::validate::rwpath::Ok $x
}

    return 1
}

# # ## ### ##### ######## ############# #####################
## Channel, for existing and readable file. Defaults to stdin.

namespace eval ::cmdr::validate::rchan {
    namespace export default validate complete release acceptable
    namespace ensemble create
    namespace import ::cmdr::validate::common::fail
    namespace import ::cmdr::validate::common::complete-glob
    namespace import ::cmdr::validate::common::one-path
}

proc ::cmdr::validate::rchan::acceptable {p} {
    debug.cmdr/validate {} 10
    return [one-path "readable file" ::cmdr::validate::rchan::Ok]
}

proc ::cmdr::validate::rchan::release  {p x} {
    if {$x eq "stdin"} return
    close $x
    return
}

    return 1
}

# # ## ### ##### ######## ############# #####################
## Channel, for existing and writable file. Defaults to stdout.

namespace eval ::cmdr::validate::wchan {
    namespace export default validate complete release acceptable
    namespace ensemble create
    namespace import ::cmdr::validate::common::fail
    namespace import ::cmdr::validate::common::complete-glob
    namespace import ::cmdr::validate::common::one-path
    namespace import ::cmdr::validate::common::ok-directory
}

proc ::cmdr::validate::wchan::acceptable {p} {
    debug.cmdr/validate {} 10
    return [one-path "writable file" ::cmdr::validate::wchan::Ok]
}

proc ::cmdr::validate::wchan::release  {p x} {
    if {$x eq "stdout"} return
    close $x
    return
}

proc ::cmdr::validate::wchan::default  {p}   { return stdout }
proc ::cmdr::validate::wchan::complete {p x} {
    debug.cmdr/validate {} 10
    complete-glob ::cmdr::validate::wchan::Ok $x
}
proc ::cmdr::validate::wchan::validate {p x} {
    debug.cmdr/validate {}

    return 1
}

# # ## ### ##### ######## ############# #####################
## Channel, for existing and read/writable file. No default.

namespace eval ::cmdr::validate::rwchan {
    namespace export default validate complete release acceptable
    namespace ensemble create
    namespace import ::cmdr::validate::common::fail
    namespace import ::cmdr::validate::common::complete-glob
    namespace import ::cmdr::validate::common::one-path
    namespace import ::cmdr::validate::common::ok-directory
}

proc ::cmdr::validate::rwchan::acceptable {p} {
    debug.cmdr/validate {} 10
    return [one-path "read/writable file" ::cmdr::validate::rwchan::Ok]
}

proc ::cmdr::validate::rwchan::release  {p x} { close $x }
proc ::cmdr::validate::rwchan::default  {p}   { return {} }
proc ::cmdr::validate::rwchan::complete {p x} {
    debug.cmdr/validate {} 10
    complete-glob ::cmdr::validate::rwchan::Ok $x
}

    if {![file readable $path]} {return 0}
    if {![file writable $path]} {return 0}
    return 1
}

# # ## ### ##### ######## ############# #####################
## Ready
package provide cmdr::validate 1.4
return

    namespace ensemble create
}

namespace eval ::cmdr::validate::common {
    namespace export \
	complete-enum complete-glob complete-substr \
	ok-directory lead-in fail fail-unknown-thing \
	fail-known-thing one-of one-path expected
    namespace ensemble create
}

# # ## ### ##### ######## ############# #####################

debug define cmdr/validate/common
debug level  cmdr/validate/common

proc ::cmdr::validate::common::fail-unknown-thing {p code type x {context {}}} {
    # Specific failure for a named thing: Expected existence, found it missing.
    debug.cmdr/validate/common {}

    append msg "Found a problem with [$p type] \"[$p the-name]\":"
    append msg " [lead-in $type] \"$x\" does not exist$context."

    # Ping the parameter for knowledge of acceptable values and use
    # the information when available. Fall back to a generic text if
    # the parameter doesn't know anything.
    if {[catch {
	set acceptable [$p acceptable]
	# This calls, indirectly, on method 'acceptable' of p's
	# validation type.
    }]} {
	debug.cmdr/validate/common {fail accept: $::errorInfo}

	append msg " Please use a different value."
    } else {
	debug.cmdr/validate/common {accept: $acceptable}

	append msg " " $acceptable
    }
    return -code error -errorcode [list CMDR VALIDATE {*}$code] $msg
}

proc ::cmdr::validate::common::fail-known-thing {p code type x {context {}}} {
    # Specific failure for a named thing: Expected non-existence, found a definition.
    debug.cmdr/validate/common {}

    } elseif {[string match {[aeiouAEIOU]*} $type]} {
	set lead {An }
    } else {
	set lead {A }
    }
    return $lead$type
}

proc ::cmdr::validate::common::one-path {label filter} {
    set matches [complete-glob $filter *]
    if {![llength $matches]} {
	return "No ${label} found here."
    }
    return "Expected one of\n[one-of $matches yes]"
}

proc ::cmdr::validate::common::one-of {enum {multi no}} {
    if {$multi} {
	set n [string length [expr {1+[llength $enum]}]]
	set m {}
	set i 0
	foreach w $enum { incr i ; append m "[format %${n}d $i]. $w\n" }
    } elseif {[llength $enum] < 2} {
	set m "\"[lindex $enum 0]\""
    } else {
	set m {}
	foreach w [lrange $enum 0 end-1] {
	    append m "\"$w\", "
	}
	append m "or \"[lindex $enum end]\""
    }
    return $m
}

proc ::cmdr::validate::common::expected {enum} {
    if {![llength $enum]} {
	return "Nothing acceptable found"
    }
    set multi [expr {[llength $enum] <= 20}]
    set sep [expr {$multi ? "\n" : ": "}]
    set sfx [expr {$multi ? "" : "."}]
    return "Expected one of$sep[one-of $enum $multi]$sfx"
}

# # ## ### ##### ######## ############# #####################

proc ::cmdr::validate::common::complete-enum {choices nocase buffer} {
    # As a helper function for command completion printing anything
    # here would mix with the output of linenoise. Do that only on
    # explicit request (level 10).

    if {![file isdirectory $path]} {return 0}
    if {![file writable    $path]} {return 0}
    return 1
}

# # ## ### ##### ######## ############# #####################
## Ready
package provide cmdr::validate::common 1.3
return