ViewExecutable

Constructs a new ViewExecutable object.

Returns the identifier.

Saves the view.

Sets the arguments for the view.

Expands the list of used cache contexts for the view.

Sets the current page for the pager.

Gets the current page from the pager.

Gets the items per page from the pager.

Sets the items per page on the pager.

Gets the pager offset from the pager.

Sets the offset on the pager.

Determines if the view uses a pager.

Sets whether or not AJAX should be used.

If AJAX is used, paging, table sorting, and exposed filters will be fetched via an AJAX call rather than a page refresh.

Determines whether or not AJAX should be used.

Sets the exposed filters input to an array.

Figures out what the exposed input for this view is.

They will be taken from \Drupal::request()->query or from something previously set on the view.

Sets the display for this view and initializes the display handler.

Gets the first display that is accessible to the user.

Gets the current display plugin.

Sets the current display.

Creates a new display and a display handler instance for it.

Gets the current style plugin.

Finds and initializes the style plugin.

Note that arguments may have changed which style plugin we use, so check the view object first, then ask the display handler.

Acquires and attaches all of the handlers.

Gets the current pager plugin.

Initializes the pager.

Like style initialization, pager initialization is held until late to allow for overrides.

Renders the pager, if necessary.

Creates a list of base tables to be used by the view.

This is used primarily for the UI. The display must be already initialized.

Returns the entity type of the base table, if available.

Runs the preQuery() on all active handlers.

Runs the postExecute() on all active handlers.

Attaches the views handler for the specific type.

Builds all the arguments.

Gets the current query plugin.

Initializes the query object for the view.

Builds the query for the view.

Builds an individual set of handlers.

This is an internal method.

Some filter needs this function, even it is internal.

Executes the view's query.

Renders this view for a certain display.

Note: You should better use just the preview function if you want to render a view.

Gets the cache tags associated with the executed view.

Note: The cache plugin controls the used tags, so you can override it, if needed.

Builds the render array outline for the given display.

This render array has a #pre_render callback which will call ::executeDisplay in order to actually execute the view and then build the final render array structure.

Executes the given display, with the given arguments.

To be called externally by whatever mechanism invokes the view, such as a page callback, hook_block, etc.

This function should NOT be used by anything external as this returns data in the format specified by the display. It can also have other side effects that are only intended for the 'proper' use of the display, such as setting page titles.

If you simply want to view the display, use View::preview() instead.

Previews the given display, with the given arguments.

To be called externally, probably by an AJAX handler of some flavor. Can also be called when views are embedded, as this guarantees normalized output.

This function does not do any access checks on the view. It is the responsibility of the caller to check $view->access() or implement other access logic. To render the view normally with access checks, use views_embed_view() instead.

Runs attachments and lets the display do what it needs to before running.

Unsets the current view, mostly.

Runs attachment displays for the view.

Determines if the given user has access to the view.

Note that this sets the display handler if it hasn't been set.

Sets the used response object of the view.

Gets the response object used by the view.

Sets the request object.

Gets the request object.

Gets the view's current title.

This can change depending upon how it was built.

Overrides the view's current title.

The tokens in the title gets replaced before rendering.

Forces the view to build a title.

Determines whether you can link to the view or a particular display.

Some displays (e.g. block displays) do not have their own route, but may optionally provide a link to another display that does have a route.

Gets the URL for the current view.

This URL will be adjusted for arguments.

Gets the Url object associated with the display handler.

Gets the base path used for this view.

Gets the current user.

Views plugins can receive the current user in order to not need dependency injection.

Creates a duplicate ViewExecutable object.

Makes a copy of this view that has been sanitized of handlers, any runtime data, ID, and UUID.

Unsets references so that a $view object may be properly garbage collected.

Makes sure the view is completely valid.

Provides a list of views handler types used in a view.

This also provides some information about the views handler types.

Returns the valid types of plugins that can be used.

Adds an instance of a handler to the view.

Items may be fields, filters, sort criteria, or arguments.

Generates a unique ID for a handler instance.

These handler instances are typically fields, filters, sort criteria, or arguments.

Gets an array of handler instances for the current display.

Gets the configuration of a handler instance on a given display.

Sets the configuration of a handler instance on a given display.

Removes configuration for a handler instance on a given display.

Sets an option on a handler instance.

Use this only if you have just 1 or 2 options to set; if you have many, consider getting the handler instance, adding the options and using set_item() directly.

Enables admin links on the rendered view.

Returns whether admin links should be rendered on the view.

Merges all plugin default values for each display.

Provides a full array of possible theme functions to try for a given hook.

Determines if this view has form elements.

Gets dependencies for the view.

Magic method implementation to serialize the view executable.

Magic method implementation to unserialize the view executable.