def get_view(name=None, context=None, request=None):
    """Get a BrowserView object.

    :param name: [required] Name of the view.
    :type name: string
    :param context: [required] Context on which to get view.
    :type context: context object
    :param request: [required] Request on which to get view.
    :type request: request object
    :raises:
        :class:`~plone.api.exc.MissingParameterError`,
        :class:`~plone.api.exc.InvalidParameterError`
    :Example: :ref:`content_get_view_example`
    """

    try:
        return getMultiAdapter((context, request), name=name)
    except:
        # get a list of all views so we can display their names in the error
        # msg
        sm = getSiteManager()
        views = sm.adapters.lookupAll(
            required=(providedBy(context), providedBy(request)),
            provided=Interface,
        )
        views_names = [view[0] for view in views]

        raise InvalidParameterError(
            "Cannot find a view with name '{0}'.\n"
            "Available views are:\n"
            "{1}".format(name, '\n'.join(sorted(views_names)))
        )

 def test_marker_interface(self):
     """Test that Folder and Collection provides IVirtualGalleryEnabled
     marker interface.
     """
     from hexagonit.virtualgallery.browser.interfaces import IVirtualgalleryEnabled
     self.assertTrue(IVirtualgalleryEnabled in providedBy(self.portal.folder))
     self.assertTrue(IVirtualgalleryEnabled in providedBy(self.portal.collection))

    def update(self):
        request = self.request
        context = self.context

        self.view_name = view_name = request.GET.get('view', '')

        adapters = request.registry.adapters

        view_callable = adapters.lookup(
            (IViewClassifier, providedBy(request), providedBy(context)),
            IView, name=view_name, default=None)

        if not isinstance(view_callable, PyramidView):
            raise HTTPNotFound()

        view_renderer = None
        layout_renderer = None

        for r in view_callable.renderers:
            if isinstance(r, view.LayoutRenderer):
                layout_renderer = r
            if isinstance(r, view.ViewRenderer):
                view_renderer = r

        if layout_renderer is not None:
            self.layout = view.query_layout_chain(
                context, request, layout_renderer.layout)

        self.view = view_renderer
        self.action = view_callable.__config_action__
        self.info = view_callable.__config_action__.info

        if self.layout is None:
            raise HTTPNotFound()

    def __call__(self, *args):
        if len(args) == 1:
            ast=args[0]
            processer = p
        else:
            processer, ast = args
        # raise Exception()
        continuation = processer.continuation
        continuation['initialCallDepth'] += 1
        continuation['targetCallDepth'] = processer.callDepth

        callback = callccCallback(continuation, self)
        # processer.popStack([ast[0], callback])
        # processer.stackPointer-=1
        
        if Procedure in providedBy(ast[0]):
            processer.pushStack([[ast[0], callback]])
            r = processer.process([[ast[0], callback]], processer.cenv)
#            processer.popStack(r)
        elif Macro in providedBy(ast[0]):
            r = ast[0](processer, [callback])
            processer.pushStack(r)
            r = processer.process(r, processer.cenv)
            processer.popStack(r)
        else:
            r = ast[0](callback)
        return r

def diff(source, target, *interfaces):
    """Get a list of (field, changed, result) 3-tuples, for "diff-able" fields.
    """
    if not len(interfaces):
        interfaces = interface.providedBy(source)
    results = []
    for iface in interfaces:
        # the order is locked on the order returned by of interface.names()
        for name in iface.names():
            #!+VERSIONS(miano, 2 may 2012) something changed in the last couple
            # of weeks that makes removeSecurityPolicy below required yet
            # it wasn't before.
            field = removeSecurityProxy(iface[name])
            # only consider for diffing fields of this type
            #!+VERSIONS(miano, 2 May 2012) This was an isinstance check before.
            # switched it to check on interfaces.
            if set((schema.interfaces.IText, schema.interfaces.ITextLine,
                schema.interfaces.ISet)).isdisjoint(
                    set(interface.providedBy(field))):
                continue
            bound = field.bind(source)
            source_value = bound.query(source, field.default)
            target_value = bound.query(target, field.default)
            if source_value is None or target_value is None:
                continue
            hresult = htmldiff(source_value, target_value)
            results.append((field, bool(hresult!=source_value), hresult))
    return results

 def execute(self, clear=True):
     for event in self._events:
         handler = None
         if event.origin is not None:
             # 1. Lookup customization with the original field
             required = (providedBy(event.origin), event.interface)
             # 1.a Original field and name
             handler = self._origin.lookup(
                 required, Interface, event.field.identifier)
             if handler is None:
                 # 1.b Original field without name
                 handler = self._origin.lookup(required, Interface)
             if handler is not None:
                 handler(event.field)
         if handler is None:
             # 2. No customization found, lookup with the zeam.form field
             required = (providedBy(event.field), event.interface)
             # 2.a zeam.form field and name
             handler = self._field.lookup(
                 required, Interface, event.field.identifier)
             if handler is None:
                 # 2.b zeam.form field without name
                 handler = self._field.lookup(required, Interface)
             if handler is not None:
                 handler(event.field)
     if clear:
         del self._events[:]
     self._scheduled = False

