Return value used to compare size of this node
775471
def value( self, node, parent=None ):
        """"""
        # this is the *weighted* size/contribution of the node 
        try:
            return node['contribution']
        except KeyError, err:
            contribution = int(node.get('totsize',0)/float( len(node.get('parents',())) or 1))
            node['contribution'] = contribution
            return contribution
233402
function() {
					var full;
					if (node.hasClass(cls)) {
						return node.get(0);
					} else {
						full = node.find('.' + cls);
						if (full.length) {
							return full.get(0);
						}
					}
					return null;
				}
996707
def visit_RETURN(self, node):
        
        if len(node.children) == 2:
            node.children[1] = (yield ToVisit(node.children[1]))
        yield node
335616
function size(o) {
  var bbox = o.getBounds ? o.getBounds() : o;

  var foo = bbox[1].minus(bbox[0]);
  return foo;
}
625752
function(node) {
        var w = Y_DOM._getDocSize(node).width;
        return Math.max(w, Y_DOM._getWinSize(node).width);
    }
462740
def get_size(self, value=None):
        """"""
        if isinstance(value, ActionHeader):
            return value.get_size()
        elif value is None:
            current_size = super().get_size()
            return ceil(current_size / 8) * 8
        raise ValueError(f'Invalid value "{value}" for Action*.get_size()')
1034665
def Size(self):
        

        return s.uint8 + GetVarSize(self.Key) + GetVarSize(self.Field) + GetVarSize(self.Value)
374781
function measureText (nodes, parentNode) {
  let width = 0
  for (let i = 0; i < nodes.length; i++) {
    const node = nodes[i]
    width += measure(node.textContent, node.nodeType === 1 ? node : parentNode)
  }
  return width
}
1369790
def sizeof(s):
    
    if hasattr(s, '_size_'):
        return s._size_

    elif isinstance(s, bytes):
        return len(s)

    raise ValueError(s)
1258156
function _getSize(attribute, value) {
    hasNumeric = _hasRule(attribute, _numericRules);

    // This method will determine if the attribute is a number, string, or file and
    // return the proper size accordingly. If it is a number, then number itself
    // is the size. If it is a file, we take kilobytes, and for a string the
    // entire length of the string will be considered the attribute size.
    if (/^[0-9]+$/.test(value) && hasNumeric) {
      return getValue(attribute);
    } else if (value && is_string(value) || is_array(value)) {
      return value.length;
    }

    return 0;
  }
976948
def fetch_size fsz, &block
    obj = self.dup
    obj.instance_variable_set :@fetch_size, fsz
    ret obj, &block
  end
563651
def get_size(self, value=None):
        
        if isinstance(value, type(self)):
            return value.get_size()

        return 2 + self.length
772595
function calcPreferredSize(pw) {
            if (arguments.length > 0) {
                var bl = [];
                if (this.$lastWidth < 0 || this.$lastWidth !== pw) {
                    bl = this.$breakToLines(pw);
                } else {
                    bl = this.$brokenLines;
                }

                return {
                    width  : pw,
                    height : bl.length * this.getLineHeight() +
                            (bl.length - 1) * this.lineIndent
                };
            } else {
                return this.$super();
            }
        }
1362264
public int size()
    {
        int size = 0;
        if (value != null)
            size++;
        for (Trie<K, V> child : children.values())
            size += child.size();
        return size;
    }
647858
def get_size(self, value=None):
        """"""
        if isinstance(value, Match):
            return value.get_size()
        elif value is None:
            current_size = super().get_size()
            return ceil(current_size / 8) * 8
        raise ValueError(f'Invalid value "{value}" for Match.get_size()')
145892
def _eval_num(self, node):
        
        if self.floats:
            return node.n
        else:
            return int(node.n)
59941
private int get_size_i(final boolean fwd) {
	int size = 0;
	final Iterator it = elements.iterator();
	while (it.hasNext()) {
	    final GroupElement e = (GroupElement) it.next();
	    if (e instanceof GroupDeviceElement || fwd) {
		size += e.get_size(true);
	    }
	}
	return size;
    }