AbstractFilter
    
            
            in package
            
        
    
            
            implements
                            FilterInterface                    
    
    
        
            Abstract filter class
Tags
Interfaces, Classes and Traits
- FilterInterface
- Filter interface
Table of Contents
- $callable : CallableObject
- Filter callable
- $excludeByName : array<string|int, mixed>
- Exclude by name
- $excludeByType : array<string|int, mixed>
- Exclude by type
- __construct() : mixed
- Constructor
- filter() : mixed
- Filter value
- getCallable() : CallableObject
- Get callable
- getExcludeByName() : array<string|int, mixed>
- Get exclude by name
- getExcludeByType() : array<string|int, mixed>
- Get exclude by type
- getParams() : array<string|int, mixed>
- Get params
- hasCallable() : bool
- Has callable
- hasExcludeByName() : bool
- Has exclude by name
- hasExcludeByType() : bool
- Has exclude by type
- hasParams() : bool
- Has params
- setCallable() : AbstractFilter
- Set callable
- setExcludeByName() : AbstractFilter
- Set exclude by name
- setExcludeByType() : AbstractFilter
- Set exclude by type
- setParams() : AbstractFilter
- Set params
Properties
$callable
Filter callable
    protected
        CallableObject
    $callable
     = null
        
    
$excludeByName
Exclude by name
    protected
        array<string|int, mixed>
    $excludeByName
     = []
        
    
$excludeByType
Exclude by type
    protected
        array<string|int, mixed>
    $excludeByType
     = []
        
    
Methods
__construct()
Constructor
    public
                __construct(mixed $callable[, mixed $params = null ][, mixed $excludeByName = null ][, mixed $excludeByType = null ]) : mixed
        Instantiate the form filter object
Parameters
- $callable : mixed
- $params : mixed = null
- $excludeByName : mixed = null
- $excludeByType : mixed = null
Return values
mixed —filter()
Filter value
    public
                filter(mixed $value[, string $name = null ][, mixed $type = null ]) : mixed
        
        Parameters
- $value : mixed
- $name : string = null
- $type : mixed = null
Return values
mixed —getCallable()
Get callable
    public
                getCallable() : CallableObject
        
    
    
        Return values
CallableObject —getExcludeByName()
Get exclude by name
    public
                getExcludeByName() : array<string|int, mixed>
        
    
    
        Return values
array<string|int, mixed> —getExcludeByType()
Get exclude by type
    public
                getExcludeByType() : array<string|int, mixed>
        
    
    
        Return values
array<string|int, mixed> —getParams()
Get params
    public
                getParams() : array<string|int, mixed>
        
    
    
        Return values
array<string|int, mixed> —hasCallable()
Has callable
    public
                hasCallable() : bool
        
    
    
        Return values
bool —hasExcludeByName()
Has exclude by name
    public
                hasExcludeByName() : bool
        
    
    
        Return values
bool —hasExcludeByType()
Has exclude by type
    public
                hasExcludeByType() : bool
        
    
    
        Return values
bool —hasParams()
Has params
    public
                hasParams() : bool
        
    
    
        Return values
bool —setCallable()
Set callable
    public
                setCallable(mixed $callable) : AbstractFilter
        
        Parameters
- $callable : mixed
Return values
AbstractFilter —setExcludeByName()
Set exclude by name
    public
                setExcludeByName(mixed $excludeByName) : AbstractFilter
        
        Parameters
- $excludeByName : mixed
Return values
AbstractFilter —setExcludeByType()
Set exclude by type
    public
                setExcludeByType(mixed $excludeByType) : AbstractFilter
        
        Parameters
- $excludeByType : mixed
Return values
AbstractFilter —setParams()
Set params
    public
                setParams(mixed $params) : AbstractFilter
        
        Parameters
- $params : mixed