Returns a lazy initialized map of wrapped element resources by container name.<p>

@return the lazy map of element resource wrappers
502518
public Map<String, List<CmsJspResourceWrapper>> getElementsInContainer() {

        return CmsCollectionsGenericWrapper.createLazyMap(obj -> {
            if (obj instanceof String) {
                List<CmsJspResourceWrapper> elements = new ArrayList<>();
                CmsContainerBean container = getPage().getContainers().get(obj);
                if (container != null) {
                    for (CmsContainerElementBean element : container.getElements()) {
                        try {
                            element.initResource(m_cms);
                            elements.add(CmsJspResourceWrapper.wrap(m_cms, element.getResource()));
                        } catch (Exception e) {
                            LOG.error(e.getLocalizedMessage(), e);
                        }
                    }
                }
                return elements;
            } else {
                return null;
            }
        });

    }
643457
protected Map<String, CmsDefaultSet<String>> safeGetAllowedContextMap() {

        try {
            return OpenCms.getResourceManager().getAllowedContextMap(m_cms);
        } catch (Exception e) {
            LOG.error(e.getLocalizedMessage(), e);
            return Collections.emptyMap();
        }
    }
94605
public static List<CmsContainerElementBean> getInheritedContainerElements(
        CmsObject cms,
        CmsContainerElementBean element) {

        CmsResource resource = element.getResource();
        return CmsXmlInheritGroupContainerHandler.loadInheritContainerElements(cms, resource);
    }
667147
public List<String> getLockedResources() {

        if (m_lockedResources == null) {
            // collect my locked resources
            Set<String> lockedResources = new HashSet<String>();
            Iterator<String> i = getResourceList().iterator();
            while (i.hasNext()) {
                String resName = i.next();
                try {
                    lockedResources.addAll(getCms().getLockedResources(resName, getNonBlockingFilter()));
                } catch (CmsException e) {
                    // error reading a resource, should usually never happen
                    if (LOG.isErrorEnabled()) {
                        LOG.error(e.getLocalizedMessage(getLocale()), e);
                    }
                }
                if (Boolean.valueOf(getParamIncluderelated()).booleanValue()) {
                    addLockedRelatedResources(resName, getNonBlockingFilter(), lockedResources);
                }
            }
            // get blocking resources needs the locked resources
            m_lockedResources = new ArrayList<String>(lockedResources);
            lockedResources.addAll(getBlockingLockedResources());
            // create the locked resources list again, with the blocking locked resources
            m_lockedResources = new ArrayList<String>(lockedResources);
            Collections.sort(m_lockedResources);
        }
        return m_lockedResources;
    }
1000413
public Map<String, Object> getAttributes() {

        Map<String, Object> attrs = CmsRequestUtil.getAtrributeMap(m_request);

        if (attrs.size() == 0) {
            return null;
        }
        return attrs;
    }
996977
public CmsContainerElementData getCachedNewElement(String resourceTypeName) {

        if (m_newElements.containsKey(resourceTypeName)) {
            return m_newElements.get(resourceTypeName);
        }
        return null;
    }
1021856
public Map<String, Namespace> getNamespaceMap() {
        final Map<String, Namespace> ret = new HashMap<String, Namespace>();
        if (namespaceGroup == null) {
            return ret;
        }

        final List<Namespace> namespaces = namespaceGroup.getNamespaces();
        if (hasItems(namespaces)) {
            for (final Namespace ns : namespaces)
                ret.put(ns.getPrefix(), ns);
        }

        final String defns = namespaceGroup.getDefaultResourceLocation();
        if (defns != null) {
            Namespace ns = new Namespace(DEFAULT_NAMESPACE_PREFIX, defns);
            ret.put(DEFAULT_NAMESPACE_PREFIX, ns);
        }

        return ret;
    }
56352
public Map<String, String> getResources() {
    Map<String, String> resourceByResourceName = new HashMap<>();
    String metadata = getMetadata(ICON);
    if (metadata.equals("")) {
      metadata = getFirstIconFile(BUNDLE_ICONS);
    }
    resourceByResourceName.put(ICON, metadata);
    return resourceByResourceName;
  }
809112
public List<ResourceEnvRefType<MessageDrivenBeanType<T>>> getAllResourceEnvRef()
   {
      List<ResourceEnvRefType<MessageDrivenBeanType<T>>> list = new ArrayList<ResourceEnvRefType<MessageDrivenBeanType<T>>>();
      List<Node> nodeList = childNode.get("resource-env-ref");
      for(Node node: nodeList)
      {
         ResourceEnvRefType<MessageDrivenBeanType<T>>  type = new ResourceEnvRefTypeImpl<MessageDrivenBeanType<T>>(this, "resource-env-ref", childNode, node);
         list.add(type);
      }
      return list;
   }
935853
private Map<Object, Object> lazyProperties() {
        if (properties == null) {
            properties = new HashMap<Object, Object>();
        }
        return properties;
    }
