Returns if the CPU core supports ETM.

        Args:
          self (JLink): the ``JLink`` instance.

        Returns:
          ``True`` if the CPU has the ETM unit, otherwise ``False``.
552321
def etm_supported(self):
        
        res = self._dll.JLINKARM_ETM_IsPresent()
        if (res == 1):
            return True

        # JLINKARM_ETM_IsPresent() only works on ARM 7/9 devices.  This
        # fallback checks if ETM is present by checking the Cortex ROM table
        # for debugging information for ETM.
        info = ctypes.c_uint32(0)
        index = enums.JLinkROMTable.ETM
        res = self._dll.JLINKARM_GetDebugInfo(index, ctypes.byref(info))
        if (res == 1):
            return False

        return True
1325863
def has_tsm(self):
        
        if (self.oemid['manufacturer_id'] == 19046 and
                self.oemid['device_id'] == 32):
            try:
                self.ipmicmd.xraw_command(netfn=0x3a, command=0xf)
            except pygexc.IpmiException as ie:
                if ie.ipmicode == 193:
                    return False
                raise
            return True
        return False
1068386
def isEnabled(self):
        
        
        if self._linkEnabledToCurrent:
            addtl = self.isCurrent()
        else:
            addtl = True
        
        return self._enabled and addtl
331341
def _supports_avx():
    """"""
    if os.path.exists("/proc/cpuinfo"):
        with open("/proc/cpuinfo") as in_handle:
            for line in in_handle:
                if line.startswith("flags") and line.find("avx") > 0:
                    return True
94921
def is_registered(ext):
    '''  '''
    return Lean.template_mappings.has_key(ext.lower()) and len(Lean.template_mappings[ext])
1152408
public boolean isVm() {
    try {
      XPath xpath = XPathFactory.newInstance().newXPath();
      String expression = "/appengine-web-app/vm/text()='true'";
      return (Boolean) xpath.evaluate(expression, document, XPathConstants.BOOLEAN);
    } catch (XPathExpressionException e) {
      throw new GradleException("XPath evaluation failed on appengine-web.xml", e);
    }
  }
116064
public static boolean getAt(BitSet self, int index) {
        int i = normaliseIndex(index, self.length());
        return self.get(i);
    }
510817
public boolean compatibleWith(PipelineConfiguration oth) {
        if (oth == null)
            return false;
        if (pipelineSteps.length != oth.pipelineSteps.length)
            return false;
        for (int i = 0; i < pipelineSteps.length; ++i)
            if (!pipelineSteps[i].compatibleWith(oth.pipelineSteps[i]))
                return false;
        return true;
    }
1276916
def is_compatible(self):
        ''''''
        supported_tags = pep425tags.get_supported()
        return next((True for t in self.tags() if t in supported_tags), False)
383361
def get_cpu_vendor(cls, family, arch='x86'):
        

        props = cls.get_cpu_props(family, arch)
        vendor = 'generic'
        try:
            vendor = props.xpath('vendor/@name')[0]
        except IndexError:
            pass
        return vendor
34511
def _is_convertible_to_index(other):
    
    if isinstance(other, TimedeltaIndex):
        return True
    elif (len(other) > 0 and
          other.inferred_type not in ('floating', 'mixed-integer', 'integer',
                                      'mixed-integer-float', 'mixed')):
        return True
    return False
629556
def check_tubing_TEMA(NPS=None, BWG=None):
    '''
    
    '''
    if NPS in TEMA_tubing:
        if BWG in TEMA_tubing[NPS]:
            return True
    return False
762309
public boolean isSupportedByServer()
            throws NoResponseException, XMPPErrorException, NotConnectedException, InterruptedException {
        return ServiceDiscoveryManager.getInstanceFor(connection()).serverSupportsFeature(NAMESPACE);
    }
1006025
def needs_compile(self):
        ''''''
        try:
            source_mtime = os.stat(self.sourcepath).st_mtime
        except OSError:  # no source for this template, so just return
            return False
        try:
            target_mtime = os.stat(self.targetpath).st_mtime
        except OSError: # target doesn't exist, so compile
            return True
        # both source and target exist, so compile if source newer
        return source_mtime > target_mtime
1041045
protected int supportsBranchCoupling(int couplingType, ManagedConnectionFactory managedConnectionFactory) {
        final boolean isTraceOn = TraceComponent.isAnyTracingEnabled();
        int startFlag;
        if (isJDBC) {
            startFlag = ((WSManagedConnectionFactory) managedConnectionFactory).getXAStartFlagForBranchCoupling(couplingType);
        } else {
            String bcInfo = "branch-coupling=LOOSE";
            if (couplingType == ResourceRefInfo.BRANCH_COUPLING_TIGHT)
                bcInfo = "branch-coupling=TIGHT";

            Tr.warning(tc, "IGNORE_FEATURE_J2CA0240", new Object[] { bcInfo, gConfigProps.cfName });
            startFlag = XAResource.TMNOFLAGS; // take default
        }
        if (isTraceOn && tc.isDebugEnabled()) {
            Tr.debug(this, tc, "Branch coupling request for " + cmConfig.getCFDetailsKey() + " is " + couplingType + " startFlag is " + startFlag);
        }
        return startFlag;
    }
467989
def number_format_is_linked(self):
        
        numFmt = self._element.numFmt
        if numFmt is None:
            return True
        souceLinked = numFmt.sourceLinked
        if souceLinked is None:
            return True
        return numFmt.sourceLinked
435957
public static boolean areSoSourcesAbisSupported() {
    sSoSourcesLock.readLock().lock();
    try {
      if (sSoSources == null) {
        return false;
      }

      String supportedAbis[] = SysUtil.getSupportedAbis();
      for (int i = 0; i < sSoSources.length; ++i) {
        String[] soSourceAbis = sSoSources[i].getSoSourceAbis();
        for (int j = 0; j < soSourceAbis.length; ++j) {
          boolean soSourceSupported = false;
          for (int k = 0; k < supportedAbis.length && !soSourceSupported; ++k) {
            soSourceSupported = soSourceAbis[j].equals(supportedAbis[k]);
          }
          if (!soSourceSupported) {
            Log.e(TAG, "abi not supported: " + soSourceAbis[j]);
            return false;
          }
        }
      }

      return true;
    } finally {
      sSoSourcesLock.readLock().unlock();
    }
  }