def get_view(name=None, context=None, request=None):
    """Get a BrowserView object.

    :param name: [required] Name of the view.
    :type name: string
    :param context: [required] Context on which to get view.
    :type context: context object
    :param request: [required] Request on which to get view.
    :type request: request object
    :raises:
        :class:`~plone.api.exc.MissingParameterError`,
        :class:`~plone.api.exc.InvalidParameterError`
    :Example: :ref:`content_get_view_example`
    """
    # It happens sometimes that ACTUAL_URL is not set in tests. To be nice
    # and not throw strange errors, we set it to be the same as URL.
    # TODO: if/when we have api.env.test_mode() boolean in the future, use that
    config = getConfiguration()
    if config.dbtab.__module__ == "plone.testing.z2":
        request["ACTUAL_URL"] = request["URL"]

    try:
        return getMultiAdapter((context, request), name=name)
    except:
        # get a list of all views so we can display their names in the error
        # msg
        sm = getSiteManager()
        views = sm.adapters.lookupAll(required=(providedBy(context), providedBy(request)), provided=Interface)
        views_names = [view[0] for view in views]

        raise InvalidParameterError(
            "Cannot find a view with name '{0}'.\n"
            "Available views are:\n"
            "{1}".format(name, "\n".join(sorted(views_names)))
        )

    def test_backward_compat(self):

        class C1(object): __implemented__ = I1
        class C2(C1): __implemented__ = I2, I5
        class C3(C2): __implemented__ = I3, C2.__implemented__

        self.assert_(C3.__implemented__.__class__ is tuple)

        self.assertEqual(
            [i.getName() for i in providedBy(C3())],
            ['I3', 'I2', 'I5'],
            )

        class C4(C3):
            implements(I4)

        self.assertEqual(
            [i.getName() for i in providedBy(C4())],
            ['I4', 'I3', 'I2', 'I5'],
            )

        self.assertEqual(
            [i.getName() for i in C4.__implemented__],
            ['I4', 'I3', 'I2', 'I5'],
            )

        # Note that C3.__implemented__ should now be a sequence of interfaces
        self.assertEqual(
            [i.getName() for i in C3.__implemented__],
            ['I3', 'I2', 'I5'],
            )
        self.failIf(C3.__implemented__.__class__ is tuple)

    def test_directlyProvides(self):
        class IA1(Interface): pass
        class IA2(Interface): pass
        class IB(Interface): pass
        class IC(Interface): pass
        class A(Odd):
            pass
        classImplements(A, IA1, IA2)

        class B(Odd):
            pass
        classImplements(B, IB)

        class C(A, B):
            pass
        classImplements(C, IC)


        ob = C()
        directlyProvides(ob, I1, I2)
        self.assertTrue(I1 in providedBy(ob))
        self.assertTrue(I2 in providedBy(ob))
        self.assertTrue(IA1 in providedBy(ob))
        self.assertTrue(IA2 in providedBy(ob))
        self.assertTrue(IB in providedBy(ob))
        self.assertTrue(IC in providedBy(ob))

        directlyProvides(ob, directlyProvidedBy(ob)-I2)
        self.assertTrue(I1 in providedBy(ob))
        self.assertFalse(I2 in providedBy(ob))
        self.assertFalse(I2 in providedBy(ob))
        directlyProvides(ob, directlyProvidedBy(ob), I2)
        self.assertTrue(I2 in providedBy(ob))

    def getLayouts(self):
        context = self.context
        request = context.REQUEST

        if ICollageAlias.providedBy(self.context):
            target = self.context.get_target()
            if target is not None:
                context = target

        ifaces = mark_request(context, request)

        sm = getSiteManager()
        layouts = sm.adapters.lookupAll(
            required=(providedBy(context), providedBy(request)),
            provided=Interface
        )

        directlyProvides(request, *ifaces)
        layouts = [(name, getattr(layout, 'title', name))
                   for (name, layout) in layouts
                   if isinstance(layout, type) and
                   issubclass(layout, BrowserView) and
                   not getattr(layout, 'hide', False)]
        layouts.sort(lambda a, b: cmp(a[1], b[1]))
        return layouts

    def get_root(self, node):
        '''Get the root of the page-tree

        The root node is a node that provides the
        IGSContentManagerFolderMarker interface but does not have a
        parent that provides the IGSContentManagerFolderMarker
        interface.

        ARGUMENTS
          node  A node in the tree to start searching from.

        RETURNS
          The root node of the tree.

        SIDE EFFECTS
          None
        '''
        parent = node.aq_parent
        if (IGSContentManagerFolderMarker in providedBy(parent)):
            retval = self.get_root(parent)
        else:
            retval = node
        assert retval
        assert IGSContentManagerFolderMarker in providedBy(retval)
        return retval

