Example #1
0
def translete_congr(_segment, _obj1, _obj2):
    
    # check if it have relation
    session = core.Kernel.session()
    
    res = sc_utils.searchPairsBinaryNoOrient(session, _obj1._getScAddr(), _obj2._getScAddr(), sc.SC_CONST)

    if res is not None:
        for result in res:
            if sc_utils.checkIncToSets(session, result[2], [geom_keynodes.Relation.nrel_congr], sc.SC_A_CONST | sc.SC_POS | sc.SC_PERMANENT):
                return
    
    # create new relation
    a = sc_utils.createPairBinaryNoOrient(session, _segment, _obj1._getScAddr(), _obj2._getScAddr(), sc.SC_CONST)
    sc_utils.createPairPosPerm(session, _segment, geom_keynodes.Relation.nrel_congr, a, sc.SC_CONST)
    
    return
Example #2
0
def translete_congr(_segment, _obj1, _obj2):

    # check if it have relation
    session = core.Kernel.session()

    res = sc_utils.searchPairsBinaryNoOrient(session, _obj1._getScAddr(),
                                             _obj2._getScAddr(), sc.SC_CONST)

    if res is not None:
        for result in res:
            if sc_utils.checkIncToSets(
                    session, result[2], [geom_keynodes.Relation.nrel_congr],
                    sc.SC_A_CONST | sc.SC_POS | sc.SC_PERMANENT):
                return

    # create new relation
    a = sc_utils.createPairBinaryNoOrient(session,
                                          _segment, _obj1._getScAddr(),
                                          _obj2._getScAddr(), sc.SC_CONST)
    sc_utils.createPairPosPerm(session, _segment,
                               geom_keynodes.Relation.nrel_congr, a,
                               sc.SC_CONST)

    return
Example #3
0
    def expression(self, ):

        node = None

        a = None

        b = None


        try:
            try:
                # logic_gram.g:23:2: (a= atom ( '^' | '&' | ( '->' | '<-' ) | '<->' ) b= atom )
                # logic_gram.g:23:3: a= atom ( '^' | '&' | ( '->' | '<-' ) | '<->' ) b= atom
                pass 
                #action start
                   
                revers=None
                relation=None
                	
                #action end
                self._state.following.append(self.FOLLOW_atom_in_expression49)
                a = self.atom()

                self._state.following.pop()
                # logic_gram.g:26:10: ( '^' | '&' | ( '->' | '<-' ) | '<->' )
                alt2 = 4
                LA2 = self.input.LA(1)
                if LA2 == 6:
                    alt2 = 1
                elif LA2 == 7:
                    alt2 = 2
                elif LA2 == 8 or LA2 == 9:
                    alt2 = 3
                elif LA2 == 10:
                    alt2 = 4
                else:
                    nvae = NoViableAltException("", 2, 0, self.input)

                    raise nvae

                if alt2 == 1:
                    # logic_gram.g:26:11: '^'
                    pass 
                    self.match(self.input, 6, self.FOLLOW_6_in_expression52)
                    #action start
                    relation=logic_keynodes.Relation.nrel_disjunction
                    #action end


                elif alt2 == 2:
                    # logic_gram.g:27:3: '&'
                    pass 
                    self.match(self.input, 7, self.FOLLOW_7_in_expression57)
                    #action start
                    relation=logic_keynodes.Relation.nrel_conjunction
                    #action end


                elif alt2 == 3:
                    # logic_gram.g:28:3: ( '->' | '<-' )
                    pass 
                    # logic_gram.g:28:3: ( '->' | '<-' )
                    alt1 = 2
                    LA1_0 = self.input.LA(1)

                    if (LA1_0 == 8) :
                        alt1 = 1
                    elif (LA1_0 == 9) :
                        alt1 = 2
                    else:
                        nvae = NoViableAltException("", 1, 0, self.input)

                        raise nvae

                    if alt1 == 1:
                        # logic_gram.g:28:4: '->'
                        pass 
                        self.match(self.input, 8, self.FOLLOW_8_in_expression64)


                    elif alt1 == 2:
                        # logic_gram.g:28:9: '<-'
                        pass 
                        self.match(self.input, 9, self.FOLLOW_9_in_expression66)
                        #action start
                        revers=True
                        #action end



                    #action start
                    relation=logic_keynodes.Relation.nrel_implication
                    #action end


                elif alt2 == 4:
                    # logic_gram.g:29:3: '<->'
                    pass 
                    self.match(self.input, 10, self.FOLLOW_10_in_expression75)
                    #action start
                    relation=logic_keynodes.Relation.nrel_equivalence
                    #action end



                self._state.following.append(self.FOLLOW_atom_in_expression84)
                b = self.atom()

                self._state.following.pop()
                #action start
                  
                if relation==logic_keynodes.Relation.nrel_implication:
                	if revers:
                		a,b=b,a
                	node=sc_utils.createPairBinaryOrient(self.session, self.segment, a ,b, sc.SC_CONST)
                else:
                	node=sc_utils.createPairBinaryNoOrient(self.session, self.segment, a ,b, sc.SC_CONST)
                self.nodeList.append(node)
                self.nodeList.append(sc_utils.createPairPosPerm(self.session, self.segment,relation, node, sc.SC_CONST))
                	
                #action end




            except RecognitionException, re:
                self.reportError(re)
                self.recover(self.input, re)
        finally:

            pass
        return node