EmbeddedPkg: Extend NvVarStoreFormattedLib LIBRARY_CLASS

[mirror_edk2.git] / AppPkg / Applications / Python / Python-2.7.2 / Demo / metaclasses / Eiffel.py

"""Support Eiffel-style preconditions and postconditions.\r
\r
For example,\r
\r
class C:\r
    def m1(self, arg):\r
        require arg > 0\r
        return whatever\r
        ensure Result > arg\r
\r
can be written (clumsily, I agree) as:\r
\r
class C(Eiffel):\r
    def m1(self, arg):\r
        return whatever\r
    def m1_pre(self, arg):\r
        assert arg > 0\r
    def m1_post(self, Result, arg):\r
        assert Result > arg\r
\r
Pre- and post-conditions for a method, being implemented as methods\r
themselves, are inherited independently from the method.  This gives\r
much of the same effect of Eiffel, where pre- and post-conditions are\r
inherited when a method is overridden by a derived class.  However,\r
when a derived class in Python needs to extend a pre- or\r
post-condition, it must manually merge the base class' pre- or\r
post-condition with that defined in the derived class', for example:\r
\r
class D(C):\r
    def m1(self, arg):\r
        return arg**2\r
    def m1_post(self, Result, arg):\r
        C.m1_post(self, Result, arg)\r
        assert Result < 100\r
\r
This gives derived classes more freedom but also more responsibility\r
than in Eiffel, where the compiler automatically takes care of this.\r
\r
In Eiffel, pre-conditions combine using contravariance, meaning a\r
derived class can only make a pre-condition weaker; in Python, this is\r
up to the derived class.  For example, a derived class that takes away\r
the requirement that arg > 0 could write:\r
\r
    def m1_pre(self, arg):\r
        pass\r
\r
but one could equally write a derived class that makes a stronger\r
requirement:\r
\r
    def m1_pre(self, arg):\r
        require arg > 50\r
\r
It would be easy to modify the classes shown here so that pre- and\r
post-conditions can be disabled (separately, on a per-class basis).\r
\r
A different design would have the pre- or post-condition testing\r
functions return true for success and false for failure.  This would\r
make it possible to implement automatic combination of inherited\r
and new pre-/post-conditions.  All this is left as an exercise to the\r
reader.\r
\r
"""\r
\r
from Meta import MetaClass, MetaHelper, MetaMethodWrapper\r
\r
class EiffelMethodWrapper(MetaMethodWrapper):\r
\r
    def __init__(self, func, inst):\r
        MetaMethodWrapper.__init__(self, func, inst)\r
        # Note that the following causes recursive wrappers around\r
        # the pre-/post-condition testing methods.  These are harmless\r
        # but inefficient; to avoid them, the lookup must be done\r
        # using the class.\r
        try:\r
            self.pre = getattr(inst, self.__name__ + "_pre")\r
        except AttributeError:\r
            self.pre = None\r
        try:\r
            self.post = getattr(inst, self.__name__ + "_post")\r
        except AttributeError:\r
            self.post = None\r
\r
    def __call__(self, *args, **kw):\r
        if self.pre:\r
            apply(self.pre, args, kw)\r
        Result = apply(self.func, (self.inst,) + args, kw)\r
        if self.post:\r
            apply(self.post, (Result,) + args, kw)\r
        return Result\r
\r
class EiffelHelper(MetaHelper):\r
    __methodwrapper__ = EiffelMethodWrapper\r
\r
class EiffelMetaClass(MetaClass):\r
    __helper__ = EiffelHelper\r
\r
Eiffel = EiffelMetaClass('Eiffel', (), {})\r
\r
\r
def _test():\r
    class C(Eiffel):\r
        def m1(self, arg):\r
            return arg+1\r
        def m1_pre(self, arg):\r
            assert arg > 0, "precondition for m1 failed"\r
        def m1_post(self, Result, arg):\r
            assert Result > arg\r
    x = C()\r
    x.m1(12)\r
##    x.m1(-1)\r
\r
if __name__ == '__main__':\r
    _test()\r