def checkObject(container, name, object):
    """Check containement constraints for an object and container
    """

    # check __setitem__ precondition
    containerProvided = providedBy(container)
    __setitem__ = containerProvided.get("__setitem__")
    if __setitem__ is not None:
        precondition = __setitem__.queryTaggedValue("precondition")
        if precondition is not None:
            precondition(container, name, object)

    # check the constraint on __parent__
    __parent__ = providedBy(object).get("__parent__")
    if __parent__ is not None:
        try:
            validate = __parent__.validate
        except AttributeError:
            pass
        else:
            validate(container)

    if not containerProvided.extends(IContainer):
        # If it doesn't implement IContainer, it can't contain stuff.
        raise TypeError(_("Container is not a valid Zope container."))

    def get_tree(self, node):
        '''Get the tree below of the node

        ARGUMENTS
            A node in the tree.

        RETURNS
            A 2-tuple of (node, (children\ldots)). The node supports
            the IGSContentManagerFolderMarker interface.

        SIDE EFFECTS
            None
        '''
        assert IGSContentManagerFolderMarker in providedBy(node)

        objectValueTypes = ('Folder (Ordered)', 'Folder')
        childFolders = node.objectValues(objectValueTypes)
        children = [self.get_tree(c) for c in childFolders
                    if(IGSContentManagerFolderMarker in providedBy(c))]
        retval = (node, tuple(children))

        assert len(retval) == 2
        assert retval[0] == node
        assert IGSContentManagerFolderMarker in providedBy(retval[0])
        return retval

    def test_directlyProvides(self):
        class IA1(Interface): pass
        class IA2(Interface): pass
        class IB(Interface): pass
        class IC(Interface): pass
        class A(Odd):
            implements(IA1, IA2)

        class B(Odd):
            implements(IB)

        class C(A, B):
            implements(IC)


        ob = C()
        directlyProvides(ob, I1, I2)
        self.assert_(I1 in providedBy(ob))
        self.assert_(I2 in providedBy(ob))
        self.assert_(IA1 in providedBy(ob))
        self.assert_(IA2 in providedBy(ob))
        self.assert_(IB in providedBy(ob))
        self.assert_(IC in providedBy(ob))

        directlyProvides(ob, directlyProvidedBy(ob)-I2)
        self.assert_(I1 in providedBy(ob))
        self.failIf(I2 in providedBy(ob))
        self.failIf(I2 in providedBy(ob))
        directlyProvides(ob, directlyProvidedBy(ob), I2)
        self.assert_(I2 in providedBy(ob))

 def getAvailableLayouts(self):
     # Get the layouts registered for this object from its FTI.
     fti = self.getTypeInfo()
     if fti is None:
         return ()
     result = []
     method_ids = fti.getAvailableViewMethods(self)
     spec = (providedBy(self), providedBy(self.REQUEST))
     gsm = getSiteManager()
     for mid in method_ids:
         if not isinstance(mid, six.string_types):
             mid = mid.decode()
         factory = gsm.adapters.lookup(spec, Interface, mid)
         if factory is not None:
             menu = getUtility(
                 IBrowserMenu,
                 'plone_displayviews'
             )
             item = menu.getMenuItemByAction(self, self.REQUEST, mid)
             title = item and item.title or mid
             result.append((mid, title))
         else:
             method = getattr(self, mid, None)
             if method is not None:
                 # a method might be a template, script or method
                 try:
                     title = method.aq_inner.aq_explicit.title_or_id()
                 except AttributeError:
                     title = mid
                 result.append((mid, title))
     return result

    def test_builtins(self):
        # Setup

        intspec = implementedBy(int)
        olddeclared = intspec.declared

        classImplements(int, I1)
        class myint(int):
            implements(I2)

        x = 42
        self.assertEqual([i.getName() for i in providedBy(x)],
                         ['I1'])

        x = myint(42)
        directlyProvides(x, I3)
        self.assertEqual([i.getName() for i in providedBy(x)],
                         ['I3', 'I2', 'I1'])

        # cleanup
        intspec.declared = olddeclared
        classImplements(int)

        x = 42
        self.assertEqual([i.getName() for i in providedBy(x)],
                         [])

