---

Class Relations

• class: ::nx::EnsembleObject

::nx::EnsembleObject create ::nx::Object::slot::__object

Methods (to be applied on the object)

• alias (scripted)

  set pathData  [:__resolve_method_path -per-object  $methodName]
  set object    [dict get $pathData object]
  
  #puts "object alias $object.[dict get $pathData methodName] $cmd"
  set r [::nsf::method::alias $object -per-object [dict get $pathData methodName]  -frame $frame $cmd]
  ::nsf::method::property $object -per-object $r call-protected  [::nsf::dispatch $object __default_method_call_protection]
  if {[info exists returns]} {::nsf::method::property $object $r returns $returns}
  if {$debug} {::nsf::method::property $object $r debug true}
  if {$deprecated} {::nsf::method::property $object $r deprecated true}
  return $r

• filters (forward)

• forward (scripted)

  set arguments [lrange [::nsf::current args] 1 end]
  set pathData  [:__resolve_method_path -per-object  $methodName]
  set object    [dict get $pathData object]
  
  if {[info exists target] && [string index $target 0] eq "-"} {
    error "target '$target' must not start with a dash"
  }
  if {[info exists frame] && $frame ni {object default}} {
    error "value of parameter '-frame' must be 'object' or 'default'"
  }
  if {[info exists returns]} {
    set nrPreArgs [expr {[llength $arguments]-[llength $args]}]
      # search for "-returns" in the arguments before $args ...
      set p [lsearch -exact [lrange $arguments 0 $nrPreArgs] -returns]
      # ... and remove it if found
      if {$p > -1} {set arguments [lreplace $arguments $p $p+1]}
  }
  set r [::nsf::method::forward $object -per-object  [dict get $pathData methodName] {*}$arguments]
  ::nsf::method::property $object -per-object $r call-protected  [::nsf::dispatch $object __default_method_call_protection]
  if {[info exists returns]} {::nsf::method::property $object $r returns $returns}
  if {$debug} {::nsf::method::property $object $r debug true}
  if {$deprecated} {::nsf::method::property $object $r deprecated true}
  return $r

• method (scripted)

  set pathData  [:__resolve_method_path -per-object $methodName]
  set object    [dict get $pathData object]
  set regObject [dict get $pathData regObject]
  
  # puts "object method $object.[dict get $pathData methodName] [list $arguments] {...}"
  set r [::nsf::method::create $object  -checkalways=$checkalways  {*}[expr {$regObject ne "" ? "-reg-object [list $regObject]" : ""}]  -per-object  [dict get $pathData methodName] $arguments $body]
  if {$r ne ""} {
      # the method was not deleted
      ::nsf::method::property $object $r call-protected  [::nsf::dispatch $object __default_method_call_protection]
      if {[info exists returns]} {::nsf::method::property $object $r returns $returns}
    if {$debug} {::nsf::method::property $object $r debug true}
    if {$deprecated} {::nsf::method::property $object $r deprecated true}
  }
  return $r

• mixins (forward)

• property (scripted)

  
  if {$accessor eq ""} {
    set accessor [::nsf::dispatch [self] __default_accessor]
    #puts stderr "OBJECT [self] got default accessor ${accessor}"
  }
  set traceSpec [expr {[info exists trace] ? [list -trace $trace] : ""}]
  
  set r [[self] object variable  -accessor $accessor  -incremental=$incremental  -class $class  -initblock $initblock  -configurable $configurable  -nocomplain=$nocomplain  {*}$traceSpec  {*}$spec]
  return $r

