115         # method anymore (syt)

   115         # method anymore (syt)

   116         rset = ResultSet(self.rows+rset.rows, self.rql, self.args,

   116         rset = ResultSet(self.rows+rset.rows, self.rql, self.args,

   117                          self.description +rset.description)

   117                          self.description +rset.description)

   118         return self.req.decorate_rset(rset)

   118         return self.req.decorate_rset(rset)

   119 

   119 

   125         rset = ResultSet(rows, self.rql, self.args, descr)

   124         rset = ResultSet(rows, self.rql, self.args, descr)

   126         return self.req.decorate_rset(rset)

   125         return self.req.decorate_rset(rset)

   127 

   126 

   128     def transformed_rset(self, transformcb):

   127     def transformed_rset(self, transformcb):

   129         """ the result set according to a given column types

   128         """ the result set according to a given column types

   138         :param col: the column index

   137         :param col: the column index

   139 

   138 

   140         :rtype: `ResultSet`

   139         :rtype: `ResultSet`

   141         """

   140         """

   142         rows, descr = [], []

   141         rows, descr = [], []

   144         for row, desc in zip(self.rows, self.description):

   143         for row, desc in zip(self.rows, self.description):

   145             nrow, ndesc = transformcb(row, desc)

   144             nrow, ndesc = transformcb(row, desc)

   146             if ndesc: # transformcb returns None for ndesc to skip that row

   145             if ndesc: # transformcb returns None for ndesc to skip that row

   147                 rows.append(nrow)

   146                 rows.append(nrow)

   148                 descr.append(ndesc)

   147                 descr.append(ndesc)

   161         :param col: the column index

   160         :param col: the column index

   162 

   161 

   163         :rtype: `ResultSet`

   162         :rtype: `ResultSet`

   164         """

   163         """

   165         rows, descr = [], []

   164         rows, descr = [], []

   167         for i in xrange(len(self)):

   166         for i in xrange(len(self)):

   168             if not filtercb(self.get_entity(i, col)):

   167             if not filtercb(self.get_entity(i, col)):

   169                 continue

   168                 continue

   170             rows.append(self.rows[i])

   169             rows.append(self.rows[i])

   171             descr.append(self.description[i])

   170             descr.append(self.description[i])

   188         :param col: the column index. if col = -1, the whole row are used

   187         :param col: the column index. if col = -1, the whole row are used

   189 

   188 

   190         :rtype: `ResultSet`

   189         :rtype: `ResultSet`

   191         """

   190         """

   192         rows, descr = [], []

   191         rows, descr = [], []

   194         if col >= 0:

   193         if col >= 0:

   195             entities = sorted(enumerate(self.entities(col)),

   194             entities = sorted(enumerate(self.entities(col)),

   196                               key=lambda (i, e): keyfunc(e), reverse=reverse)

   195                               key=lambda (i, e): keyfunc(e), reverse=reverse)

   197         else:

   196         else:

   198             entities = sorted(enumerate(self),

   197             entities = sorted(enumerate(self),

   235             if keyfunc is not None:

   234             if keyfunc is not None:

   236                 key = keyfunc(key)

   235                 key = keyfunc(key)

   237 

   236 

   238             if key not in mapping:

   237             if key not in mapping:

   239                 rows, descr = [], []

   238                 rows, descr = [], []

   241                 mapping[key] = rset

   240                 mapping[key] = rset

   242                 result.append(rset)

   241                 result.append(rset)

   243             else:

   242             else:

   244                 rset = mapping[key]

   243                 rset = mapping[key]

   245             rset.rows.append(self.rows[idx])

   244             rset.rows.append(self.rows[idx])

   287                     if offset <= entity.row < stop:

   286                     if offset <= entity.row < stop:

   288                         entity.row = entity.row - offset

   287                         entity.row = entity.row - offset

   289                     else:

   288                     else:

   290                         self.req.drop_entity_cache(entity.eid)

   289                         self.req.drop_entity_cache(entity.eid)

   291         else:

   290         else:

   293             if not offset:

   292             if not offset:

   294                 # can copy built entity caches

   293                 # can copy built entity caches

   295                 copy_cache(rset, 'get_entity', self)

   294                 copy_cache(rset, 'get_entity', self)

   296         rset.limited = (limit, offset)

   295         rset.limited = (limit, offset)

   297         return rset

   296         return rset