Source

SCons / bench / is_types.py

Full commit
Steven Knight 340177d 






Greg Noel 05f3dfb 






Steven Knight 340177d 

Greg Noel 2395d93 







Steven Knight 340177d 






Greg Noel 05f3dfb 
Steven Knight 340177d 

Greg Noel 05f3dfb 
Steven Knight 340177d 
Greg Noel 2395d93 
Steven Knight 340177d 
Greg Noel 05f3dfb 
Steven Knight 340177d 

Greg Noel 05f3dfb 
Steven Knight 340177d 







Greg Noel 2395d93 

Steven Knight 340177d 

Greg Noel 2395d93 

Steven Knight 340177d 
Greg Noel 2395d93 
Steven Knight 340177d 
Greg Noel 2395d93 


Steven Knight 340177d 

Greg Noel 2395d93 

Steven Knight 340177d 







Greg Noel 2395d93 
Steven Knight 340177d 



Greg Noel 2395d93 
Steven Knight 340177d 

Greg Noel 2395d93 
Steven Knight 340177d 

Greg Noel 2395d93 

Steven Knight 340177d 



Greg Noel 2395d93 
Steven Knight 340177d 

















Greg Noel 2395d93 
Steven Knight 340177d 
















Greg Noel 2395d93 


Steven Knight 340177d 

Greg Noel 2395d93 
Steven Knight 340177d 



Greg Noel 2395d93 

Steven Knight 340177d 








Greg Noel 2395d93 
Steven Knight 340177d 

Greg Noel 2395d93 
Steven Knight 340177d 

Greg Noel 2395d93 
Steven Knight 340177d 

























































































Steven Knight aef7e82 
Steven Knight 340177d 






































Steven Knight 9aa3f9a 




# __COPYRIGHT__
#
# Benchmarks for testing various possible implementations
# of the is_Dict(), is_List() and is_String() functions in
# src/engine/SCons/Util.py.

import types
try:
    from collections import UserDict, UserList, UserString
except ImportError:
    # No 'collections' module or no UserFoo in collections
    exec('from UserDict import UserDict')
    exec('from UserList import UserList')
    exec('from UserString import UserString')

InstanceType = types.InstanceType
DictType = dict
ListType = list
StringType = str
try: unicode
except NameError:
    UnicodeType = None
else:
    UnicodeType = unicode


# The original implementations, pretty straightforward checks for the
# type of the object and whether it's an instance of the corresponding
# User* type.

def original_is_Dict(e):
    return isinstance(e, (dict,UserDict))

def original_is_List(e):
    return isinstance(e, (list,UserList))

if UnicodeType is not None:
    def original_is_String(e):
        return isinstance(e, (str,unicode,UserString))
else:
    def original_is_String(e):
        return isinstance(e, (str,UserString))



# New candidates that explicitly check for whether the object is an
# InstanceType before calling isinstance() on the corresponding User*
# type.

def checkInstanceType_is_Dict(e):
    return isinstance(e, dict) or \
           (isinstance(e, types.InstanceType) and isinstance(e, UserDict))

def checkInstanceType_is_List(e):
    return isinstance(e, list) \
        or (isinstance(e, types.InstanceType) and isinstance(e, UserList))

if UnicodeType is not None:
    def checkInstanceType_is_String(e):
        return isinstance(e, str) \
            or isinstance(e, unicode) \
            or (isinstance(e, types.InstanceType) and isinstance(e, UserString))
else:
    def checkInstanceType_is_String(e):
        return isinstance(e, str) \
            or (isinstance(e, types.InstanceType) and isinstance(e, UserString))



# Improved candidates that cache the type(e) result in a variable
# before doing any checks.

def cache_type_e_is_Dict(e):
    t = type(e)
    return t is dict or \
           (t is types.InstanceType and isinstance(e, UserDict))

def cache_type_e_is_List(e):
    t = type(e)
    return t is list \
        or (t is types.InstanceType and isinstance(e, UserList))

if UnicodeType is not None:
    def cache_type_e_is_String(e):
        t = type(e)
        return t is str \
            or t is unicode \
            or (t is types.InstanceType and isinstance(e, UserString))
else:
    def cache_type_e_is_String(e):
        t = type(e)
        return t is str \
            or (t is types.InstanceType and isinstance(e, UserString))