• variable (scripted)

  #
  # This method creates sometimes a slot, sometimes not
  # (optimization).  We need a slot currently in the following
  # situations:
  #  - when accessors are needed
  #    (serializer uses slot object to create accessors)
  #  - when initblock is non empty
  #
  
  #puts stderr "Object variable $spec accessor $accessor nocomplain $nocomplain incremental $incremental"
  
  # get name and list of parameter options
  lassign [::nx::MetaSlot parseParameterSpec -class $class -target [self] $spec]  name parameterOptions class options
  
  #puts "[self] object variable $spec name <$name> parameterOptions <$parameterOptions> class <$class> options <$options>"
  
  
  if {[dict exists $options -configurable]} {
    set configurable [dict get $options -configurable]
  }
  
  if {![info exists trace] && [info exists :trace] && ${:trace} ne "none"} {
    set trace ${:trace}
  }
  
  #puts "[self] object variable $spec haveDefault? [info exists defaultValue] opts <$parameterOptions> options <$options>"
  
  if {[info exists defaultValue]
      && [dict exists $options -substdefault]
      && [string match {*\[*\]*} $defaultValue]
    } {
    if {![info complete $defaultValue]} {
      return -code error "substdefault: default '$defaultValue' is not a complete script"
    }
    set substDefaultOptions [::nx::MetaSlot substDefaultOptions [dict get $options -substdefault]]
    set defaultValue [subst {*}$substDefaultOptions $defaultValue]
  }
  
  #
  # Check for slot-less variables
  #
  if {$initblock eq ""
      && !$configurable
      && !$incremental
      && $accessor eq "none"
      && ![info exists trace]
    } {
    #
    # The variable is slot-less.
    #
    #puts "[self]... slotless variable $spec"
  
    # The following tasks have to be still performed:
    # - If there is an explicit default value, the value has to
    #   be checked.
    # - if the type is a switch, we have to set the implicit
    #   default value, when there is not explicit default
    #
    set isSwitch [expr {[dict exists $options -type] && [dict get $options -type] eq "switch"}]
  
    if {[info exists defaultValue]} {
      if {[info exists :$name] && !$nocomplain} {
        return -code error  "object [self] has already an instance variable named '$name'"
      }
      if {$parameterOptions ne ""} {
        #puts stderr "*** ::nsf::is $parameterOptions $defaultValue // opts=$options"
        #
        # Extract from the options a spec for value checking, and
        # let "nsf::is" perform the actual checking. In case, the
        # check fails, "nsf::is" will raise an error with and error
        # message communicating the failure.
        #
        set nspec [::nx::MetaSlot optionsToValueCheckingSpec $options]
        ::nsf::is -complain $nspec $defaultValue
      } else {
        set name $spec
      }
      set :$name $defaultValue
    } elseif {$isSwitch} {
      set :$name 0
    } else {
      return -code error  "variable definition for '$name' (without value and accessor) is useless"
    }
    return
  }
  
  #puts "[self]... slot variable $spec"
  #
  # create variable via a slot object
  #
  set defaultopts [list -accessor $accessor]
  if {[info exists trace]} {lappend defaultopts -trace $trace}
  
  set slot [::nx::MetaSlot createFromParameterSpec [self]  -per-object  -class $class  -initblock $initblock  -incremental=$incremental  -private=[expr {$accessor eq "private"}]  -defaultopts $defaultopts  $spec  {*}[expr {[info exists defaultValue] ? [list $defaultValue] : ""}]]
  
  if {$nocomplain} {$slot eval {set :nocomplain 1}}
  if {!$configurable} {$slot eval {set :configurable false}}
  if {[info exists defaultValue]} {
    #
    # We could consider calling "configure" instead, but that would
    # not work for true "variable" handlers.
    #
    # In case a "get" trace is activated, don't complain about
    # pre-existing variables, which might be set via traces.
    #
    set allowpreset [expr {"get" in [$slot cget -trace] && [nsf::var::exists [self] $name]}]
    $slot setCheckedInstVar -allowpreset=$allowpreset -nocomplain=$nocomplain [self] $defaultValue
    #set :__initblock($name) 1
  }
  
  if {[$slot eval {info exists :settername}]} {
    set name [$slot cget -settername]
  } else {
    set name [$slot cget -name]
  }
  #puts "[self]... $slot cget DONE"
  return [::nsf::directdispatch [self] ::nsf::methods::object::info::method registrationhandle $name]

---