Pass through to provider SequenceRuleLookupSession.use_comparative_sequence_rule_view
11843
def use_comparative_sequence_rule_view(self):
        """"""
        self._object_views['sequence_rule'] = COMPARATIVE
        # self._get_provider_session('sequence_rule_lookup_session') # To make sure the session is tracked
        for session in self._get_provider_sessions():
            try:
                session.use_comparative_sequence_rule_view()
            except AttributeError:
                pass
1183594
def save_sequence_rule_enabler(self, sequence_rule_enabler_form, *args, **kwargs):
        """"""
        # Implemented from kitosid template for -
        # osid.resource.ResourceAdminSession.update_resource
        if sequence_rule_enabler_form.is_for_update():
            return self.update_sequence_rule_enabler(sequence_rule_enabler_form, *args, **kwargs)
        else:
            return self.create_sequence_rule_enabler(sequence_rule_enabler_form, *args, **kwargs)
859405
def get_sequence_rules_by_search(self, sequence_rule_query, sequence_rule_search):
        """"""
        # Implemented from azosid template for -
        # osid.resource.ResourceSearchSession.get_resources_by_search_template
        if not self._can('search'):
            raise PermissionDenied()
        return self._provider_session.get_sequence_rules_by_search(sequence_rule_query, sequence_rule_search)
1302241
def use_plenary_sequence_rule_view(self):
        """"""
        self._object_views['sequence_rule'] = PLENARY
        # self._get_provider_session('sequence_rule_lookup_session') # To make sure the session is tracked
        for session in self._get_provider_sessions():
            try:
                session.use_plenary_sequence_rule_view()
            except AttributeError:
                pass
208082
def _process_mrk_acc_view_for_equiv(self, limit):
        
        if self.test_mode:
            graph = self.testgraph
        else:
            graph = self.graph
        model = Model(graph)
        # pass through the file again,
        # and make the equivalence statements to a subset of the idspaces.
        # TODO verify the difference between what the
        # mrk_acc_view vs mrk_summary_view buys us here.
        # if nothing, then we should remove one or the other.
        LOG.info("mapping marker equivalent identifiers in mrk_acc_view")
        line_counter = 0
        with open('/'.join((self.rawdir, 'mrk_acc_view')), 'r') as f:
            f.readline()  # read the header row; skip
            for line in f:
                line = line.rstrip("\n")
                line_counter += 1
                (accid, prefix_part, logicaldb_key, object_key,
                 preferred, organism_key) = line.split('\t')

                if self.test_mode is True:
                    if int(object_key) not in self.test_keys.get('marker'):
                        continue

                # right now not caring about other organisms
                if organism_key != 1:
                    continue

                mgiid = self.idhash['marker'].get(object_key)
                if mgiid is None:
                    # presumably we've already added the relevant MGI ids,
                    # so skip those that we can't find
                    LOG.debug("can't find mgiid for %s", object_key)
                    continue
                marker_id = None
                if preferred == '1':  # TODO what does it mean if it's 0?
                    if logicaldb_key == '55':  # entrez/ncbi
                        marker_id = 'NCBIGene:' + accid
                    elif logicaldb_key == '1' and prefix_part != 'MGI:':
                        marker_id = accid
                    elif logicaldb_key == '60':
                        marker_id = 'ENSEMBL:'+accid
                    # TODO get non-preferred ids==deprecated?

                if marker_id is not None:
                    if mgiid in self.markers['classes']:
                        model.addClassToGraph(marker_id, None)
                        model.addEquivalentClass(mgiid, marker_id)
                    elif mgiid in self.markers['indiv']:
                        model.addIndividualToGraph(marker_id, None)
                        model.addSameIndividual(mgiid, marker_id)
                    else:
                        LOG.error("mgiid not in class or indiv hash %s", mgiid)

                if not self.test_mode and limit is not None and line_counter > limit:
                    break

        return
906304
private void processRule(final Rule<RI, RO> rule, final RI data) {
        // Get result handlers matching the rule
        final List<ResultHandler<RO>> mappedResultHandlers = rulesToResultHandlers.get(rule);
        if ((mappedResultHandlers == null) || mappedResultHandlers.isEmpty()) {
            LOGGER.warn("No matching result handler in mappable validator for rule: " + rule);
        } else {
            // Check rule
            final RO result = rule.validate(data);

            // Process result with all matching result handlers
            for (final ResultHandler<RO> resultHandler : mappedResultHandlers) {
                processResultHandler(resultHandler, result);
            }
        }
    }
