# File lib/uttk/logger.rb, line 291
    def self.make_notif ( n )
      if n.size == 3
        n
      else
        [:new_leaf, n[0].to_logger_path, n[1]]
      end
    end

# File lib/uttk/logger.rb, line 299
    def self.make_notifs ( ns )
      ns.map { |n| make_notif(n) }
    end

# File lib/uttk/logger.rb, line 41
    def initialize ( *observers )
      @path = Logger::Path.new
      observers.flatten.each { |obs| add_observer(obs) }
      @sections = []
      @section_tree = SectionNode.new('all')
      @severity_level = Severity::DEBUG
      @nb_log_msg = 0
      @verbosity = Verbosity.new
      @verbosity_level = 0
      @closed = false
    end

# File lib/uttk/logger.rb, line 213
    def << ( v )
      v.to_uttk_log(self)
    end

# File lib/uttk/logger.rb, line 209
    def []= ( k, v )
      v.to_uttk_log_with_key(k, self)
    end

# File lib/uttk/logger.rb, line 77
    def active_section(active, *section_names)
      @sections = @section_tree.set_active_section(active, *section_names)
      nil
    end

# File lib/uttk/logger.rb, line 82
    def active_section?(section_name)
      @sections.include?(section_name)
    end

# File lib/uttk/logger.rb, line 58
    def chpath ( path )
      @path = path.dup
    end

# File lib/uttk/logger.rb, line 284
    def close
      return if @closed
      @path = Logger::Path.new unless @path.empty?
      notif :close
      @closed = true
    end

# File lib/uttk/logger.rb, line 53
    def initialize_copy ( o )
      super # FIXME share less information
      @path = o.path
    end

# File lib/uttk/logger.rb, line 107
    def log(severity_level=nil, *section_names, &block)
      severity_level ||= Severity.higher
      return true if severity_level < @severity_level
      if section_names.empty?
        format_log_message(severity_level, section_names, &block)
      else
        section_names.each do |s|
          if @sections.include?(s)
            format_log_message(severity_level, section_names, &block)
            break
          end
        end
      end
    end

# File lib/uttk/logger.rb, line 237
    def make_log_arguments(str)
      if str =~ /^([A-Za-z0-9]+)(.*)$/
        severity, tail = $1, $2
        args = []
        begin
          args << Severity.const_get(severity.upcase)
        rescue NameError
          raise(NameError, "`#{severity}' - unknown severity level")
        end
        while tail =~ /^_([A-Za-z0-9]+)(.*)$/
          args << $1
          tail = $2
        end
        args
      else
        raise(BadMethodFormat, "`#{str}' - bad format")
      end
    end

# File lib/uttk/logger.rb, line 220
    def method_missing ( key, *a, &b )
      str = key.to_s
      if str =~ /^(.*)=$/
        self[$1.to_sym] = a[0]
      elsif b
        begin
          args = make_log_arguments(str)
          args += a
          self.log(*args, &b)
        rescue BadMethodFormat
          super
        end
      else
        super
      end
    end

# File lib/uttk/logger.rb, line 205
    def new_leaf ( x )
      notif :new_leaf, @path.dup, x
    end

# File lib/uttk/logger.rb, line 159
    def new_node ( node, options=nil, &block )
      unless options.nil?
        options.each_key do |k|
          unless OPTIONS.include? k
            raise ArgumentError, "bad option: #{k}"
          end
        end
      end
      unless node.is_a? Symbol or node.is_a? Integer or node == ''
        node = node.to_s.to_sym
      end

      if block
        up_path = @path.dup
      else
        result = upper
      end

      begin
        @path << Segment.new(node, options)
      rescue Exception => ex
        if block
          secret_up up_path
        else
          result.up
        end
        raise ex
      end

      if block
        begin
          block[]
        ensure
          @path = up_path
        end
      else
        result
      end
    end

# File lib/uttk/logger.rb, line 256
    def path
      @path.dup
    end

# File lib/uttk/logger.rb, line 260
    def path_size
      @path.size
    end

# File lib/uttk/logger.rb, line 64
    def severity_level=(severity_level)
      if severity_level.is_a?(String)
        severity_level = Severity.const_get(severity_level.to_s.upcase)
      end
      if Severity.lower <= severity_level and severity_level <= Severity.higher
        @severity_level = severity_level
      else
        raise(ArgumentError, "`#{severity_level}' - invalid severity level")
      end
    end

# File lib/uttk/logger.rb, line 264
    def to_s
      "#<#{self.class} path=#{path}>"
    end

# File lib/uttk/logger.rb, line 273
    def update ( msg, *args )
      notif(msg, *args) if MESSAGES.include? msg
    end

# File lib/uttk/logger.rb, line 199
    def upper
      # The local variable up_path is very important !!!
      up_path = @path.dup
      Upper.new { @path = up_path }
    end

# File lib/uttk/logger.rb, line 88
    def verbosity=(verbosity)
      unless verbosity.is_a?(Verbosity)
        raise(ArgumentError,
              "`#{verbosity}' - must inherit from Verbosity")
      end
      @verbosity = verbosity
    end

# File lib/uttk/logger.rb, line 98
    def verbosity_level=(verbosity_level)
      if verbosity_level < 0
        raise(ArgumentError,
              "`#{verbosity_level}' - " +
              'verbosity level must be positive or null')
      end
      @verbosity_level = verbosity_level
    end

# File lib/uttk/logger.rb, line 122
    def format_log_message(severity_level, section_names, &block)
      message = block[]
      return if message.nil?
      name = Severity.label(severity_level)
      name += "_#@nb_log_msg" unless @nb_log_msg.zero?
      new_node(name) do
        if @verbosity_level == 0
          message.to_uttk_log(self)
        else
          for i in 1..@verbosity_level do
            @verbosity.class.level_fields(i).each do |field|
              self[field] = @verbosity.send(field,
                                            severity_level,
                                            section_names)
            end
          end
          self['message'] = message
        end
      end
      @nb_log_msg += 1
    end