327870
private ResourceMap computeRelatedResources() {

        ResourceMap relatedResources = new ResourceMap();
        Set<CmsResource> resourcesToProcess = Sets.newHashSet(m_originalResources);
        Set<CmsResource> processedResources = Sets.newHashSet();
        while (!resourcesToProcess.isEmpty()) {
            CmsResource currentResource = resourcesToProcess.iterator().next();
            resourcesToProcess.remove(currentResource);
            processedResources.add(currentResource);
            if (!currentResource.getState().isDeleted()) {
                Set<CmsResource> directlyRelatedResources = getDirectlyRelatedResources(currentResource);
                for (CmsResource target : directlyRelatedResources) {
                    if (!processedResources.contains(target)) {
                        resourcesToProcess.add(target);
                    }
                    relatedResources.get(currentResource).add(target);
                }
            }
        }
        return relatedResources;
    }
1070462
public Set<CmsUUID> getResourcesToRemove() {

        Set<CmsUUID> result = new HashSet<CmsUUID>(m_model.getRemoveIds());
        result.addAll(m_model.getIdsOfAlreadyPublishedResources());
        return result;
    }
316760
public Map<String, org.opencms.ade.containerpage.client.ui.CmsContainerPageContainer> getContainerTargets() {

        Map<String, org.opencms.ade.containerpage.client.ui.CmsContainerPageContainer> result = new HashMap<String, org.opencms.ade.containerpage.client.ui.CmsContainerPageContainer>();
        for (Entry<String, org.opencms.ade.containerpage.client.ui.CmsContainerPageContainer> entry : m_targetContainers.entrySet()) {
            if (entry.getValue().isEditable()
                && (!isDetailPage() || (entry.getValue().isDetailOnly() || entry.getValue().isDetailView()))) {
                result.put(entry.getKey(), entry.getValue());
            }
        }
        return result;
    }
826570
private List<CmsResource> getResources() {

        List<CmsResource> result = new LinkedList<CmsResource>();
        CmsObject cms = getCms();
        CmsResourceFilter filter = CmsResourceFilter.ALL;
        try {
            for (String path : m_paths) {
                List<CmsResource> resources = cms.readResources(path, filter, true);
                // filter out any resource that is no XML content:
                for (CmsResource resource : resources) {
                    if (resource.isFile()) {
                        if (CmsResourceTypeXmlContent.isXmlContent(resource)) {
                            result.add(resource);
                        } else if (CmsResourceTypeXmlPage.isXmlPage(resource)) {
                            result.add(resource);
                        }
                    }
                }
            }
        } catch (CmsException e) {
            LOG.error(Messages.get().getBundle().key(Messages.LOG_ERR_LANGUAGECOPY_READRESOURCES_0), e);
            result = Collections.emptyList();
        }

        return result;
    }
771776
public java.util.List<Resource> getResources() {
        if (resources == null) {
            resources = new com.amazonaws.internal.SdkInternalList<Resource>();
        }
        return resources;
    }
528184
private Map<String, String> getMapping() {
    if (this.attributesMapping != null && this.lastReload != null && this.lastReload.equals(this.attributeResolverService
      .getLastSuccessfulReloadInstant())) {
      return this.attributesMapping;
    }
    // Reload.
    ServiceableComponent<AttributeResolver> component = null;
    Map<String, String> am = null;
    try {
      // Get date before we get the component. That way we'll not leak changes.
      final DateTime when = this.attributeResolverService.getLastSuccessfulReloadInstant();
      component = this.attributeResolverService.getServiceableComponent();
      if (null == component) {
        if (!captiveServiceReloadFailed) {
          logger.error("Invalid AttributeResolver configuration");
        }
        captiveServiceReloadFailed = true;
      }
      else {
        final AttributeResolver attributeResolver = component.getComponent();
        am = new HashMap<>();

        Map<String, AttributeDefinition> map = attributeResolver.getAttributeDefinitions();
        for (Map.Entry<String, AttributeDefinition> entry : map.entrySet()) {
          String name = null;
          Set<AttributeEncoder<?>> encoders = entry.getValue().getAttributeEncoders();
          for (AttributeEncoder<?> encoder : encoders) {
            if (encoder instanceof SAML2AttributeEncoder) {
              name = ((SAML2AttributeEncoder<?>) encoder).getName();
              if (name != null) {
                break;
              }
            }
          }
          if (name != null) {
            logger.debug("Adding mapping between SAML2 attribute '{}' and id '{}'", name, entry.getKey());
            am.put(name, entry.getKey());
          }
          else {
            logger.debug("No mapping to SAML2 attribute for attribute id '{}'", entry.getKey());
          }
        }

        captiveServiceReloadFailed = false;
        lastReload = when;
      }
    }
    finally {
      if (null != component) {
        component.unpinComponent();
      }
    }

    this.attributesMapping = am;
    return am;
  }
904922
public List getResources() {

        if ((m_resources == null) || m_resources.isEmpty()) {
            m_resources = new ArrayList();
            m_resources.add("/");
        }
        return m_resources;
    }