# Source code for past.types.olddict

    """
    A dict subclass for Python 3 that behaves like Python 2's dict

    Example use:

    >>> from past.builtins import dict
    >>> d1 = dict()    # instead of {} for an empty dict
    >>> d2 = dict(key1='value1', key2='value2')

    The keys, values and items methods now return lists on Python 3.x and there are
    methods for iterkeys, itervalues, iteritems, and viewkeys etc.

    >>> for d in (d1, d2):
    ...     assert isinstance(d.keys(), list)
    ...     assert isinstance(d.values(), list)
    ...     assert isinstance(d.items(), list)
    """

    import sys

    from past.utils import with_metaclass

    _builtin_dict = dict
    ver = sys.version_info[:2]

    class BaseOldDict(type):
        def __instancecheck__(cls, instance):
            return isinstance(instance, _builtin_dict)

    class olddict(with_metaclass(BaseOldDict, _builtin_dict)):
        """
        A backport of the Python 3 dict object to Py2
        """
        iterkeys = _builtin_dict.keys
        viewkeys = _builtin_dict.keys

        def keys(self):
            return list(super(olddict, self).keys())

        itervalues = _builtin_dict.values
        viewvalues = _builtin_dict.values

        def values(self):
            return list(super(olddict, self).values())

        iteritems = _builtin_dict.items
        viewitems = _builtin_dict.items

        def items(self):
            return list(super(olddict, self).items())

        def has_key(self, k):
            """
            D.has_key(k) -> True if D has a key k, else False
            """
            return k in self

        # def __new__(cls, *args, **kwargs):
        #     """
        #     dict() -> new empty dictionary
        #     dict(mapping) -> new dictionary initialized from a mapping object's
        #         (key, value) pairs
        #     dict(iterable) -> new dictionary initialized as if via:
        #         d = {}
        #         for k, v in iterable:
        #             d[k] = v
        #     dict(**kwargs) -> new dictionary initialized with the name=value pairs
        #         in the keyword argument list.  For example:  dict(one=1, two=2)

        #     """
        #
        #     if len(args) == 0:
        #         return super(olddict, cls).__new__(cls)
        #     # Was: elif isinstance(args[0], newbytes):
        #     # We use type() instead of the above because we're redefining
        #     # this to be True for all unicode string subclasses. Warning:
        #     # This may render newstr un-subclassable.
        #     elif type(args[0]) == olddict:
        #         return args[0]
        #     # elif isinstance(args[0], _builtin_dict):
        #     #     value = args[0]
        #     else:
        #         value = args[0]
        #     return super(olddict, cls).__new__(cls, value)

        def __native__(self):
            """
            Hook for the past.utils.native() function
            """
            return super(oldbytes, self)

    __all__ = ['olddict']