Define a group of children

 @param [Symbol] name
 @param [Range] range

 @return [undefined]

 @pai private
344957
def define_group(name, range)
      define_method(name) do
        children[range]
      end
      private(name)
      memoize(name)
    end
996141
public static <C extends Comparable> RangeTree<C> create(final Iterable<Range<C>> ranges) {
        return new CenteredRangeTree<C>(ranges);
    }
899431
function variableToRule(name, ranges) {
  const terms = ['or'];
  ranges.forEach((clause) => {
    terms.push({
      type: '5C',
      terms: [
        clause.interval[0],
        endpointToRuleOperator[clause.endpoints[0]],
        name,
        endpointToRuleOperator[clause.endpoints[1]],
        clause.interval[1],
      ],
    });
  });
  if (terms.length === 2) {
    // one range, don't need the logical 'or'
    return terms[1];
  }
  return {
    type: 'logical',
    terms,
  };
}
466398
private static Element createRangeElement(Document document, String name,
			ConfigurableEmitter.Range range) {
		Element element = document.createElement(name);
		element.setAttribute("min", "" + range.getMin());
		element.setAttribute("max", "" + range.getMax());
		element.setAttribute("enabled", "" + range.isEnabled());

		return element;
	}
343594
def format
      rows = @children
      rows = @children[1..-1] if @skip_first_row
      rows ||= []
      rows = rows.collect { |row| row.format }.join("\n")

      return nil if rows.length == 0
      rows
    end
611441
def child_cell(index)
      assert_exists

      if (index - Celerity.index_offset) >= @cells.length
        raise UnknownCellException, "Unable to locate a cell at index #{index}"
      end

      TableCell.new(self, :object, @cells[index - Celerity.index_offset])
    end
1356621
function (name, items) {
    var List = this.get('List');
    var list = this.lists[name];
    if (typeof list === 'undefined') {
      var opts = lazy.clone(this.options);
      opts.items = items || this.items;
      opts.collection = this;
      this.lists[name] = list = new List(opts);
    }
    return list;
  }
160711
function _children (options) {
  if (!this.id) return []
  var min = options.hash.min
  delete options.hash.min
  options.hash.memberof = this.id
  var output = _identifiers(options)
  output = output.filter(function (identifier) {
    if (identifier.kind === 'external') {
      return identifier.description && identifier.description.length > 0
    } else {
      return true
    }
  })
  if (output.length >= (min || 0)) return output
}
265682
def cell(*names)
      # define variables
      names_list = names.first.to_s.start_with?('Lato') ? names[1..-1] : names
      cell_class = names.first.to_s.start_with?('Lato') ? "#{names.first}::" : 'LatoCore::'
      # return correct cell
      names_list.each do |name|
        cell_class = "#{cell_class}#{name.capitalize}::"
      end
      "#{cell_class}Cell".constantize
    end
514758
def lines(name=nil) #:yield: Line
      # FIXME - this would be much easier if #lines was #each, and there was a
      # different #lines that returned an Enumerator that used #each
      unless block_given?
        map do |f|
          if( !name || f.name?(name) )
            f2l(f)
          else
            nil
          end
        end.compact
      else
        each do |f|
          if( !name || f.name?(name) )
            line = f2l(f)
            if line
              yield line
            end
          end
        end
        self
      end
    end
602213
def regions(name=nil, tags=Selectable::Tags.new)
      return self if name.nil?
      self.ranges(name, tags).collect do |base_range|
        marks = self.sort.select do |mark|
          mark >= base_range.from && 
          mark <= base_range.to &&
          mark.tags >= base_range.tags
        end
        ranges = self.ranges.select do |range|
          range.from >= base_range.from &&
          range.to <= base_range.to &&
          range.tags >= base_range.tags
        end
        tl = Benelux::Timeline.new(marks)
        tl.ranges = ranges.sort
        tl
      end
    end
795287
public static Protos.Resource ranges(String name, String role, Protos.Value.Range... ranges) {
		checkNotNull(name);
		checkNotNull(role);
		checkNotNull(ranges);
		return Protos.Resource.newBuilder()
			.setName(name)
			.setType(Protos.Value.Type.RANGES)
			.setRanges(Protos.Value.Ranges.newBuilder().addAllRange(Arrays.asList(ranges)).build())
			.setRole(role)
			.build();
	}
557107
def set_children(self, value, defined):
        """"""
        self.children = value
        self.children_defined = defined
        return self
833396
def each_child_node_of(o)
      if array_like? o and not record_like? o
        if o.respond_to? :to_hash
          o.each {|k, v| yield Mapping.new(k, v) }
        else
          o.each {|_| yield _ }
        end
      end
    end
1147029
def each_with_something( test, max=0, name=nil )
      num = 0
      child=nil
      @elements.each( name ){ |child|
        yield child if test.call(child) and num += 1
        return if max>0 and num == max
      }
    end
110145
function _yield(name, context) {
  var prop = this.props[name || 'children'];
  if (typeof prop !== 'function') return prop;

  var args = Array.prototype.slice.call(arguments, 2);
  return prop.apply(context, args);
}
113043
def each_child(&block)
      if block_given?
        block.call self

        @children.each do |_, child|
          child.each_child(&block)
        end
      end
    end