A shortcut method to access the template's external exports mapping.
@return a non-null map
345278
public Map<String,String> getExternalExports() {
		return this.template != null ? this.template.externalExports : new HashMap<String,String>( 0 );
	}
362708
private String dumpJavaColonCompEnvMap() {
        StringBuffer buffer = new StringBuffer("");
        buffer.append("EJBContext.lookup data structure contents:\n");
        buffer.append("   Contains **" + ivJavaColonCompEnvMap.size() + "** bindings.\n");
        if (!ivJavaColonCompEnvMap.isEmpty()) {
            Set<Map.Entry<String, InjectionBinding<?>>> entries = ivJavaColonCompEnvMap.entrySet();
            Iterator<Map.Entry<String, InjectionBinding<?>>> entryIterator = entries.iterator();
            int count = 0;
            while (entryIterator.hasNext()) {
                Map.Entry<String, InjectionBinding<?>> oneEntry = entryIterator.next();
                buffer.append("     Entry " + count + "\n");
                buffer.append("            Key: **" + oneEntry.getKey() + "**\n");
                buffer.append("            Value: **" + oneEntry.getValue() + "**\n");
                buffer.append("\n");
                count++;
            }
        }
        return buffer.toString();
    }
184325
public Map<String, Object> getLocals() {
    if (locals == null || locals.length == 0) {
      return null;
    }

    Map<String, Object> localsMap = new HashMap<>();
    for (LocalVariable localVariable : locals) {
      if (localVariable != null) {
        localsMap.put(localVariable.getName(), localVariable.getValue());
      }
    }

    return localsMap;
  }
1329307
@Override
    public Map<String, Document> getFragmentLayoutCopies() {
        // since this is only visible in fragment list in administrative portlet, use default portal
        // locale
        final Locale defaultLocale = localeManagerFactory.getPortalLocales().get(0);

        final Map<String, Document> layouts = new HashMap<>();

        final List<FragmentDefinition> definitions = this.fragmentUtils.getFragmentDefinitions();
        for (final FragmentDefinition fragmentDefinition : definitions) {
            final Document layout = DocumentFactory.getThreadDocument();
            final UserView userView =
                    this.fragmentUtils.getUserView(fragmentDefinition, defaultLocale);
            if (userView == null) {
                logger.warn(
                        "No UserView found for FragmentDefinition {}, it will be skipped.",
                        fragmentDefinition.getName());
                continue;
            }
            final Node copy = layout.importNode(userView.getLayout().getDocumentElement(), true);
            layout.appendChild(copy);
            layouts.put(fragmentDefinition.getOwnerId(), layout);
        }
        return layouts;
    }
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);
    }
486146
public Map<String, PortMapping> ports() {
    final ImmutableMap.Builder<String, PortMapping> builder = ImmutableMap.builder();
    for (final Map.Entry<String, PortMapping> e : job.getPorts().entrySet()) {
      final PortMapping mapping = e.getValue();
      builder.put(e.getKey(), mapping.hasExternalPort()
                              ? mapping
                              : mapping.withExternalPort(checkNotNull(ports.get(e.getKey()))));
    }
    return builder.build();
  }
253555
private Map<String, GroovyRunner> getMap() {
        Map<String, GroovyRunner> map = runnerMap;
        if (map == null) {
            writeLock.lock();
            try {
                if ((map = runnerMap) == null) {
                    runnerMap = map = new LinkedHashMap<>();
                    load(null);
                }
            } finally {
                writeLock.unlock();
            }
        }
        return map;
    }
968312
public Map<String, String> getFieldMap() {
		if (headerMap == null) {
			throw new IllegalStateException("No header available");
		}

		final Map<String, String> fieldMap = new LinkedHashMap<>(headerMap.size());
		String key;
		Integer col;
		String val;
		for (final Map.Entry<String, Integer> header : headerMap.entrySet()) {
			key = header.getKey();
			col = headerMap.get(key);
			val = null == col ? null : get(col);
			fieldMap.put(key, val);
		}

		return fieldMap;
	}
823718
protected Map<String,Object> getAdditionalScriptBindings() {
        Map<String,Object> addlBindings = new HashMap<String,Object>(1);
        addlBindings.put(VELOCITY_OUTPUT, velocityOutput);
        return addlBindings;
    }
885630
public static MappingRules getDefaultJsonMapping() {
        return new MappingRules(MappingRules.getDefaultMappingRules().MAPPING_NODE_FILTER,
                MappingRules.MAPPING_EXPORT_FILTER, MappingRules.MAPPING_IMPORT_FILTER,
                new MappingRules.PropertyFormat(MappingRules.PropertyFormat.Scope.definition,
                        MappingRules.PropertyFormat.Binary.link),
                0, MappingRules.ChangeRule.update);
    }
298633
@Override
    public Map<String, List<Object>> getAttributes() {
        for (final IAdditionalDescriptors additionalDescriptors : delegateDescriptors) {
            final Map<String, List<Object>> attributes = additionalDescriptors.getAttributes();
            if (attributes != null && !attributes.isEmpty()) {
                return attributes;
            }
        }

        return Collections.emptyMap();
    }
685221
protected function exportInternal()
    {
        // Read the TypoScript rendering configuration for the given content record
        if ($this->config !== null) {
            $this->template = '10 = RECORDS'.PHP_EOL.TypoScriptUtility::serialize('', [10 => $this->config]);
        }

        return parent::exportInternal();
    }
73094
function() {
      var node = this.startNode();
      this.expect('export');

      if (this.value === 'default') {
        return this.parseExportDefaultDeclaration(node);
      }

      if (this.value === '*') {
        return this.parseExportAllDeclaration(node);
      }

      return this.parseExportNamedDeclaration(node);
    }
850691
public function getExportFields()
    {
        $export_fields = Config::inst()->get(
            $this->modelClass,
            self::EXPORT_FIELDS
        );

        if (isset($export_fields) && is_array($export_fields)) {
            $fields = $export_fields;
        } else {
            $fields = parent::getExportFields();
        }

        $this->extend("updateExportFields", $fields);

        return $fields;
    }
909989
TemplateTypeMap extend(TemplateTypeMap other) {
    ImmutableList<JSType> resizedOtherValues = other.resizedToMatchKeys(other.templateValues);
    return registry.createTemplateTypeMap(
        concatImmutableLists(other.templateKeys, templateKeys),
        concatImmutableLists(resizedOtherValues, templateValues));
  }
1306205
@SuppressWarnings("unchecked")
    private Map<Contextual<?>, Object> getComponentInstanceMap() {
        ConcurrentHashMap<Contextual<?>, Object> map = (ConcurrentHashMap<Contextual<?>, Object>) getCurrentRenderContext()
                .get(COMPONENT_MAP_NAME);

        if (map == null) {
            map = new ConcurrentHashMap<Contextual<?>, Object>();
            getCurrentRenderContext().put(COMPONENT_MAP_NAME, map);
        }

        return map;
    }
639064
public Map<String, Node> getTemplateNodeToMatchMap() {
    Map<String, Node> map = new HashMap<>(stringLiteralMatches);

    for (int i = 0; i < templateParams.size(); i++) {
      String name = templateParams.get(i);
      map.put(name, paramNodeMatches.get(i));
    }

    for (int i = 0; i < templateLocals.size(); i++) {
      String name = templateLocals.get(i);
      map.put(name, IR.name(localVarMatches.get(i)));
    }

    return map;
  }