# Improved candidates that cache the type(e) result in a variable
# before doing any checks, but using the global names for
# DictType, ListType and StringType.

def global_cache_type_e_is_Dict(e):
    t = type(e)
    return t is DictType or \
           (t is InstanceType and isinstance(e, UserDict))

def global_cache_type_e_is_List(e):
    t = type(e)
    return t is ListType \
        or (t is InstanceType and isinstance(e, UserList))

if UnicodeType is not None:
    def global_cache_type_e_is_String(e):
        t = type(e)
        return t is StringType \
            or t is UnicodeType \
            or (t is InstanceType and isinstance(e, UserString))
else:
    def global_cache_type_e_is_String(e):
        t = type(e)
        return t is StringType \
            or (t is InstanceType and isinstance(e, UserString))



# Alternative that uses a myType() function to map the User* objects
# to their corresponding underlying types.

instanceTypeMap = {
    UserDict : dict,
    UserList : list,
    UserString : str,
}

if UnicodeType is not None:
    def myType(obj):
        t = type(obj)
        if t is types.InstanceType:
            t = instanceTypeMap.get(obj.__class__, t)
        elif t is unicode:
            t = str
        return t
else:
    def myType(obj):
        t = type(obj)
        if t is types.InstanceType:
            t = instanceTypeMap.get(obj.__class__, t)
        return t

def myType_is_Dict(e):
    return myType(e) is dict

def myType_is_List(e):
    return myType(e) is list

def myType_is_String(e):
    return myType(e) is str




def Func01(obj):
    """original_is_String"""
    for i in IterationList:
        original_is_String(obj)

def Func02(obj):
    """original_is_List"""
    for i in IterationList:
        original_is_List(obj)

def Func03(obj):
    """original_is_Dict"""
    for i in IterationList:
        original_is_Dict(obj)

def Func04(obj):
    """checkInstanceType_is_String"""
    for i in IterationList:
        checkInstanceType_is_String(obj)

def Func05(obj):
    """checkInstanceType_is_List"""
    for i in IterationList:
        checkInstanceType_is_List(obj)

def Func06(obj):
    """checkInstanceType_is_Dict"""
    for i in IterationList:
        checkInstanceType_is_Dict(obj)

def Func07(obj):
    """cache_type_e_is_String"""
    for i in IterationList:
        cache_type_e_is_String(obj)

def Func08(obj):
    """cache_type_e_is_List"""
    for i in IterationList:
        cache_type_e_is_List(obj)

def Func09(obj):
    """cache_type_e_is_Dict"""
    for i in IterationList:
        cache_type_e_is_Dict(obj)

def Func10(obj):
    """global_cache_type_e_is_String"""
    for i in IterationList:
        global_cache_type_e_is_String(obj)

def Func11(obj):
    """global_cache_type_e_is_List"""
    for i in IterationList:
        global_cache_type_e_is_List(obj)

def Func12(obj):
    """global_cache_type_e_is_Dict"""
    for i in IterationList:
        global_cache_type_e_is_Dict(obj)

#def Func13(obj):
#    """myType_is_String"""
#    for i in IterationList:
#        myType_is_String(obj)
#
#def Func14(obj):
#    """myType_is_List"""
#    for i in IterationList:
#        myType_is_List(obj)
#
#def Func15(obj):
#    """myType_is_Dict"""
#    for i in IterationList:
#        myType_is_Dict(obj)



# Data to pass to the functions on each run.  Each entry is a
# three-element tuple:
#
#   (
#       "Label to print describing this data run",
#       ('positional', 'arguments'),
#       {'keyword' : 'arguments'},
#   ),

class A(object):
    pass

Data = [
    (
        "String",
        ('',),
        {},
    ),
    (
        "List",
        ([],),
        {},
    ),
    (
        "Dict",
        ({},),
        {},
    ),
    (
        "UserString",
        (UserString(''),),
        {},
    ),
    (
        "UserList",
        (UserList([]),),
        {},
    ),
    (
        "UserDict",
        (UserDict({}),),
        {},
    ),
    (
        "Object",
        (A(),),
        {},
    ),
]

# Local Variables:
# tab-width:4
# indent-tabs-mode:nil
# End:
# vim: set expandtab tabstop=4 shiftwidth=4: