Returns a map from element names to their values in "dynamic
proxy return form".  Includes all elements, whether explicit or
defaulted.
546184
private Map<String, Object> getAllReflectedValues() {
        Map<String, Object> res = new LinkedHashMap<>();

        for (Map.Entry<MethodSymbol, Attribute> entry :
                                                  getAllValues().entrySet()) {
            MethodSymbol meth = entry.getKey();
            Object value = generateValue(meth, entry.getValue());
            if (value != null) {
                res.put(meth.name.toString(), value);
            } else {
                // Ignore this element.  May (properly) lead to
                // IncompleteAnnotationException somewhere down the line.
            }
        }
        return res;
    }
728965
def get_list(self, name):
        ''''''
        normalized_name = normalize_name(name, self._normalize_overrides)
        return self._map[normalized_name]
311363
def elements(self):
        """"""
        offset = self.EXTRA_DIGITS
        if offset:
            return (self._id[:offset], self.company_prefix, self._reference,
                    self.check_digit)
        else:
            return (self.company_prefix, self._reference, self.check_digit)
161918
function getChildJSXElements(node, parent) {
  if (node.children.length === 0) return [];
  const childJsxComponentsArr = node
    .children
    .filter(jsx => jsx.type === 'JSXElement'
      && htmlElements.indexOf(jsx.openingElement.name.name) < 0);
  return childJsxComponentsArr
    .map(child => {
      return {
        name: child.openingElement.name.name,
        children: getChildJSXElements(child, parent),
        props: getReactProps(child, parent),
        state: {},
        methods: [],
      };
    });
}
125174
def _get_element_by_names(source, names):
    

    if source is None:
        return source

    else:
        if names:
            head, *rest = names
            if isinstance(source, dict) and head in source:
                return _get_element_by_names(source[head], rest)
            elif isinstance(source, list) and head.isdigit():
                return _get_element_by_names(source[int(head)], rest)
            elif not names[0]:
                pass
            else:
                source = None
        return source
1276158
def _buildElementTree(self,):
        
        t_binder = ctree.Element(self.name)

        for k,v in self.__dict__.items():
            if k not in ('name', 'urls', 'inputs', 'paging') and v :
                t_binder.set(k,v)

        self.etree = t_binder
        return t_binder
1047765
function(name) {
			name = (name || '').toLowerCase();
			
			if (name in elementMap)
				return this.getMapping(name);
			
			if (this.isInlineLevel(name))
				return 'span';
			
			return 'div';
		}
80987
function formMap(k, v) {
    // customized props
    switch (k) {
        case "link.type": {
            return {
                type: "array",
                title: "link.type",
                items: {
                    enum: Object.keys(LINE_TYPES),
                },
                uniqueItems: true,
            };
        }
    }

    return {
        title: k,
        type: typeof v,
        default: v,
    };
}
165319
public Map<String,Element> getElementsById() {
		synchronized(lock) {
			if(elementsById == null) return Collections.emptyMap();
			if(frozen) return elementsById;
			return AoCollections.unmodifiableCopyMap(elementsById);
		}
	}
630466
function createDefaultProxies(items, proxyRole) {
  const proxies = items ?
    items.map(() => template.createElement(proxyRole)) :
    [];
  // Make the array immutable to help update performance.
  Object.freeze(proxies);
  return proxies;
}
996388
def element_definitions_by_name(names)
      return [] if names.blank?

      if names.to_s == "all"
        Element.definitions
      else
        Element.definitions.select { |e| names.include? e['name'] }
      end
    end
170615
def _encode_mapping(name, value, check_keys, opts):
    """"""
    data = b"".join([_element_to_bson(key, val, check_keys, opts)
                     for key, val in iteritems(value)])
    return b"\x03" + name + _PACK_INT(len(data) + 5) + data + b"\x00"
68022
def getElementsBy(self, cond: Callable[[Element], bool]) -> NodeList:
        """"""
        return getElementsBy(self, cond)
109730
def extract_explicit_namespace_bindings(element_name, attrs)
      element_name_local_part, element_name_prefix, element_name_uri = element_name
      ns = {}
      ns[element_name_prefix] = element_name_uri if element_name_prefix && element_name_uri

      attrs.each do |name, value|
        attr_local_part, attr_prefix, attr_uri = name
        if attr_prefix && attr_uri
          raise "bindings clash: '#{attr_prefix}'=>'#{ns[attr_prefix]}' , '#{attr_prefix}'=>'#{attr_uri}'" if ns.has_key?(attr_prefix) && ns[attr_prefix]!=attr_uri
          ns[attr_prefix] = attr_uri
        end
      end
      ns
    end
440555
protected Map<String, List<Element>> elementsIndexByName() {
        HashMap<String, List<Element>> index = new HashMap<>();
        for (Object part : renderingParts) {//We have to use the rendering order of elements for multiple elements with same name
            if (part instanceof Element) {
                Element element = (Element) part;
                String name = element.getProperty("name");
                if (name != null && !name.trim().isEmpty()) {
                    boolean multiValued = element.isMultiValue();
                    if (multiValued && index.containsKey(name)) {
                        throw new IllegalStateException("Name '" + name + "' cannot be repeated in the form if any of the elements is multi-valued");
                    }

                    if (name.contains("[") && name.contains("]")) {
                        throw new IllegalStateException("Name '" + name + "' cannot be in array form");
                    }

                    if (!index.containsKey(name)) {
                        index.put(name, new ArrayList<Element>());
                    } else {
                        Class<?> expectedType = index.get(name).get(0).getValueType();
                        if (!element.getValueType().equals(expectedType)) {
                            //This is necessary for calling fillBeanProperties
                            throw new IllegalStateException("Multiple elements with same name '" + name + "' should all have the same value type");
                        }
                    }

                    index.get(name).add(element);
                }
            }

        }

        return index;
    }
598462
def projection(self, plain_src_name):
        """"""
        mapped = self.lookup(plain_src_name)
        if not mapped:
            return None
        fields = mapped.include_fields or mapped.exclude_fields
        if fields:
            include = 1 if mapped.include_fields else 0
            return dict((field, include) for field in fields)
        return None
782579
def get_template_names(self):
        
        if self.request.is_ajax():
            return [self.list_template_name]
        else:
            return super(UserMaps, self).get_template_names()