Ticket #198: ticket198-encoder-optimization.diff

File ticket198-encoder-optimization.diff, 7.0 KB (added by akaihola, 11 months ago)

two optimizations to the encoder, description below

  • tests/test_amf0.py

     
    1919from pyamf import amf0, util 
    2020from pyamf.tests.util import EncoderTester, DecoderTester 
    2121 
     22class Spam(object): 
     23    pass 
     24 
     25class DynamicSpam(pyamf.ASObject): 
     26    pass 
     27 
    2228class TypesTestCase(unittest.TestCase): 
    2329    """ 
    2430    Tests the type mappings. 
    … …  
    224230            ({'a': 'b'}, '\x03\x00\x01a\x02\x00\x01b\x00\x00\x09')]) 
    225231 
    226232    def test_force_amf3(self): 
    227         class Spam(object): 
    228             pass 
    229  
    230233        pyamf.register_class(Spam, 'spam.eggs', metadata=['amf3']) 
    231234 
    232235        x = Spam() 
    … …  
    238241        pyamf.unregister_class(Spam) 
    239242 
    240243    def test_typed_object(self): 
    241         class Spam(object): 
    242             pass 
    243  
    244244        pyamf.register_class(Spam, alias='org.pyamf.spam') 
    245245 
    246246        x = Spam() 
    … …  
    277277        self.assertEquals(self.buf.getvalue(), '\x11\x04\x01') 
    278278 
    279279    def test_anonymous(self): 
    280         class Spam(object): 
    281             pass 
    282  
    283280        pyamf.register_class(Spam) 
    284281 
    285282        x = Spam() 
    … …  
    292289        pyamf.unregister_class(Spam) 
    293290 
    294291    def test_dynamic(self): 
    295         class Spam(pyamf.ASObject): 
    296             pass 
    297292 
    298293        def attr_func(obj): 
    299             self.assertTrue(isinstance(obj, Spam)) 
     294            self.assertTrue(isinstance(obj, DynamicSpam)) 
    300295 
    301296            return ['hello'] 
    302297 
    303         x = Spam() 
     298        x = DynamicSpam() 
    304299 
    305300        x.foo = 'bar' 
    306301        x.hello = 'world' 
    307302 
    308         pyamf.register_class(Spam, attr_func=attr_func, metadata=['dynamic']) 
     303        pyamf.register_class(DynamicSpam, attr_func=attr_func, metadata=['dynamic']) 
    309304        self._run([(x, '\x03\x00\x05hello\x02\x00\x05world\x00\x00\t')]) 
    310         pyamf.unregister_class(Spam) 
     305        pyamf.unregister_class(DynamicSpam) 
    311306 
    312307        # try duplicate attributes 
    313         pyamf.register_class(Spam, attrs=['hello'], attr_func=attr_func, 
     308        pyamf.register_class(DynamicSpam, attrs=['hello'], attr_func=attr_func, 
    314309            metadata=['dynamic']) 
    315310        self._run([(x, '\x03\x00\x05hello\x02\x00\x05world\x00\x00\t')]) 
    316         pyamf.unregister_class(Spam) 
     311        pyamf.unregister_class(DynamicSpam) 
    317312 
    318         pyamf.register_class(Spam, attrs=['foo'], attr_func=attr_func, 
     313        pyamf.register_class(DynamicSpam, attrs=['foo'], attr_func=attr_func, 
    319314            metadata=['dynamic']) 
    320315        self._run([(x, '\x03\x00\x03foo\x02\x00\x03bar\x00\x05hello\x02\x00' 
    321316            '\x05world\x00\x00\t')]) 
    322         pyamf.unregister_class(Spam) 
     317        pyamf.unregister_class(DynamicSpam) 
    323318 
    324319        # and now typedobject 
    325         pyamf.register_class(Spam, 'x', attr_func=attr_func, 
     320        pyamf.register_class(DynamicSpam, 'x', attr_func=attr_func, 
    326321            metadata=['dynamic']) 
    327322        self._run([(x, 
    328323            '\x10\x00\x01x\x00\x05hello\x02\x00\x05world\x00\x00\t')]) 
    329         pyamf.unregister_class(Spam) 
     324        pyamf.unregister_class(DynamicSpam) 
    330325 
    331         pyamf.register_class(Spam, 'x', attrs=['hello'], attr_func=attr_func, 
     326        pyamf.register_class(DynamicSpam, 'x', attrs=['hello'], attr_func=attr_func, 
    332327            metadata=['dynamic']) 
    333328        self._run([(x, 
    334329            '\x10\x00\x01x\x00\x05hello\x02\x00\x05world\x00\x00\t')]) 
    335         pyamf.unregister_class(Spam) 
     330        pyamf.unregister_class(DynamicSpam) 
    336331 
    337         pyamf.register_class(Spam, 'x', attrs=['foo'], attr_func=attr_func, 
     332        pyamf.register_class(DynamicSpam, 'x', attrs=['foo'], attr_func=attr_func, 
    338333            metadata=['dynamic']) 
    339334        self._run([(x, '\x10\x00\x01x\x00\x03foo\x02\x00\x03bar\x00\x05hello' 
    340335            '\x02\x00\x05world\x00\x00\t')]) 
    341         pyamf.unregister_class(Spam) 
     336        pyamf.unregister_class(DynamicSpam) 
    342337 
    343338    def test_custom_type(self): 
    344339        def write_as_list(list_interface_obj): 
    … …  
    502497            ({'a': 'b'}, '\x03\x00\x01a\x02\x00\x01b\x00\x00\x09')]) 
    503498 
    504499    def test_registered_class(self): 
    505         class Spam(object): 
    506             pass 
    507  
    508500        try: 
    509501            del pyamf.CLASS_CACHE['org.pyamf.spam'] 
    510502        except KeyError: 

  • tests/test_amf3.py

     
    3232    def __writeamf__(self, output): 
    3333        pass 
    3434 
     35class Person: 
     36    pass 
     37 
    3538class TypesTestCase(unittest.TestCase): 
    3639    """ 
    3740    Tests the type mappings. 
    … …  
    507510        self.assertEquals(self.buf.getvalue(), '\t\x07\x01\x04\x01\x04\x02\x04\x03') 
    508511 
    509512    def test_old_style_classes(self): 
    510         class Person: 
    511             pass 
    512  
    513513        pyamf.register_class(Person, 'spam.eggs.Person') 
    514514 
    515515        u = Person() 

  • amf3.py

     
    2626""" 
    2727 
    2828import types, datetime, zlib 
     29from cPickle import dumps 
    2930 
    3031import pyamf 
    3132from pyamf import util 
    3233 
     34class ClassDefNums(dict): 
     35 
     36    class _Pickled(str): pass 
     37 
     38    def __setitem__(self, key, value): 
     39        try: 
     40            dict.__setitem__(self, key, value) 
     41        except TypeError: 
     42            dict.__setitem__(self, self._Pickled(dumps(key)), value) 
     43 
     44    def __getitem__(self, key): 
     45        try: 
     46            return dict.__getitem__(self, key) 
     47        except TypeError: 
     48            return dict.__getitem__(self, self._Pickled(dumps(key))) 
     49 
    3350class ASTypes: 
    3451    """ 
    3552    All AMF3 data types used in ActionScript 3.0. 
    … …  
    660677        self.strings = [] 
    661678        self.classes = [] 
    662679        self.class_defs = {} 
     680        self.class_def_nums = ClassDefNums() 
    663681        self.legacy_xml = [] 
    664682 
    665683    def getString(self, ref): 
    … …  
    748766                    class_def.__class__) 
    749767 
    750768        try: 
    751             return self.classes.index(class_def) 
    752         except ValueError: 
     769            return self.class_def_nums[class_def] 
     770        except KeyError: 
    753771            raise pyamf.ReferenceError("Reference for class %s not found" % 
    754772                class_def.__class__) 
    755773 
    … …  
    758776        Creates a reference to C{class_def}. 
    759777        """ 
    760778        try: 
    761             return self.classes.index(class_def) 
    762         except ValueError: 
     779            return self.class_def_nums[class_def] 
     780        except KeyError: 
     781            class_num = len(self.classes) 
    763782            self.classes.append(class_def) 
    764783            self.class_defs[class_def.__class__] = class_def 
     784            self.class_def_nums[class_def] = class_num 
    765785 
    766             return len(self.classes) - 1 
     786            return class_num 
    767787 
    768788    def getLegacyXML(self, ref): 
    769789        """ 
    … …  
    11611181        # Unsupported types go first 
    11621182        ((types.BuiltinFunctionType, types.BuiltinMethodType,), 
    11631183            "writeUnsupported"), 
    1164         ((lambda x: x == pyamf.Undefined,), "writeUndefined"), 
     1184        ((lambda x: x is pyamf.Undefined,), "writeUndefined"), 
    11651185        ((bool,), "writeBoolean"), 
    11661186        ((int,long), "writeInteger"), 
    11671187        ((float,), "writeNumber"),