Gets the SwatHtmlHeadEntry objects needed by this UI object

If this UI object is not visible, an empty set is returned to reduce
the number of required HTTP requests.

@return SwatHtmlHeadEntrySet the SwatHtmlHeadEntry objects needed by
this UI object.
972574
public function getHtmlHeadEntrySet()
    {
        if ($this->isVisible()) {
            $set = new SwatHtmlHeadEntrySet($this->html_head_entry_set);
        } else {
            $set = new SwatHtmlHeadEntrySet();
        }

        return $set;
    }
944161
@Override
    public Set<Entry<String, GroovyRunner>> entrySet() {
        Map<String, GroovyRunner> map = getMap();
        readLock.lock();
        try {
            if (map.isEmpty()) {
                return Collections.emptySet();
            }
            return Collections.unmodifiableSet(new LinkedHashSet<>(map.entrySet()));
        } finally {
            readLock.unlock();
        }
    }
1082497
public final Set<Entry<String, L[]>> getEntries() {
        return (this.map != null)
                ? this.map.entrySet()
                : Collections.<Entry<String, L[]>>emptySet();
    }
858839
public HttpHeaders preflightResponseHeaders() {
        if (preflightHeaders.isEmpty()) {
            return EmptyHttpHeaders.INSTANCE;
        }
        final HttpHeaders preflightHeaders = new DefaultHttpHeaders();
        for (Entry<CharSequence, Callable<?>> entry : this.preflightHeaders.entrySet()) {
            final Object value = getValue(entry.getValue());
            if (value instanceof Iterable) {
                preflightHeaders.add(entry.getKey(), (Iterable<?>) value);
            } else {
                preflightHeaders.add(entry.getKey(), value);
            }
        }
        return preflightHeaders;
    }
402233
@Override
	public Set<Entry<Object, Object>> entrySet() {
		final Set<Entry<Object, Object>> entrySet = new HashSet<Entry<Object, Object>>();
		lock.readLock().lock();
		try {
			final boolean useLocalPrefixes = !mixDefaultAndLocalPrefixes && hasLocalPrefixConfigurations();
			for (final Map.Entry<Object, Object> keyEntry : getKeyMap(false).entrySet()) {
				final Object value = get(keyEntry.getValue(), useLocalPrefixes);
				if (String.class == keyEntry.getKey().getClass()) {
					entrySet.add(new PPEntry(keyEntry.getKey(), value));
				} else {
					entrySet.add(new PPEntry(keyEntry.getKey(), value));
				}
			}
			return entrySet;
		} finally {
			lock.readLock().unlock();
		}
	}
486401
public final Map<String, String> getHeadersMap() {
        if (networkRequest != null && networkRequest.headers != null) {
            return networkRequest.headers.toMap();
        }
        return Collections.emptyMap();
    }
906426
public function getAvailableHtmlHeadEntrySet()
    {
        $set = parent::getAvailableHtmlHeadEntrySet();

        if ($this->input_cell !== null) {
            $set->addEntrySet(
                $this->input_cell->getAvailableHtmlHeadEntrySet()
            );
        }

        return $set;
    }
946204
@Override
    public Set<Entry<String, Object>> entrySet() {
        return new AbstractSet<Entry<String, Object>>() {
            @Override
            public Iterator<Entry<String, Object>> iterator() {
                return entryIterator();
            }

            @Override
            public int size() {
                return BeanMap.this.readMethods.size();
            }
        };
    }
384305
public Set entrySet()
    {
        if (Tracing.isAnyTracingEnabled() && trace.isEntryEnabled())
            trace.entry(this, cclass,
                        "entrySet");

        EntrySet entrySet = new EntrySet();

        if (Tracing.isAnyTracingEnabled() && trace.isEntryEnabled())
            trace.exit(this, cclass,
                       "entrySet",
                       new Object[] { entrySet });
        return entrySet;
    }
234078
public function headers()
    {
        if($this->headers === null) {
            $data = $this->serverRequest->getHeaders();
            $this->headers = $this->builder->headers($data);
        }
        
        return $this->headers;
    }
234000
public function getAvailableHtmlHeadEntrySet()
    {
        $this->createEmbeddedWidgets();

        $set = parent::getAvailableHtmlHeadEntrySet();
        $set->addEntrySet($this->check_all->getAvailableHtmlHeadEntrySet());
        return $set;
    }
49990
public function getAvailableHtmlHeadEntrySet()
    {
        $set = parent::getAvailableHtmlHeadEntrySet();

        foreach ($this->action_items as $child_widget) {
            $set->addEntrySet($child_widget->getAvailableHtmlHeadEntrySet());
        }

        return $set;
    }
820751
public Header getHeader() {
        List<Header> list = this.getDescendants(Header.class);
        if (list.size() > 0) {
            return list.get(0);
        } else {
            return null;
        }
    }
1360685
protected HtmlTree getClassUseHeader() {
        String cltype = configuration.getText(classdoc.isInterface()?
            "doclet.Interface":"doclet.Class");
        String clname = classdoc.qualifiedName();
        String title = configuration.getText("doclet.Window_ClassUse_Header",
                cltype, clname);
        HtmlTree bodyTree = getBody(true, getWindowTitle(title));
        HtmlTree htmlTree = (configuration.allowTag(HtmlTag.HEADER))
                ? HtmlTree.HEADER()
                : bodyTree;
        addTop(htmlTree);
        addNavLinks(true, htmlTree);
        if (configuration.allowTag(HtmlTag.HEADER)) {
            bodyTree.addContent(htmlTree);
        }
        ContentBuilder headContent = new ContentBuilder();
        headContent.addContent(getResource("doclet.ClassUse_Title", cltype));
        headContent.addContent(new HtmlTree(HtmlTag.BR));
        headContent.addContent(clname);
        Content heading = HtmlTree.HEADING(HtmlConstants.CLASS_PAGE_HEADING,
                true, HtmlStyle.title, headContent);
        Content div = HtmlTree.DIV(HtmlStyle.header, heading);
        if (configuration.allowTag(HtmlTag.MAIN)) {
            mainTree.addContent(div);
        } else {
            bodyTree.addContent(div);
        }
        return bodyTree;
    }
674785
public Set<Map.Entry<String, V>> entrySet()
    {
        Set<Map.Entry<String, V>> entrySet = new TreeSet<Map.Entry<String, V>>();
        StringBuilder sb = new StringBuilder();
        for (BaseNode node : child)
        {
            if (node == null) continue;
            node.walk(new StringBuilder(sb.toString()), entrySet);
        }
        return entrySet;
    }
53000
public String[] getHeader() {
        
        return columns.stream()
            .map(c -> headerMapper.toMap(c, configuration, groups))
            .toArray(n -> new String[n]);
        
    }
561781
public synchronized Set<java.util.Map.Entry<String, XAttribute>> entrySet() {
		try {
			return deserialize().entrySet();
		} catch (IOException e) {
			e.printStackTrace();
			return null;
		}
	}