True if a header is explicitly defined for this section.
434237
def _has_definition(self):
        """"""
        headerReference = self._sectPr.get_headerReference(self._hdrftr_index)
        return False if headerReference is None else True
627306
protected static function allowHeaders()
    {
        if (self::$needHeaders !== null) {
            return self::$needHeaders;
        }

        return self::$needHeaders = Request::is('GET') || Request::is('HEAD');
    }
1003888
private boolean shouldHeaderBeShown() {
        SharedPreferences sharedPreferences =
                PreferenceManager.getDefaultSharedPreferences(getActivity());
        String key = getString(R.string.show_dialog_header_preference_key);
        boolean defaultValue =
                getResources().getBoolean(R.bool.show_dialog_header_preference_default_value);
        return sharedPreferences.getBoolean(key, defaultValue);
    }
1342912
@Beta
    public boolean isValidSection(SectionHeader header) {
        // sidenote: the readsize should never be > 0 if the section starts
        // outside the file
        // but we make sure that everything is alright
        return getReadSize(header) > 0
                && header.getAlignedPointerToRaw() < file.length();
    }
854948
def has_header_encryption(self):
        
        if self._hdrenc_main:
            return True
        if self._main:
            if self._main.flags & RAR_MAIN_PASSWORD:
                return True
        return False
5052
private boolean isFirstLineData(State state, List<String> headerTokens) {
        // Check whether the type of the header match the type of the following data
        boolean headerCompatible = true;
        // Check whether if all types where strings
        boolean allStrings = true;
        for (int i = 0; i < state.nColumns; i++) {
            if (state.columnNumberParsable.get(i)) {
                allStrings = false;
                if (!isTokenNumberParsable(state, headerTokens.get(i))) {
                    headerCompatible = false;
                }
            }
        }
        // If all columns are strings, it's impossible to tell whether we have
        // a header or not: assume we have a header.
        // If the column types matches (e.g. the header for a number column is also
        // a number) then we'll assume the header is actually data.
        return !allStrings && headerCompatible;
    }
1363961
def has_section(self, section_name):
		
		if not self.has_option(section_name):
			return False
		return isinstance(self.get(section_name), dict)
252027
def isPeBounded(self):
        
        boundImportsDir = self.ntHeaders.optionalHeader.dataDirectory[consts.BOUND_IMPORT_DIRECTORY]
        if boundImportsDir.rva.value and boundImportsDir.size.value:
            return True
        return False
704170
private boolean isFiltered(HeaderType<?> headerType)
	{
		for (HeaderType<?> type : mFilteredHeaderTypes)
		{
			if (type.equals(headerType))
			{
				return true;
			}
		}
		return false;
	}
1307304
boolean checkIntegrity () {
        if (headerType == null) return false;
        if (headerType == HeaderType.MODE_PARAMETER_HEADER_6 && longLba) return false;
        return true;
    }
73892
def section(self, section):
        
        # check if the named section exists
        if self.config.has_section(section):
            return (True, self.config.items(section))
        return (False, 'Section: ' + section + ' does not exist')
345773
def has_alias(self, header):
        """"""
        try:
            # Force to lower case (issue #1126)
            return self._limits[self.plugin_name + '_' + header.lower() + '_' + 'alias'][0]
        except (KeyError, IndexError):
            # logger.debug("No alias found for {}".format(header))
            return None
269685
public boolean isStandardAlignmentMode() {
		long fileAlign = get(FILE_ALIGNMENT);
		long sectionAlign = get(SECTION_ALIGNMENT);
		return 0x200 <= fileAlign && fileAlign <= sectionAlign
				&& 0x1000 <= sectionAlign;
	}
615010
function hasNestedDefine(ast) {
	var result = false;

	types.visit(ast, {
		visitCallExpression: function(path) {
			if (this.isDefineExpression(path)) {
				result = true;
				this.abort();
			}

			this.traverse(path);
		},

		// whether a non top level `define(` is call in the AST
		isDefineExpression: function(path) {
			return (
				n.Identifier.check(path.node.callee) &&
				path.node.callee.name === "define" &&
				!n.Program.check(path.parent.parent.node)
			);
		}
	});

	return result;
}
495415
public boolean containsHeader(String name) {
        List<String> values = getHeaderMap().get(name);
        return (values != null && !values.isEmpty());
    }
715670
def contains_offset(self, offset):
        """"""
        
        if self.PointerToRawData is None:
           # bss and other sections containing only uninitialized data must have 0
           # and do not take space in the file
           return False
        return ( adjust_FileAlignment( self.PointerToRawData, 
                self.pe.OPTIONAL_HEADER.FileAlignment ) <= 
                    offset < 
                        adjust_FileAlignment( self.PointerToRawData,
                            self.pe.OPTIONAL_HEADER.FileAlignment ) + 
                                self.SizeOfRawData )
393122
@Override
    public boolean containsHeader(String name) {
        return (headers != null && headers.get(name) != null && !headers.get(name).isEmpty());
    }