Return whether this X500Name is empty. An X500Name is not empty
if it has at least one RDN containing at least one AVA.
191370
public boolean isEmpty() {
        int n = names.length;
        if (n == 0) {
            return true;
        }
        for (int i = 0; i < n; i++) {
            if (names[i].assertion.length != 0) {
                return false;
            }
        }
        return true;
    }
1261110
def is_valid(self, domain, diagnose=False):

        

        return_status = [ValidDiagnosis()]
        dns_checked = False

        # http://tools.ietf.org/html/rfc5321#section-2.3.5
        #   Names that can be resolved to MX RRs or address (i.e., A or AAAA)
        #   RRs (as discussed in Section 5) are permitted, as are CNAME RRs
        #   whose targets can be resolved, in turn, to MX or address RRs.
        #
        # http://tools.ietf.org/html/rfc5321#section-5.1
        #   The lookup first attempts to locate an MX record associated with
        #   the name.  If a CNAME record is found, the resulting name is
        #   processed as if it were the initial name. ... If an empty list of
        #   MXs is returned, the address is treated as if it was associated
        #   with an implicit MX RR, with a preference of 0, pointing to that
        #   host.
        #
        # is_email() author's note: We will regard the existence of a CNAME to
        # be sufficient evidence of the domain's existence. For performance
        # reasons we will not repeat the DNS lookup for the CNAME's target, but
        # we will raise a warning because we didn't immediately find an MX
        # record.
        try:
            dns.resolver.query(domain, 'MX')
            dns_checked = True
        except (dns.resolver.NXDOMAIN, dns.name.NameTooLong):
            # Domain can't be found in DNS
            return_status.append(DNSDiagnosis('NO_RECORD'))

            # Since dns.resolver gives more information than the PHP analog, we
            # can say that TLDs that throw an NXDOMAIN or NameTooLong error
            # have been checked
            if len(domain.split('.')) == 1:
                dns_checked = True
        except dns.resolver.NoAnswer:
            # MX-record for domain can't be found
            return_status.append(DNSDiagnosis('NO_MX_RECORD'))

            try:
                # TODO: See if we can/need to narrow to A / CNAME
                dns.resolver.query(domain)
            except dns.resolver.NoAnswer:
                # No usable records for the domain can be found
                return_status.append(DNSDiagnosis('NO_RECORD'))
        except dns.resolver.NoNameservers:
            return_status.append(DNSDiagnosis('NO_NAMESERVERS'))
        except (dns.exception.Timeout, dns.resolver.Timeout):
            return_status.append(DNSDiagnosis('DNS_TIMEDOUT'))

        # Check for TLD addresses
        # -----------------------
        # TLD addresses are specifically allowed in RFC 5321 but they are
        # unusual to say the least. We will allocate a separate
        # status to these addresses on the basis that they are more likely
        # to be typos than genuine addresses (unless we've already
        # established that the domain does have an MX record)
        #
        # http://tools.ietf.org/html/rfc5321#section-2.3.5
        #   In the case of a top-level domain used by itself in an address, a
        #   single string is used without any dots. This makes the requirement,
        #   described in more detail below, that only fully-qualified domain
        #   names appear in SMTP transactions on the public Internet,
        #   particularly important where top-level domains are involved.
        #
        # TLD format
        # ----------
        # The format of TLDs has changed a number of times. The standards
        # used by IANA have been largely ignored by ICANN, leading to
        # confusion over the standards being followed. These are not defined
        # anywhere, except as a general component of a DNS host name (a label).
        # However, this could potentially lead to 123.123.123.123 being a
        # valid DNS name (rather than an IP address) and thereby creating
        # an ambiguity. The most authoritative statement on TLD formats that
        # the author can find is in a (rejected!) erratum to RFC 1123
        # submitted by John Klensin, the author of RFC 5321:
        #
        # http://www.rfc-editor.org/errata_search.php?rfc=1123&eid=1353
        #   However, a valid host name can never have the dotted-decimal
        #   form #.#.#.#, since this change does not permit the highest-level
        #   component label to start with a digit even if it is not
        #   all-numeric.
        if not dns_checked:
            atom_list = domain.split(".")
            if len(atom_list) == 1:
                return_status.append(RFC5321Diagnosis('TLD'))

            try:
                float(atom_list[len(atom_list)-1][0])
                return_status.append(RFC5321Diagnosis('TLDNUMERIC'))
            except ValueError:
                pass

        final_status = max(return_status)

        return final_status if diagnose else final_status == ValidDiagnosis()
1241727
def is_empty(self):
        
        while self.pq:
            if self.pq[0][1] != self.INVALID:
                return False
            else:
                _, _, element = heapq.heappop(self.pq)
                if element in self.element_finder:
                    del self.element_finder[element]
        return True
1336895
public boolean isEmpty() {
        if(value == null) {
            return true;
        }
        
        if(value instanceof String) {
            return ((String)value).isEmpty();
        }
        
        return false;
    }
693448
def is_empty(self):
        """"""
        return (not self.breakpoint and not self.code_analysis
                and not self.todo and not self.bookmarks)
778491
boolean isSimpleName(boolean isStrictSQLNames) {
        if (isStrictSQLNames) {
            return isNonReservedIdentifier() && token.namePrefix == null;
        } else {
            return isNonCoreReservedIdentifier() && token.namePrefix == null;
        }
    }
828879
public function isEmpty()
    {
        if ($this->isStarted()) {
            ++$this->usageIndex;
        }
        foreach ($this->data as &$data) {
            if (!empty($data)) {
                return false;
            }
        }

        return true;
    }
527142
def isempty(result):
	'''  '''

	if isinstance(result, list):
		for element in result:
			if isinstance(element, list):
				if not isempty(element):
					return False
			else:
				if element is not None:
					return False
	else:
		if result is not None:
			return False
	return True
1352569
def is_pure_name(path):
    
    return (
        not os.path.isabs(path)
        and len(os.path.dirname(path)) == 0
        and not os.path.splitext(path)[1]
        and path != '.'
        and path != ''
    )
842041
def isemptyfile(filepath):
    
    exists = os.path.exists(safepath(filepath))
    if exists:
        filesize = os.path.getsize(safepath(filepath))
        return filesize == 0
    else:
        return False
986176
def checkASN(filename):
    
    # Extract the file extn type:
    extnType = filename[filename.rfind('_')+1:filename.rfind('.')]

    # Determine if this extn name is valid for an assocation file
    if isValidAssocExtn(extnType):
        return True
    else:
        return False
721122
private static boolean isEmptyOrAllRealm(String realm) {
        if (realm == null || realm.trim().isEmpty() || realm.trim().equals("*")) {
            return true;
        } else {
            return false;
        }
    }
341486
def is_empty(self):
        
        if self.bounds[1] < self.bounds[0]:
            return True
        if self.bounds[1] == self.bounds[0]:
            return not (self.included[0] and self.included[1])
877536
public boolean isEmpty() {
        for (Node p = head; p != null; p = succ(p)) {
            if (!p.isMatched())
                return !p.isData;
        }
        return true;
    }
644646
def has_instance(name, provider=None):
    '''
    
    '''
    data = get_instance(name, provider)
    if data is None:
        return False
    return True
1034994
def is_empty(self):
        """"""
        return all(date.is_empty() for date in [self.created, self.issued]) \
               and not self.publisher
813532
public boolean isEmpty() {
        return ((files == null) || files.isEmpty())
                && ((fileObjects == null) || fileObjects.isEmpty())
                && (classNames == null || classNames.isEmpty());
    }