Returns a map from element symbols to their values.
Includes all elements, whether explicit or defaulted.
974810
private Map<MethodSymbol, Attribute> getAllValues() {
        Map<MethodSymbol, Attribute> res =
            new LinkedHashMap<MethodSymbol, Attribute>();

        // First find the default values.
        ClassSymbol sym = (ClassSymbol) anno.type.tsym;
        for (Scope.Entry e = sym.members().elems; e != null; e = e.sibling) {
            if (e.sym.kind == Kinds.MTH) {
                MethodSymbol m = (MethodSymbol) e.sym;
                Attribute def = m.getDefaultValue();
                if (def != null)
                    res.put(m, def);
            }
        }
        // Next find the explicit values, possibly overriding defaults.
        for (Pair<MethodSymbol, Attribute> p : anno.values)
            res.put(p.fst, p.snd);
        return res;
    }
1158378
def all_combinations_for_elements(self, element_symbols):
        
        d = OrderedDict()
        for symbol in element_symbols:
            d[symbol] = self.select_symbols(symbol, ret_list=True)

        from itertools import product
        return list(product(*d.values()))
131825
private LinkedHashMap<PrefixedName,DTDElement> getElementMap() {
        LinkedHashMap<PrefixedName,DTDElement> m = mElements;
        if (m == null) {
            /* Let's try to get insert-ordered Map, to be able to
             * report redefinition problems in proper order when validating
             * subset compatibility
             */
            mElements = m = new LinkedHashMap<PrefixedName,DTDElement>();
        }
        return m;
    }
240689
function () {
                var t, entries = []
                for (t in map) {
                  if (t.charAt(0) === '$')
                    entries = entries.concat(map[t])
                }
                return entries
              }
373862
protected Map<String, String> getElementAttributes() {
        // Preserve order of attributes
        Map<String, String> attrs = new HashMap<>();

        if (this.getAlias() != null) {
            attrs.put("alias", this.getAlias());
        }

        return attrs;
    }
912674
public Map<String, TemplateTokenInfo> getTokensAsMap() {
        HashMap<String, TemplateTokenInfo> tokens = new HashMap<String, TemplateTokenInfo>();
        for (TemplateTokenInfo tokenInfo : tokenInfos)
            tokens.put(tokenInfo.getName(), tokenInfo);
        return Collections.unmodifiableMap(tokens);
    }
939041
def pseudos_with_symbols(self, symbols):
        
        pseudos = self.select_symbols(symbols, ret_list=True)
        found_symbols = [p.symbol for p in pseudos]
        duplicated_elements = [s for s, o in collections.Counter(found_symbols).items() if o > 1]

        if duplicated_elements:
            raise ValueError("Found multiple occurrences of symbol(s) %s" % ', '.join(duplicated_elements))
        missing_symbols = [s for s in symbols if s not in found_symbols]

        if missing_symbols:
            raise ValueError("Missing data for symbol(s) %s" % ', '.join(missing_symbols))

        return pseudos
190507
def get_value_map(self):
        
        value_map = {}
        tree_clone = self.tree_mapping_widget.invisibleRootItem().clone()
        for tree_branch in tree_clone.takeChildren():
            value_list = []
            for tree_leaf in tree_branch.takeChildren():
                value_list += [tree_leaf.data(0, Qt.UserRole)]
            if value_list:
                value_map[tree_branch.data(0, Qt.UserRole)] = value_list
        return value_map
890904
Map convertToMap() {
        Map ret = new HashMap();
        for (Enumeration e = enumerateKeys(); e.hasMoreElements();) {
            Object key = e.nextElement();
            Object value = getValue(key);
            ret.put(key, value);
        }
        return ret;
    }
165319
public Map<String,Element> getElementsById() {
		synchronized(lock) {
			if(elementsById == null) return Collections.emptyMap();
			if(frozen) return elementsById;
			return AoCollections.unmodifiableCopyMap(elementsById);
		}
	}
1137871
public List<String> getMappings(String elementName) {

        List<String> result = m_elementMappings.get(elementName);
        if (result == null) {
            result = Collections.emptyList();
        }
        return result;
    }
277354
def types(self):
        
        return [x for x in self[self.current_scope].values() if isinstance(x, symbols.TYPE)]
604832
def elements(self):
        """"""
        return (self.party_prefix, self.country_code, self.party_suffix,
                self.branch_code)
503555
def keys(self):
        ""
        return (list(self._pb.IntMap.keys()) + list(self._pb.StringMap.keys()) +
                list(self._pb.FloatMap.keys()) + list(self._pb.BoolMap.keys()))
279239
def symbols(self):
        """"""
        def _iter_symbols(symbol_values):
            # The initial charset doesn't matter, as the start codes have the same symbol values in all charsets.
            charset = 'A'

            shift_charset = None
            for symbol_value in symbol_values:
                if shift_charset:
                    symbol = self._val2sym[shift_charset][symbol_value]
                    shift_charset = None
                else:
                    symbol = self._val2sym[charset][symbol_value]

                if symbol in (self.Special.START_A, self.Special.CODE_A):
                    charset = 'A'
                elif symbol in (self.Special.START_B, self.Special.CODE_B):
                    charset = 'B'
                elif symbol in (self.Special.START_C, self.Special.CODE_C):
                    charset = 'C'
                elif symbol in (self.Special.SHIFT_A,):
                    shift_charset = 'A'
                elif symbol in (self.Special.SHIFT_B,):
                    shift_charset = 'B'

                yield symbol

        return list(_iter_symbols(self.symbol_values))
717761
public ElementValuePair[] elementValues() {
        List<Pair<MethodSymbol,Attribute>> vals = annotation.values;
        ElementValuePair res[] = new ElementValuePair[vals.length()];
        int i = 0;
        for (Pair<MethodSymbol,Attribute> val : vals) {
            res[i++] = new ElementValuePairImpl(env, val.fst, val.snd);
        }
        return res;
    }
972334
protected <T extends AnnotatedElement> Map<T, PropertyInfo> resolve(String keyPrefix, T[] elements, Set<Class> resolvedConfigs) {
        Map<T, PropertyInfo> result = new HashMap<>();
        for (T element : elements) {
            try {
                result.putAll(resolveProperty(keyPrefix, element));
                result.putAll(resolveConfig(keyPrefix, element, resolvedConfigs));
            } catch (PropertyLoaderException e) {
                throw new PropertyLoaderException(String.format("Error while process %s", element), e);
            }
        }
        return result;
    }