Checks that the current isis version is equal to or above the suplied
    version.
972736
def check_isis_version(major, minor=0, patch=0):
    """"""
    if ISIS_VERSION and (major, minor, patch) <= ISIS_VERISON_TUPLE:
        return

    msg = 'Version %s.%s.%s of isis required (%s found).'
    raise VersionError(msg % (major, minor, patch, ISIS_VERSION))
1115866
function hasPrecedence(op1, op2) {
    (0, _invariant2['default'])(PRECEDENCE[op1] && PRECEDENCE[op2], 'Missing precedence number for\n            ' + 
    JSON.stringify(op1) + ' or ' + JSON.stringify(op2) + '.\n            See ' + 
    JSON.stringify(PRECEDENCE));

    return PRECEDENCE[op1] < PRECEDENCE[op2];}
1208508
private final boolean compareAndSetTail(Node expect, Node update) {
        return U.compareAndSwapObject(this, TAIL, expect, update);
    }
901341
public boolean equal(final Object o1,
                         Object o2) {
        if ( o1 == o2 ) {
            return true;
            
        }
        // o1 is a FactHandle, so just check their id's are the same
        if ( o1 instanceof FactHandle ) {
            return ((InternalFactHandle)o1).getId() == ((InternalFactHandle)o2).getId() ;
        }

        // o1 is an object, so unwrap o2 for comparison
        final InternalFactHandle handle = ((InternalFactHandle) o2);
        o2 = handle.getObject();
        return o1 == o2 || o2.equals( o1 );
    }
433669
private static boolean ensureVersion(Version existing, Version expected) {
        return existing != Version.UNDEFINED && existing.greaterThanOrEqualTo(expected);
    }
19091
def check_version(component, expected_version):
    """"""

    comp = comp_names[component]

    compath = os.path.realpath(os.path.abspath(comp.path))
    sys.path.insert(0, compath)

    import version

    if version.version != expected_version:
        raise EnvironmentError("Version mismatch during release, expected={}, found={}".format(expected_version, version.version))
926808
def check_version(ctx, param, value):
    """"""
    if ctx.resilient_parsing:
        return

    if not value and ctx.invoked_subcommand != 'run':
        ctx.call_on_close(_check_version)
1322525
def compare_version
      c_version = Gem::Version.new(@current_version)
      l_version = Gem::Version.new(@last_version)

      if @current_version.nil? || c_version < l_version
        yield @current_version, @last_version
      end
    end
304752
def check_version(self, check, timeout=None, metadata=None,
                      credentials=None):
        """"""
        return self.stub.CheckVersion(check, timeout=timeout,
                                      metadata=metadata,
                                      credentials=credentials)
1334897
def rpm_compare(self, a, b):
        
        if a['version'] == b['version'] and \
           a['release'] == b['release'] and \
           a['signature'] == b['signature']:
            return

        raise ValueError("%s != %s" % (a, b))
1285768
def is_equal(self, other):
        
        other = IntervalCell.coerce(other)
        return other.low == self.low and other.high == self.high
469171
def check(self):
        
        current = self._get_current()
        highest = self._get_highest_version()
        return highest > current
538836
def check_version(version: str):
    
    code_version = parse_version(__version__)
    given_version = parse_version(version)
    check_condition(code_version[0] == given_version[0],
                    "Given release version (%s) does not match release code version (%s)" % (version, __version__))
    check_condition(code_version[1] == given_version[1],
                    "Given major version (%s) does not match major code version (%s)" % (version, __version__))
138310
def _revs_equal(rev1, rev2, rev_type):
    '''
    
    '''
    if (rev1 is None and rev2 is not None) \
            or (rev2 is None and rev1 is not None):
        return False
    elif rev1 is rev2 is None:
        return True
    elif rev_type == 'sha1':
        return rev1.startswith(rev2)
    else:
        return rev1 == rev2
1249863
def equal(self, other, delta=0.0):
        
        if (other is None):
            return False
        if (self.uri != other.uri):
            return(False)
        if (self.timestamp is not None or other.timestamp is not None):
            # not equal if only one timestamp specified
            if (self.timestamp is None or
                    other.timestamp is None or
                    abs(self.timestamp - other.timestamp) >= delta):
                return(False)
        if ((self.md5 is not None and other.md5 is not None) and
                self.md5 != other.md5):
            return(False)
        if ((self.length is not None and other.length is not None) and
                self.length != other.length):
            return(False)
        return(True)
715084
def when_equal(self, key: Hashable, value: Any, **when_kwargs) -> StateWatcher:
        

        def _(snapshot):
            try:
                return snapshot[key] == value
            except KeyError:
                return False

        return self.when(_, **when_kwargs)
1105075
def hasoriginal(self,allowempty=False):
        """"""
        for e in self.select(Original,None,False, False):
            if not allowempty and len(e) == 0: continue
            return True
        return False