def get_view(name=None, context=None, request=None):
    """Get a BrowserView object.

    :param name: [required] Name of the view.
    :type name: string
    :param context: [required] Context on which to get view.
    :type context: context object
    :param request: [required] Request on which to get view.
    :type request: request object
    :raises:
        :class:`~plone.api.exc.MissingParameterError`,
        :class:`~plone.api.exc.InvalidParameterError`
    :Example: :ref:`content_get_view_example`
    """
    # We do not use exceptionhandling to detect if the requested view is
    # available, because the __init__ of said view will contain
    # errors in client code.

    # Get all available views...
    sm = getSiteManager()
    available_views = sm.adapters.lookupAll(
        required=(providedBy(context), providedBy(request)),
        provided=Interface,
    )
    # and get their names.
    available_view_names = [view[0] for view in available_views]

    # Raise an error if the requested view is not available.
    if name not in available_view_names:
        raise InvalidParameterError(
            "Cannot find a view with name '{0}'.\n"
            "Available views are:\n"
            "{1}".format(name, '\n'.join(sorted(available_view_names)))
        )
    return getMultiAdapter((context, request), name=name)

def _fixup_zope_interface():
    # Make sure the provided and implementedBy objects
    # can be iterated.
    # Note that we DO NOT use the _iteratorChecker, but instead
    # we use NoProxy to be sure that the results (of iteration or not) are not
    # proxied. On Python 2, these objects are builtin and don't go through the
    # checking process at all, much like BTrees, so NoProxy is necessary for
    # compatibility. On Python 3, prior to this, iteration was simply not allowed.
    from zope.interface import providedBy
    from zope.interface import alsoProvides

    class I1(Interface):
        pass

    class I2(Interface):
        pass

    @implementer(I1)
    class O(object):
        pass

    o = O()


    # This will be athe zope.interface.implementedBy from the class
    # a zope.interface.declarations.Implements
    _default_checkers[type(providedBy(o))] = NoProxy

    alsoProvides(o, I2)
    # This will be the zope.interface.Provides from the instance
    _default_checkers[type(providedBy(o))] = NoProxy

    def setUp(self):
        super(self.__class__, self).setUp()

        # load file content
        filedata = get_file_content('example.zip')

        # create an ATFile w/ the content
        self.loginAsPortalOwner()
        # self.portal.invokeFactory("File", 'archive')
        _createObjectByType("File", self.portal, id='archive')
        self.archive = archive = self.portal.archive

        # we should not have IArchiveFile
        self.assertTrue(IArchiveFile not in providedBy(archive))
        archive.setFile(filedata)

        # trigger modified event since we have a subscriber for that
        event = ObjectModifiedEvent(archive)
        notify(event)
        # now we must have IArchiveFile
        self.assertTrue(IArchiveFile in providedBy(archive))

        # look for a zip reader
        zipreader = component.queryAdapter(archive, IArchiveReader,
                                           name=archive.getContentType())
        self.failIf(zipreader is None)

        self.logout()

def render_view(name, context, request):
    adapters = config.registry.adapters

    view_callable = adapters.lookup(
        (IViewClassifier, providedBy(request), providedBy(context)),
        IView, name=name, default=None)

    return view_callable(context, request)