path: root/bench/is_types.py

# __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: