def _get_generic_modification(self, mod_class):
        mod_type = modclass_to_modtype[mod_class]
        if issubclass(mod_class, RemoveModification):
            mod_gain_const = mcct.LOSS
            mod_type = modtype_to_inverse[mod_type]
        else:
            mod_gain_const = mcct.GAIN
        mod_filter = mod_type[:5]
        p = BiopaxProcessor._construct_modification_pattern()
        p.add(mcc(mod_gain_const, mod_filter),
                  "input simple PE", "output simple PE")
        s = _bpp('Searcher')
        res = s.searchPlain(self.model, p)
        res_array = [_match_to_array(m) for m in res.toArray()]
        stmts = []
        for r in res_array:
            controller_pe = r[p.indexOf('controller PE')]
            input_pe = r[p.indexOf('input PE')]
            input_spe = r[p.indexOf('input simple PE')]
            output_spe = r[p.indexOf('output simple PE')]
            reaction = r[p.indexOf('Conversion')]
            control = r[p.indexOf('Control')]
            if not _is_catalysis(control):
                continue
            cat_dir = control.getCatalysisDirection()
            if cat_dir is not None and cat_dir.name() != 'LEFT_TO_RIGHT':
                logger.debug('Unexpected catalysis direction: %s.' % \
                    control.getCatalysisDirection())
                continue
            enzs = BiopaxProcessor._get_primary_controller(controller_pe)
            if not enzs:
                continue
            '''
            if _is_complex(input_pe):
                sub_members_in = self._get_complex_members(input_pe)
                sub_members_out = self._get_complex_members(output_pe)
                logger.info('Cannot handle complex substrates.')
                continue
            '''
            subs = BiopaxProcessor._get_agents_from_entity(input_spe,
                                                           expand_pe=False)
            ev = self._get_evidence(control)
            for enz, sub in itertools.product(_listify(enzs), _listify(subs)):
                mod_in = \
                    BiopaxProcessor._get_entity_mods(input_spe)
                mod_out = \
                    BiopaxProcessor._get_entity_mods(output_spe)
                sub.mods = _get_mod_intersection(mod_in, mod_out)
                if issubclass(mod_class, AddModification):
                    gained_mods = _get_mod_difference(mod_out, mod_in)
                else:
                    gained_mods = _get_mod_difference(mod_in, mod_out)
                for mod in gained_mods:
                    if mod.mod_type not in (mod_type,
                                            modtype_to_inverse[mod_type]):
                        continue
                    stmt = mod_class(enz, sub, mod.residue, mod.position,
                                     evidence=ev)
                    stmts.append(decode_obj(stmt, encoding='utf-8'))
        return stmts