Gets lazy map that returns lists of element beans for the container whose name is given as a key.<p>

@return a lazy map to fetch contents of a container
505929
public Map<?, ?> getByContainer() {

        if (m_byContainer == null) {
            m_byContainer = CmsCollectionsGenericWrapper.createLazyMap(new Transformer() {

                public Object transform(Object arg0) {

                    String key = (String)arg0;
                    CmsContainerBean container = m_page.getContainers().get(key);
                    if (container == null) {
                        return Collections.emptyList();
                    } else {
                        return container.getElements();
                    }
                }
            });
        }
        return m_byContainer;
    }
789178
public List<CmsUUID> getElementIds() {

        if (m_elementIds == null) {
            m_elementIds = new ArrayList<CmsUUID>(m_elements.size());
            for (CmsContainerElementBean element : m_elements) {
                m_elementIds.add(element.getId());
            }
        }
        return m_elementIds;
    }
576115
public List<BeanType<ConstraintMappingsType<T>>> getAllBean()
   {
      List<BeanType<ConstraintMappingsType<T>>> list = new ArrayList<BeanType<ConstraintMappingsType<T>>>();
      List<Node> nodeList = childNode.get("bean");
      for(Node node: nodeList)
      {
         BeanType<ConstraintMappingsType<T>>  type = new BeanTypeImpl<ConstraintMappingsType<T>>(this, "bean", childNode, node);
         list.add(type);
      }
      return list;
   }
825845
public Map<String, BeanSpec> fields() {
        if (null != fields) {
            return fields;
        }
        synchronized (this) {
            if (null == fields) {
                Map<String, BeanSpec> map = new HashMap<>();
                for (BeanSpec spec : fields($.F.<Field>yes())) {
                    map.put(spec.name, spec);
                    // need to treat the alias of field name
                    if (spec.originalName != spec.name) {
                        map.put(spec.originalName, spec);
                    }
                }
                fields = Collections.unmodifiableMap(map);
            }
        }
        return fields;
    }
1361731
public java.util.List<java.util.Map<String, String>> getContent() {
        if (content == null) {
            content = new com.amazonaws.internal.SdkInternalList<java.util.Map<String, String>>();
        }
        return content;
    }
1210888
public static <BEAN, KEYTYPE> Set<KEYTYPE> getNoDataKeySet(Map<KEYTYPE, BEAN> map) {
		Set<KEYTYPE> keySet = null;
		Iterator<Entry<KEYTYPE, BEAN>> iterator = map.entrySet().iterator();
		while (iterator.hasNext()) {
			Entry<KEYTYPE, BEAN> entry = iterator.next();
			BEAN bean = entry.getValue();
			if (bean == null) {
				if (keySet == null) {
					keySet = new LinkedHashSet<KEYTYPE>();
				}
				keySet.add(entry.getKey());
			}
		}
		return keySet;
	}
487042
private Map<String, Item> getKeyItemMap() {

        Map<String, Item> ret = new HashMap<String, Item>();
        for (Object itemId : m_container.getItemIds()) {
            ret.put(
                m_container.getItem(itemId).getItemProperty(TableProperty.KEY).getValue().toString(),
                m_container.getItem(itemId));
        }
        return ret;

    }
320126
public String[] keys () {
        String[] keys = new String[count];
        for (int i = 0; i < count; ++i) {
            keys[i] = container[i].key;
        }
        return keys;
    }
713079
public Map<?, ?> getByType() {

        if (m_byType == null) {
            m_byType = CmsCollectionsGenericWrapper.createLazyMap(new Transformer() {

                @SuppressWarnings("synthetic-access")
                public Object transform(Object arg0) {

                    String key = (String)arg0;
                    List<CmsContainerElementBean> result = Lists.newArrayList();
                    for (Map.Entry<String, CmsContainerBean> entry : getPage().getContainers().entrySet()) {
                        CmsContainerBean value = entry.getValue();
                        for (CmsContainerElementBean element : value.getElements()) {
                            try {
                                element.initResource(m_cms);
                                if (key.equals(element.getTypeName())) {
                                    result.add(element);
                                }
                            } catch (CmsException e) {
                                LOG.error(
                                    "Could not initialize resource with site path \""
                                        + element.getSitePath()
                                        + "\" to determine the container elements type.",
                                    e);
                            }
                        }
                    }
                    return result;
                }
            });
        }
        return m_byType;
    }
1211815
public Map<CmsUUID, I_CmsFormatterBean> getAutoEnabledFormatters() {

        if (m_autoEnabledFormatters == null) {
            Map<CmsUUID, I_CmsFormatterBean> result = Maps.newHashMap();
            for (Map.Entry<CmsUUID, I_CmsFormatterBean> entry : m_formatters.entrySet()) {
                if (entry.getValue().isAutoEnabled()) {
                    result.put(entry.getKey(), entry.getValue());
                }
            }
            m_autoEnabledFormatters = result;
        }
        return Collections.unmodifiableMap(m_autoEnabledFormatters);
    }
622614
public List<T> elementList() {

        if (m_cache != null) {
            return m_cache;
        }
        if (m_relativeOrdered) {
            List<T> objectList = new ArrayList<T>();
            Iterator<CmsIdObjectElement<T>> itObjs = m_orderedObjectList.iterator();
            while (itObjs.hasNext()) {
                CmsIdObjectElement<T> object = itObjs.next();
                objectList.add(object.getObject());
            }
            m_cache = Collections.unmodifiableList(objectList);
        } else {
            m_cache = Collections.unmodifiableList(m_objectList);
        }
        return m_cache;
    }
1217698
public static Map<String, String> getImmutableContext() {
        final Map<String, String> map = contextMap.getImmutableMapOrNull();
        return map == null ? EMPTY_MAP : map;
    }
939364
public java.util.Map<String, java.util.List<String>> getFields() {
        if (fields == null) {
            fields = new com.amazonaws.internal.SdkInternalMap<String, java.util.List<String>>();
        }
        return fields;
    }
228957
public final UtlProperties
    lazyGetUtlProperties() throws Exception {
    String beanName = getUtlPropertiesName();
    UtlProperties utlProperties = (UtlProperties) this.beansMap.get(beanName);
    if (utlProperties == null) {
      utlProperties = new UtlProperties();
      this.beansMap.put(beanName, utlProperties);
      lazyGetLogger().info(null, AFactoryAppBeans.class, beanName
        + " has been created.");
    }
    return utlProperties;
  }
937187
private Map getDialogObjectMap() {

        Map objects = (Map)getSettings().getDialogObject();
        if (objects == null) {
            // using hashtable as most efficient version of a synchronized map
            objects = new Hashtable();
            getSettings().setDialogObject(objects);
        }
        return objects;
    }
1035421
public List<V> getAll(Object key) {
        List<V> res = map.get(key);
        if (res == null) {
            res = Collections.emptyList();
        }
        return res;
    }
674080
public List<String> get(String key)
    {
        if(key == null)
            throw new IllegalArgumentException("Null keys not allowed.");

        return map.get(key);
    }