maps all of the layouts to their scopes, could be optimized
@return
547699
public Map<Layout, Collection<XmlScope>> getXmlScopes() {
        List<File> layoutDirs = layoutsFinder.findLayoutDirs();

        Collection<File> layoutFiles = collectionUtils.flatMap(layoutDirs, new CollectionUtils.Function<File, Collection<File>>() {
            @Override
            public Collection<File> apply(File file) {
                return collectionUtils.filter(Arrays.asList(file.listFiles()), new CollectionUtils.Function<File, Boolean>() {
                    @Override
                    public Boolean apply(File file) {
                        return file.getName().endsWith(".xml");
                    }
                });
            }
        });

        Collection<Document> docs = collectionUtils.flatMapOpt(layoutFiles, new CollectionUtils.Function<File, Option<Document>>() {
            @Override
            public Option<Document> apply(File file) {
                return getDocumentFromFile(file);
            }
        });

        return collectionUtils.toMap(collectionUtils.flatMapOpt(docs, new CollectionUtils.Function<Document, Option<Tuple<Layout, Collection<XmlScope>>>>() {
            @Override
            public Option<Tuple<Layout, Collection<XmlScope>>> apply(Document doc) {
                Option<String> optNameSpace = namespaceFinder.getNameSpace(doc);
                if (optNameSpace.isPresent()) {
                    attrPattern = Pattern.compile(String.format(NAMESPACE_ATTRIBUTE_REG, optNameSpace.get()));
                    Collection<XmlScope> scopes = getScopes(doc);
                    return Option.of(Tuple.of(new Layout(doc.getDocumentURI()), scopes));
                } else {
                    return Option.absent();
                }
            }
        }));
    }
204563
public Map<String, AnnotationDefinition> getDefinitionMap() {
        if (definitions == null) {
            return emptyMap();
        }
        final Map<String, AnnotationDefinition> ret =
                new HashMap<String, AnnotationDefinition>(definitions.size());
        for (final AnnotationDefinition ad : definitions) {
            ret.put(ad.getId(), ad);
        }
        return ret;
    }
94848
public List<Widget> getAllViews() {
        List<Widget> views = new ArrayList<>();
        for (Widget child: mContent.getChildren()) {
            Widget item =  ((ListItemHostWidget) child).getGuest();
            if (item != null) {
                views.add(item);
            }
        }
        return views;
    }
23661
function () {
        var self = this, layout = self._layout, tabsHtml = '', prefix = self.classPrefix;

        self.preRender();
        layout.preRender(self);

        self.items().each(function (ctrl, i) {
          var id = self._id + '-t' + i;

          ctrl.aria('role', 'tabpanel');
          ctrl.aria('labelledby', id);

          tabsHtml += (
            '<div id="' + id + '" class="' + prefix + 'tab" ' +
            'unselectable="on" role="tab" aria-controls="' + ctrl._id + '" aria-selected="false" tabIndex="-1">' +
            self.encode(ctrl.settings.title) +
            '</div>'
          );
        });

        return (
          '<div id="' + self._id + '" class="' + self.classes + '" hidefocus="1" tabindex="-1">' +
          '<div id="' + self._id + '-head" class="' + prefix + 'tabs" role="tablist">' +
          tabsHtml +
          '</div>' +
          '<div id="' + self._id + '-body" class="' + self.bodyClasses + '">' +
          layout.renderHtml(self) +
          '</div>' +
          '</div>'
        );
      }
332801
public Map<String, MethodInfoList> asMap() {
        // Note that MethodInfoList extends InfoList rather than MappableInfoList, because one
        // name can be shared by multiple MethodInfo objects (so asMap() needs to be of type
        // Map<String, MethodInfoList> rather than Map<String, MethodInfo>)
        final Map<String, MethodInfoList> methodNameToMethodInfoList = new HashMap<>();
        for (final MethodInfo methodInfo : this) {
            final String name = methodInfo.getName();
            MethodInfoList methodInfoList = methodNameToMethodInfoList.get(name);
            if (methodInfoList == null) {
                methodInfoList = new MethodInfoList(1);
                methodNameToMethodInfoList.put(name, methodInfoList);
            }
            methodInfoList.add(methodInfo);
        }
        return methodNameToMethodInfoList;
    }
645871
public Iterator targetMappings() {
        // System.out.println("TargetMappings called");
        // return vHostTable.values().iterator(); 316624
        Collection vHosts = vHostTable.values(); // 316624
        List l = new ArrayList(); // 316624
        l.addAll(vHosts); // 316624
        return l.listIterator(); // 316624
    }
