"""wrapper class containing necessary information to generate a RQL query

    from a sparql syntax tree

    """

        self.infer_types_info = []

        """return corresponding rql query"""

        """set/restrict possible types for the given variable.

        :return: True if something changed, else false.

        :raise: TypeResolverException if no more type allowed

        """

            ctypes = self.possible_types[var]

            nbctypes = len(ctypes)

            ctypes &= varpossibletypes

            if not ctypes:

            return len(ctypes) != nbctypes

            return True

    def infer_types(self):

        # XXX should use something similar to rql.analyze for proper type inference

        modified = True

        # loop to infer types until nothing changed

        while modified:

            modified = False

            for yams_predicates, subjvar, obj in self.infer_types_info:

                nbchoices = len(yams_predicates)

                # get possible types for the subject variable, according to the

                # current predicate

                svptypes = set(s for s, r, o in yams_predicates)

                if not '*' in svptypes:

                    if self.set_possible_types(subjvar, svptypes):

                        modified = True

                # restrict predicates according to allowed subject var types

                if subjvar in self.possible_types:

                    yams_predicates = [(s, r, o) for s, r, o in yams_predicates

                                       if s == '*' or s in self.possible_types[subjvar]]

                if isinstance(obj, ast.SparqlVar):

                    # make a valid rql var name

                    objvar = obj.name.upper()

                    # get possible types for the object variable, according to

                    # the current predicate

                    ovptypes = set(o for s, r, o in yams_predicates)

                    if not '*' in ovptypes:

                        if self.set_possible_types(objvar, ovptypes):

                            modified = True

                    # restrict predicates according to allowed object var types

                    if objvar in self.possible_types:

                        yams_predicates = [(s, r, o) for s, r, o in yams_predicates

                                           if o == '*' or o in self.possible_types[objvar]]

                # ensure this still make sense

                if not yams_predicates:

                    raise TypeResolverException()

                if len(yams_predicates) != nbchoices:

                    modified = True

        # now, for each predicate

        for yams_predicates, subjvar, obj in self.infer_types_info:

            rel = yams_predicates[0]

            objvar = obj.name.upper()

            # if there are several yams relation type equivalences, we will have

            # to generate several unioned rql queries

            for s, r, o in yams_predicates[1:]:

                if r != rel[1]:

                    self.union_params.append((yams_predicates, subjvar, objvar))

                    break

            else:

                # else we can simply add it to base rql restrictions

                self.restrictions.append('%s %s %s' % (subjvar, rel[1], objvar))

            # make a valid rql var name

            if predicate == ('', 'a'):

                # special 'is' relation

                # restrict possible types for the subject variable

                # 'regular' relation (eg not 'is')

                # list of 3-uple

                #   (yams etype (subject), yams rtype, yams etype (object))

                # where subject / object entity type may '*' if not specified

                yams_predicates = xy.yeq(':'.join(predicate))

                qi.infer_types_info.append((yams_predicates, subjvar, obj))

                    # make a valid rql var name

        qi.infer_types()