797182
def use_comparative_agent_view(self):
        """"""
        self._object_views['agent'] = COMPARATIVE
        # self._get_provider_session('resource_agent_session') # To make sure the session is tracked
        for session in self._get_provider_sessions():
            try:
                session.use_comparative_agent_view()
            except AttributeError:
                pass
250029
public final void entryRuleFeatureCallID() throws RecognitionException {
        try {
            // InternalXbaseWithAnnotations.g:1334:1: ( ruleFeatureCallID EOF )
            // InternalXbaseWithAnnotations.g:1335:1: ruleFeatureCallID EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getFeatureCallIDRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleFeatureCallID();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getFeatureCallIDRule()); 
            }
            match(input,EOF,FOLLOW_2); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
1246290
public final void entryRuleXNumberLiteral() throws RecognitionException {
        try {
            // InternalXbase.g:1334:1: ( ruleXNumberLiteral EOF )
            // InternalXbase.g:1335:1: ruleXNumberLiteral EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getXNumberLiteralRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleXNumberLiteral();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getXNumberLiteralRule()); 
            }
            match(input,EOF,FOLLOW_2); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
10793
def use_comparative_bin_view(self):
        """"""
        self._bin_view = COMPARATIVE
        # self._get_provider_session('resource_bin_session') # To make sure the session is tracked
        for session in self._get_provider_sessions():
            try:
                session.use_comparative_bin_view()
            except AttributeError:
                pass
1358193
def use_comparative_asset_composition_view(self):
        """"""
        self._object_views['asset_composition'] = COMPARATIVE
        # self._get_provider_session('asset_composition_session') # To make sure the session is tracked
        for session in self._get_provider_sessions():
            try:
                session.use_comparative_asset_composition_view()
            except AttributeError:
                pass
243470
function CompareRuler (annoModel, rulerLocation, rulerOverview, rulerStyle) {
		mRulers.Ruler.call(this, annoModel, rulerLocation, rulerOverview, rulerStyle);
	}
437381
def use_comparative_relationship_view(self):
        """"""
        self._object_views['relationship'] = COMPARATIVE
        # self._get_provider_session('relationship_lookup_session') # To make sure the session is tracked
        for session in self._get_provider_sessions():
            try:
                session.use_comparative_relationship_view()
            except AttributeError:
                pass
674792
public static void enhanceRuleMetadata(RuleProvider provider, Rule rule)
    {
        if (rule instanceof Context)
        {
            Context context = (Context) rule;
            if (!context.containsKey(RuleMetadataType.ORIGIN))
                context.put(RuleMetadataType.ORIGIN, provider.getMetadata().getOrigin());
            if (!context.containsKey(RuleMetadataType.RULE_PROVIDER))
                context.put(RuleMetadataType.RULE_PROVIDER, provider);
            if (!context.containsKey(RuleMetadataType.TAGS))
                context.put(RuleMetadataType.TAGS, provider.getMetadata().getTags());
        }
    }
155741
def use_comparative_comment_view(self):
        """"""
        self._object_views['comment'] = COMPARATIVE
        # self._get_provider_session('comment_lookup_session') # To make sure the session is tracked
        for session in self._get_provider_sessions():
            try:
                session.use_comparative_comment_view()
            except AttributeError:
                pass
324529
function (sequenceIndex, requestType, data) {
		'use strict';
		var message = "Request #" + (sequenceIndex + 1) + " (" + requestType + ")";
		if (data.message) {
			message += ": " + data.message;
		}
		data.message = message;
		
		// the message has information that should be displayed by the test runner
		data.generatedMessage = false;
		
		data.name = "AssertionError";
		throw new AssertionError(message, data);
	}
780224
public final void entryRuleXMemberFeatureCall() throws RecognitionException {
        try {
            // InternalXbase.g:634:1: ( ruleXMemberFeatureCall EOF )
            // InternalXbase.g:635:1: ruleXMemberFeatureCall EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getXMemberFeatureCallRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleXMemberFeatureCall();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getXMemberFeatureCallRule()); 
            }
            match(input,EOF,FOLLOW_2); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }