Whether configurations are fully compatible
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;
    }
408231
private boolean isPluginConfiguration(Configuration configuration) {
		return (configuration.containsKey(ID_KEY) && getPluginId() == configuration.getInt(ID_KEY))
				// To keep backwards compatibility check also the classname
				|| getClass().getCanonicalName().equals(configuration.getString(CLASSNAME_KEY, ""));
	}
84600
public function check()
    {
        $result = true;

        $configurationSettings = [
            'Database.Host',
            'Database.Username',
            'Database.Password',
            'Database.Port',
            'Database.Name',
        ];

        foreach ($configurationSettings as $setting) {
            if ($this->configuration->hasConfigurationKey($setting) === false) {
                $this->missingConfiguration[] = $setting;
                $result = false;
            }
        }

        return $result;
    }
398312
public function isConfigured()
    {
        if (!empty($this->urlParts) && isset($this->solrMap[$this->className])) {
            return true;
        }
        return false;
    }
816912
function checkCompatibility() {
        // We use JSON for serialization. http://caniuse.com/#feat=json
        if (! window.JSON) {
            return false;
        }

        // For now, we require jQuery.
        // In the future, we may build adaptors for other libraries
        if (! window.jQuery) {
            return false;
        }

        // We require jQuery >= 1.7, because of `.on`
        if (jQuery().jquery <= '1.7') {
            return false;
        }

        // Otherwise, we are good
        return true;
    }
562366
def valid_configs(self):
        
        if self.ykver() < (2,1,0):
            raise YubiKeyUSBHIDError('Valid configs unsupported in firmware %s' % (self.version()))
        res = []
        if self.touch_level & self.CONFIG1_VALID == self.CONFIG1_VALID:
            res.append(1)
        if self.touch_level & self.CONFIG2_VALID == self.CONFIG2_VALID:
            res.append(2)
        return res
1276916
def is_compatible(self):
        ''''''
        supported_tags = pep425tags.get_supported()
        return next((True for t in self.tags() if t in supported_tags), False)
233875
function compatibleTypes(x,y) {
	if (x === y)
		return true;
	if (x instanceof TQualifiedReference && y instanceof TQualifiedReference)
		return x.qname === y.qname;
	return false;
}
1325330
public boolean shouldConfigureVirtualenv() {
    if(this.configureVirtualenv == ConfigureVirtualenv.NO) {
      return false;
    } else if(this.configureVirtualenv == ConfigureVirtualenv.YES) {
      return true;
    } else {
      final Optional<File> whichVirtualenv = this.which("virtualenv");
      return whichVirtualenv.isPresent();
    }
  }
419972
public boolean compatible( PropertySet properties)
    {
    boolean isCompatible;
    Iterator<IDisjunct> disjuncts;
    
    for( disjuncts = getDisjuncts(),
           isCompatible = true;
           

         isCompatible
           && disjuncts.hasNext();

         isCompatible = disjuncts.next().compatible( properties));
    
    return isCompatible;
    }
673076
private boolean importConfigurations() {
		// Create a set of files in the inventory
		Set<File> files = inventory.entries().stream().map(v->v.getPath()).collect(Collectors.toSet());
		List<File> entriesToImport = Arrays.asList(baseDir.listFiles(f->
			f.isFile()
			&& !f.equals(catalog)	// Exclude the master catalog (should it have the same extension as entries)
			&& f.getName().endsWith(CONFIG_EXT)
			&& !files.contains(f))	// Exclude files already in the inventory
		);
		entriesToImport.forEach(f->{
			try {
				inventory.add(InventoryEntry.create(Configuration.read(f).copyWithIdentifier(inventory.nextIdentifier()), newConfigurationFile()));
				f.delete();
			} catch (IOException e) {
				if (logger.isLoggable(Level.FINE)) {
					logger.log(Level.FINE, "Failed to read: " + f, e);
				}
			}
		});
		return !entriesToImport.isEmpty();
	}
855966
def values
      VALID_CONFIGURATION_KEYS.inject({}){|o,k| o.merge!(k => send(k)) }
    end
765077
def _is_compatible_with(self, other):
        

        title = self._compare_title(other)
        suffix = self._compare_suffix(other)

        return title and suffix
802517
def check_config(self, section, name, has_default=False, value=None, allowEmpty=False):
    
    

    cfg = self.config
    if not cfg.has_key(section) or not cfg.get(section).has_key(name):
      if not has_default:
        self.config_errors.append("%s: %s -> missing" % (section, name))
        return False
      else:
        return True

    v = cfg.get(section).get(name)

    if v == "" and not allowEmpty:
      self.config_errors.append("%s: %s -> empty" % (section, name))
      return False
    return True
508147
def is_compatible_assembly_level(self, ncbi_assembly_level):
        """"""
        configured_ncbi_strings = [self._LEVELS[level] for level in self.assembly_level]
        return ncbi_assembly_level in configured_ncbi_strings
96344
private boolean containsIncompatibleResourceType() {
    if (queryByResourceType && queryByPermission) {
      Resource[] resources = resourcesIntersection.toArray(new Resource[resourcesIntersection.size()]);
      return !ResourceTypeUtil.resourceIsContainedInArray(resourceType, resources);
    }
    return false;
  }
590717
def is_cql_compatible(self):
        
        if self.virtual:
            return False
        comparator = getattr(self, 'comparator', None)
        if comparator:
            # no compact storage with more than one column beyond PK if there
            # are clustering columns
            incompatible = (self.is_compact_storage and
                            len(self.columns) > len(self.primary_key) + 1 and
                            len(self.clustering_key) >= 1)

            return not incompatible
        return True