944812
public Map<String,String> getMappings(){
		
		HashMap<String, String> mappings      = new HashMap<String, String> ();
		HashMap<String, Boolean> destInstance = new HashMap<String, Boolean>();
		
		String s = "V";
		
		destInstance.put("null", true  );
		destInstance.put("v"   , false );
		
		HashMap<String, NullPointerControl> nullPointer = new HashMap<String, NullPointerControl>();
		
		nullPointer.put("Not", NOT_ANY     );
		nullPointer.put("All", ALL         );
		nullPointer.put("Des", DESTINATION );
		nullPointer.put("Sou", SOURCE      );
		
		HashMap<String, MappingType> mapping = new HashMap<String, MappingType>();		
		
		mapping.put("All"   , ALL_FIELDS         );
		mapping.put("Valued", ONLY_VALUED_FIELDS );
		mapping.put("Null"  , ONLY_NULL_FIELDS   );
		
		java.lang.reflect.Method[] methods = IMapper.class.getDeclaredMethods();
		
		for (Entry<String, Boolean> d : destInstance.entrySet()) 
			for (Entry<String, NullPointerControl> npc : nullPointer.entrySet()) 
				for (Entry<String, MappingType> mtd : mapping.entrySet()) 
					for (Entry<String, MappingType> mts : mapping.entrySet()) {
						String methodName = d.getKey()+s+npc.getKey()+mtd.getKey()+mts.getKey();
						for (java.lang.reflect.Method method : methods) 
							if(method.getName().equals(methodName))
								mappings.put(methodName, wrappedMapping(d.getValue(),npc.getValue(),mtd.getValue(),mts.getValue()));}
		
		mappings.put("get", "return null;"+newLine);
		return mappings;
	}
414819
public List<Section> getTickmarkSections() {
        List<Section> tickmarkSectionsCopy = new ArrayList<Section>(10);
        tickmarkSectionsCopy.addAll(tickmarkSections);
        return tickmarkSectionsCopy;
    }
817901
@SuppressLint("WrongCall")
    protected boolean layout() {
        boolean relaidout = false;
        Log.v(Log.SUBSYSTEM.LAYOUT, TAG, "layout(%s): changed: %b, requested: %b", getName(),
                isChanged(), mLayoutRequested);

        if (isChanged() || mLayoutRequested) {
            Log.v(Log.SUBSYSTEM.LAYOUT, TAG, "layout(%s): calling onLayout", getName());
            relaidout = onLayout();
        }

        mLayoutRequested = false;
        mChanged = false;
        return relaidout;
    }
805923
public Map<String, String[]> getParameters() {
		final MultivaluedMap<String, String> queryParameters = getUriInfo().getQueryParameters();
		final HashMap<String, String[]> params = new HashMap<String, String[]>();
		for (final Entry<String, List<String>> paramEntry : queryParameters.entrySet()) {
			params.put(paramEntry.getKey(), paramEntry.getValue().toArray(new String[paramEntry.getValue().size()]));
		}
		return params;
	}
1288840
public Map<String, CmsContainerBean> getParentContainers() {

        if (m_parentContainers == null) {
            initPageData();
        }
        return Collections.unmodifiableMap(m_parentContainers);
    }
708843
public String getScopes() {
        final StringBuilder sb = new StringBuilder();
        for (final Scope scope : Scope.values()) {
            sb.append(scope);
            sb.append(", ");
        }
        final String scopes = sb.toString().trim();
        return scopes.substring(0, scopes.length() - 1);
    }
59697
private WindowManager.LayoutParams createLayoutParams() {
        WindowManager.LayoutParams layoutParams = getWindow().getAttributes();
        layoutParams.width = ViewGroup.LayoutParams.MATCH_PARENT;
        layoutParams.height = ViewGroup.LayoutParams.MATCH_PARENT;
        return layoutParams;
    }
477552
public Map<String, String> getResourcePathToUriMappings() {
    if (resourcePathToUriMappings == null) {
      ImmutableMap.Builder<String, String> mapBuilder = ImmutableMap.<String, String>builder();
      // Ensure that resourcePath and uri ends with a '/'
      for (Map.Entry<String, String> mapping : mappings().entrySet()) {
        mapBuilder
            .put(ensureEndsWithSlash(mapping.getKey()), ensureEndsWithSlash(mapping.getValue()));
      }
      resourcePathToUriMappings = mapBuilder.build();
    }
    return resourcePathToUriMappings;
  }
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;
    }
910821
public Map<String, Object> toRepresentation() {
        Map<String, Object> representation = new HashMap<>();
        if (templated()) {
            representation.put("href-template", hrefTemplate);
            representation.put("href-vars", hrefVars());
        } else {
            representation.put("href", href);
        }
        if (hints != null) {
            Map<String, Object> hintsRepresentation = hints.toRepresentation();
            if (!hintsRepresentation.isEmpty()) {
                representation.put("hints", hintsRepresentation);
            }
        }
        return representation;
    }
90429
@Nonnull
  @ReturnsMutableCopy
  public ICommonsList <CSSStyleRule> getAllStyleRules ()
  {
    return m_aRules.getAllMapped (r -> r instanceof CSSStyleRule, r -> (CSSStyleRule) r);
  }