root/MGET/Trunk/PythonPackage/src/GeoEco/DynamicDocString.py

# DynamicDocString.py - Provides the DynamicDocString class, which is used by
# classes in the GeoEco Python package to store metadata within the classes'
# __doc__ attributes.
#
# Copyright (C) 2007 Jason J. Roberts
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License (available in the file LICENSE.TXT)
# for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.

import types


class DynamicDocString(types.UnicodeType):

    def __init__(self, obj=None):
        self.Obj = obj

    def _GetObj(self):
        return self._Obj
    
    def _SetObj(self, value):
        self._Obj = value

    Obj = property(_GetObj, _SetObj)

    def __getattribute__(self, name):
        assert isinstance(name, basestring)
        if isinstance(name, types.StringType):
            name = unicode(name)
        if name == u'Obj' or name == u'_Obj' or name == u'_GetObj' or name == u'_SetObj' or name.startswith(u'__'):
            return object.__getattribute__(self, name)
        return getattr(unicode(self._Obj), name)

    # Python always calls __getattribute__ to obtain normal unicode functions
    # such as upper. This allows our __getattribute__ to expose these as if we
    # were a unicode ourself. But Python does NOT appear to call __getattribute__
    # to obtain "magic" functions such as __eq__ or __getslice__. So we can't
    # use __getattribute__ to forward these calls to unicode(self._Obj).__eq__,
    # unicode(self._Obj).__getslice__, and so on. We have to create our own versions
    # that just call through to unicode(self._Obj). This is unfortunate because if
    # new versions of Python add new magic methods, we have to add them here
    # if we wish to remain a perfect replication of types.UnicodeType.
    #
    # Note: This situation has has nothing to do with the fact that the if
    # statement preceding this comment includes the OR clause
    # "name.startswith(u'__')". That OR clause was added to prevent infinite
    # recusion that occurred when I discovered that __getattribute__ IS called
    # to obtain the __objclass__ attribute. Somehow Python treats this attribute
    # different than the others (such as __add__, __unicode__, etc).

    def __add__(self, other):
        return unicode(self._Obj).__add__(other)

    def __contains__(self, other):
        return unicode(self._Obj).__contains__(other)

    def __eq__(self, other):
        return unicode(self._Obj).__eq__(other)

    def __ge__(self, other):
        return unicode(self._Obj).__ge__(other)

    def __getitem__(self, key):
        return unicode(self._Obj).__getitem__(key)

    def __getnewargs__(self, *args):
        raise NotImplementedError, u'DynamicDocString does not currently support pickling.'

    def __getslice__(self, start, end):
        return unicode(self._Obj).__getslice__(start, end)

    def __gt__(self, other):
        return unicode(self._Obj).__gt__(other)

    def __hash__(self):
        raise NotImplementedError, u'DynamicDocString is not hashable because it is mutable. DynamicDocString cannot serve as a dictionary key.'

    def __le__(self, other):
        return unicode(self._Obj).__le__(other)

    def __len__(self):
        return unicode(self._Obj).__len__()

    def __lt__(self, other):
        return unicode(self._Obj).__lt__(other)

    def __mod__(self, other):
        return unicode(self._Obj).__mod__(other)

    def __mul__(self, other):
        return unicode(self._Obj).__mul__(other)

    def __ne__(self, other):
        return unicode(self._Obj).__ne__(other)

    def __reduce__(self):
        raise NotImplementedError, u'DynamicDocString does not currently support pickling.'

    def __reduce_ex__(self, protocol):
        raise NotImplementedError, u'DynamicDocString does not currently support pickling.'

    def __radd__(self, other):
        return other.__add__(unicode(self._Obj))        # types.UnicodeType does not define __radd__ but we cannot be concatenated with other strings unless we do.

    def __repr__(self):
        return unicode(self._Obj).__repr__()

    def __rmod__(self, other):
        return unicode(self._Obj).__rmod__(other)

    def __rmul__(self, other):
        return unicode(self._Obj).__rmul__(other)

    def __str__(self):
        return str(self._Obj)

    def __unicode__(self):
        return unicode(self._Obj)


###############################################################################
# Names exported by this module
###############################################################################

__all__ = ['DynamicDocString']