| select_helpers {gtsummary} | R Documentation |
Set of functions to supplement the tidyselect set of functions for selecting columns of data frames (and other items as well).
all_continuous()
selects continuous variables
all_continuous2()
selects only type "continuous2"
all_categorical()
selects categorical (including "dichotomous"
) variables
all_dichotomous()
selects only type "dichotomous"
all_tests()
selects variables by the name of the test performed
all_stat_cols()
selects columns from tbl_summary
/tbl_svysummary
object with summary statistics (i.e. "stat_0"
, "stat_1"
, "stat_2"
, etc.)
all_interaction()
selects interaction terms from a regression model
all_intercepts()
selects intercept terms from a regression model
all_contrasts()
selects variables in regression model based on their type of contrast
all_continuous(continuous2 = TRUE) all_continuous2() all_categorical(dichotomous = TRUE) all_dichotomous() all_tests(tests = NULL) all_stat_cols(stat_0 = TRUE) all_interaction() all_intercepts() all_contrasts(contrasts_type = NULL)
continuous2 |
Logical indicating whether to include continuous2 variables. Default is |
dichotomous |
Logical indicating whether to include dichotomous variables.
Default is |
tests |
string indicating the test type of the variables to select, e.g.
select all variables being compared with |
stat_0 |
When |
contrasts_type |
type of contrast to select. When |
A character vector of column names selected
Example 1
select_ex1 <- trial %>% select(age, response, grade) %>% tbl_summary( statistic = all_continuous() ~ "{mean} ({sd})", type = all_dichotomous() ~ "categorical" )


| Up | TOC | Index | |||||
| << 7 Included Tools | < 8.35 Scientific Notation Parsing | Up: 8 API Reference | 8.37 Common Internet Routines > | 9 Release Notes >> |
8.36 Core Sockets
8.36.1 Error Information
<IP_ADDRESS> error_code
include std/socket.e namespace sockets public function error_code()
gets the error code.
Returns:
Integer OK on no error, otherwise any one of the ERR_ constants to follow.
<IP_ADDRESS> OK
include std/socket.e namespace sockets public constant OK
No error occurred.
<IP_ADDRESS> ERR_ACCESS
include std/socket.e namespace sockets public constant ERR_ACCESS
Permission has been denied. This can happen when using a send_to call on a broadcast address without setting the socket option SO_BROADCAST. Another, possibly more common, reason is you have tried to bind an address that is already exclusively bound by another application.
May occur on a Unix Domain Socket when the socket directory or file could not be accessed due to security.
<IP_ADDRESS> ERR_ADDRINUSE
include std/socket.e namespace sockets public constant ERR_ADDRINUSE
Address is already in use.
<IP_ADDRESS> ERR_ADDRNOTAVAIL
include std/socket.e namespace sockets public constant ERR_ADDRNOTAVAIL
The specified address is not a valid local IP address on this computer.
<IP_ADDRESS> ERR_AFNOSUPPORT
include std/socket.e namespace sockets public constant ERR_AFNOSUPPORT
Address family not supported by the protocol family.
<IP_ADDRESS> ERR_AGAIN
include std/socket.e namespace sockets public constant ERR_AGAIN
Kernel resources to complete the request are temporarly unavailable.
<IP_ADDRESS> ERR_ALREADY
include std/socket.e namespace sockets public constant ERR_ALREADY
Operation is already in progress.
<IP_ADDRESS> ERR_CONNABORTED
include std/socket.e namespace sockets public constant ERR_CONNABORTED
Software has caused a connection to be aborted.
<IP_ADDRESS> ERR_CONNREFUSED
include std/socket.e namespace sockets public constant ERR_CONNREFUSED
Connection was refused.
<IP_ADDRESS> ERR_CONNRESET
include std/socket.e namespace sockets public constant ERR_CONNRESET
An incomming connection was supplied however it was terminated by the remote peer.
<IP_ADDRESS> ERR_DESTADDRREQ
include std/socket.e namespace sockets public constant ERR_DESTADDRREQ
Destination address required.
<IP_ADDRESS> ERR_FAULT
include std/socket.e namespace sockets public constant ERR_FAULT
Address creation has failed internally.
<IP_ADDRESS> ERR_HOSTUNREACH
include std/socket.e namespace sockets public constant ERR_HOSTUNREACH
No route to the host specified could be found.
<IP_ADDRESS> ERR_INPROGRESS
include std/socket.e namespace sockets public constant ERR_INPROGRESS
A blocking call is inprogress.
<IP_ADDRESS> ERR_INTR
include std/socket.e namespace sockets public constant ERR_INTR
A blocking call was cancelled or interrupted.
<IP_ADDRESS> ERR_INVAL
include std/socket.e namespace sockets public constant ERR_INVAL
An invalid sequence of command calls were made, for instance trying to accept before an actual listen was called.
<IP_ADDRESS> ERR_IO
include std/socket.e namespace sockets public constant ERR_IO
An I/O error occurred while making the directory entry or allocating the inode. (Unix Domain Socket).
<IP_ADDRESS> ERR_ISCONN
include std/socket.e namespace sockets public constant ERR_ISCONN
Socket is already connected.
<IP_ADDRESS> ERR_ISDIR
include std/socket.e namespace sockets public constant ERR_ISDIR
An empty pathname was specified. (Unix Domain Socket).
<IP_ADDRESS> ERR_LOOP
include std/socket.e namespace sockets public constant ERR_LOOP
Too many symbolic links were encountered. (Unix Domain Socket).
<IP_ADDRESS> ERR_MFILE
include std/socket.e namespace sockets public constant ERR_MFILE
The queue is not empty upon routine call.
<IP_ADDRESS> ERR_MSGSIZE
include std/socket.e namespace sockets public constant ERR_MSGSIZE
Message is too long for buffer size. This would indicate an internal error to Euphoria as Euphoria sets a dynamic buffer size.
<IP_ADDRESS> ERR_NAMETOOLONG
include std/socket.e namespace sockets public constant ERR_NAMETOOLONG
Component of the path name exceeded 255 characters or the entire path exceeded 1023 characters. (Unix Domain Socket).
<IP_ADDRESS> ERR_NETDOWN
include std/socket.e namespace sockets public constant ERR_NETDOWN
The network subsystem is down or has failed
<IP_ADDRESS> ERR_NETRESET
include std/socket.e namespace sockets public constant ERR_NETRESET
Network has dropped it's connection on reset.
<IP_ADDRESS> ERR_NETUNREACH
include std/socket.e namespace sockets public constant ERR_NETUNREACH
Network is unreachable.
<IP_ADDRESS> ERR_NFILE
include std/socket.e namespace sockets public constant ERR_NFILE
Not a file. (Unix Domain Sockets).
<IP_ADDRESS> ERR_NOBUFS
include std/socket.e namespace sockets public constant ERR_NOBUFS
No buffer space is available.
<IP_ADDRESS> ERR_NOENT
include std/socket.e namespace sockets public constant ERR_NOENT
Named socket does not exist. (Unix Domain Socket).
<IP_ADDRESS> ERR_NOTCONN
include std/socket.e namespace sockets public constant ERR_NOTCONN
Socket is not connected.
<IP_ADDRESS> ERR_NOTDIR
include std/socket.e namespace sockets public constant ERR_NOTDIR
Component of the path prefix is not a directory. (Unix Domain Socket).
<IP_ADDRESS> ERR_NOTINITIALISED
include std/socket.e namespace sockets public constant ERR_NOTINITIALISED
Socket system is not initialized (Windows only)
<IP_ADDRESS> ERR_NOTSOCK
include std/socket.e namespace sockets public constant ERR_NOTSOCK
The descriptor is not a socket.
<IP_ADDRESS> ERR_OPNOTSUPP
include std/socket.e namespace sockets public constant ERR_OPNOTSUPP
Operation is not supported on this type of socket.
<IP_ADDRESS> ERR_PROTONOSUPPORT
include std/socket.e namespace sockets public constant ERR_PROTONOSUPPORT
Protocol not supported.
<IP_ADDRESS> ERR_PROTOTYPE
include std/socket.e namespace sockets public constant ERR_PROTOTYPE
Protocol is the wrong type for the socket.
<IP_ADDRESS> ERR_ROFS
include std/socket.e namespace sockets public constant ERR_ROFS
The name would reside on a read-only file system. (Unix Domain Socket).
<IP_ADDRESS> ERR_SHUTDOWN
include std/socket.e namespace sockets public constant ERR_SHUTDOWN
The socket has been shutdown. Possibly a send/receive call after a shutdown took place.
<IP_ADDRESS> ERR_SOCKTNOSUPPORT
include std/socket.e namespace sockets public constant ERR_SOCKTNOSUPPORT
Socket type is not supported.
<IP_ADDRESS> ERR_TIMEDOUT
include std/socket.e namespace sockets public constant ERR_TIMEDOUT
Connection has timed out.
<IP_ADDRESS> ERR_WOULDBLOCK
include std/socket.e namespace sockets public constant ERR_WOULDBLOCK
The operation would block on a socket marked as non-blocking.
8.36.2 Socket Backend Constants
These values are used by the Euphoria backend to pass information to this library. The TYPE constants are used to identify to the info function which family of constants are being retrieved (AF protocols, socket types, and socket options, respectively).
<IP_ADDRESS> ESOCK_UNDEFINED_VALUE
include std/socket.e namespace sockets public constant ESOCK_UNDEFINED_VALUE
when a particular constant was not defined by C,the backend returns this value
<IP_ADDRESS> ESOCK_UNKNOWN_FLAG
include std/socket.e namespace sockets public constant ESOCK_UNKNOWN_FLAG
if the backend doesn't recognize the flag in question
<IP_ADDRESS> ESOCK_TYPE_AF
include std/socket.e namespace sockets public constant ESOCK_TYPE_AF
<IP_ADDRESS> ESOCK_TYPE_TYPE
include std/socket.e namespace sockets public constant ESOCK_TYPE_TYPE
<IP_ADDRESS> ESOCK_TYPE_OPTION
include std/socket.e namespace sockets public constant ESOCK_TYPE_OPTION
8.36.3 Socket Type Euphoria Constants
These values are used to retrieve the known values for family and sock_type parameters of the create function from the Euphoria backend. (The reason for doing it this way is to retrieve the values defined in C, instead of duplicating them here.) These constants are guarranteed to never change, and to be the same value across platforms.
<IP_ADDRESS> EAF_UNSPEC
include std/socket.e namespace sockets public constant EAF_UNSPEC
Address family is unspecified
<IP_ADDRESS> EAF_UNIX
include std/socket.e namespace sockets public constant EAF_UNIX
Local communications
<IP_ADDRESS> EAF_INET
include std/socket.e namespace sockets public constant EAF_INET
IPv4 Internet protocols
<IP_ADDRESS> EAF_INET6
include std/socket.e namespace sockets public constant EAF_INET6
IPv6 Internet protocols
<IP_ADDRESS> EAF_APPLETALK
include std/socket.e namespace sockets public constant EAF_APPLETALK
Appletalk
<IP_ADDRESS> EAF_BTH
include std/socket.e namespace sockets public constant EAF_BTH
Bluetooth (currently Windows-only)
<IP_ADDRESS> ESOCK_STREAM
include std/socket.e namespace sockets public constant ESOCK_STREAM
Provides sequenced, reliable, two-way, connection-based byte streams. An out-of-band data transmission mechanism may be supported.
<IP_ADDRESS> ESOCK_DGRAM
include std/socket.e namespace sockets public constant ESOCK_DGRAM
Supports datagrams (connectionless, unreliable messages of a fixed maximum length).
<IP_ADDRESS> ESOCK_RAW
include std/socket.e namespace sockets public constant ESOCK_RAW
Provides raw network protocol access.
<IP_ADDRESS> ESOCK_RDM
include std/socket.e namespace sockets public constant ESOCK_RDM
Provides a reliable datagram layer that does not guarantee ordering.
<IP_ADDRESS> ESOCK_SEQPACKET
include std/socket.e namespace sockets public constant ESOCK_SEQPACKET
Obsolete and should not be used in new programs
8.36.4 Socket Type Constants
These values are passed as the family and sock_type parameters of the create function. They are OS-dependent.
<IP_ADDRESS> AF_UNSPEC
include std/socket.e namespace sockets public constant AF_UNSPEC
Address family is unspecified
<IP_ADDRESS> AF_UNIX
include std/socket.e namespace sockets public constant AF_UNIX
Local communications
<IP_ADDRESS> AF_INET
include std/socket.e namespace sockets public constant AF_INET
IPv4 Internet protocols
<IP_ADDRESS> AF_INET6
include std/socket.e namespace sockets public constant AF_INET6
IPv6 Internet protocols
<IP_ADDRESS> AF_APPLETALK
include std/socket.e namespace sockets public constant AF_APPLETALK
Appletalk
<IP_ADDRESS> AF_BTH
include std/socket.e namespace sockets public constant AF_BTH
Bluetooth (currently Windows-only)
<IP_ADDRESS> SOCK_STREAM
include std/socket.e namespace sockets public constant SOCK_STREAM
Provides sequenced, reliable, two-way, connection-based byte streams. An out-of-band data transmission mechanism may be supported.
<IP_ADDRESS> SOCK_DGRAM
include std/socket.e namespace sockets public constant SOCK_DGRAM
Supports datagrams (connectionless, unreliable messages of a fixed maximum length).
<IP_ADDRESS> SOCK_RAW
include std/socket.e namespace sockets public constant SOCK_RAW
Provides raw network protocol access.
<IP_ADDRESS> SOCK_RDM
include std/socket.e namespace sockets public constant SOCK_RDM
Provides a reliable datagram layer that does not guarantee ordering.
<IP_ADDRESS> SOCK_SEQPACKET
include std/socket.e namespace sockets public constant SOCK_SEQPACKET
Obsolete and should not be used in new programs
8.36.5 Select Accessor Constants
Use with the result of select.
<IP_ADDRESS> SELECT_SOCKET
include std/socket.e namespace sockets public enum SELECT_SOCKET
The socket
<IP_ADDRESS> SELECT_IS_READABLE
include std/socket.e namespace sockets public enum SELECT_IS_READABLE
Boolean (1/0) value indicating the readability.
<IP_ADDRESS> SELECT_IS_WRITABLE
include std/socket.e namespace sockets public enum SELECT_IS_WRITABLE
Boolean (1/0) value indicating the writeability.
<IP_ADDRESS> SELECT_IS_ERROR
include std/socket.e namespace sockets public enum SELECT_IS_ERROR
Boolean (1/0) value indicating the error state.
8.36.6 Shutdown Options
Pass one of the following to the method parameter of shutdown.
<IP_ADDRESS> SD_SEND
include std/socket.e namespace sockets public constant SD_SEND
Shutdown the send operations.
<IP_ADDRESS> SD_RECEIVE
include std/socket.e namespace sockets public constant SD_RECEIVE
Shutdown the receive operations.
<IP_ADDRESS> SD_BOTH
include std/socket.e namespace sockets public constant SD_BOTH
Shutdown both send and receive operations.
8.36.7 Socket Options
Pass to the optname parameter of the functions get_option and set_option.
These options are highly OS specific and are normally not needed for most socket communication. They are provided here for your convenience. If you should need to set socket options, please refer to your OS reference material.
There may be other values that your OS defines and some defined here are not supported on all operating systems.
<IP_ADDRESS> Socket Options In Common
<IP_ADDRESS> SOL_SOCKET
include std/socket.e namespace sockets public constant SOL_SOCKET
<IP_ADDRESS> SO_DEBUG
include std/socket.e namespace sockets public constant SO_DEBUG
<IP_ADDRESS> SO_ACCEPTCONN
include std/socket.e namespace sockets public constant SO_ACCEPTCONN
<IP_ADDRESS> SO_REUSEADDR
include std/socket.e namespace sockets public constant SO_REUSEADDR
<IP_ADDRESS> SO_KEEPALIVE
include std/socket.e namespace sockets public constant SO_KEEPALIVE
<IP_ADDRESS> SO_DONTROUTE
include std/socket.e namespace sockets public constant SO_DONTROUTE
<IP_ADDRESS> SO_BROADCAST
include std/socket.e namespace sockets public constant SO_BROADCAST
<IP_ADDRESS> SO_LINGER
include std/socket.e namespace sockets public constant SO_LINGER
<IP_ADDRESS> SO_SNDBUF
include std/socket.e namespace sockets public constant SO_SNDBUF
<IP_ADDRESS> SO_RCVBUF
include std/socket.e namespace sockets public constant SO_RCVBUF
<IP_ADDRESS> SO_SNDLOWAT
include std/socket.e namespace sockets public constant SO_SNDLOWAT
<IP_ADDRESS> SO_RCVLOWAT
include std/socket.e namespace sockets public constant SO_RCVLOWAT
<IP_ADDRESS> SO_SNDTIMEO
include std/socket.e namespace sockets public constant SO_SNDTIMEO
<IP_ADDRESS> SO_RCVTIMEO
include std/socket.e namespace sockets public constant SO_RCVTIMEO
<IP_ADDRESS> SO_ERROR
include std/socket.e namespace sockets public constant SO_ERROR
<IP_ADDRESS> SO_TYPE
include std/socket.e namespace sockets public constant SO_TYPE
<IP_ADDRESS> SO_OOBINLINE
include std/socket.e namespace sockets public constant SO_OOBINLINE
<IP_ADDRESS> Windows Socket Options
<IP_ADDRESS> SO_USELOOPBACK
include std/socket.e namespace sockets public constant SO_USELOOPBACK
<IP_ADDRESS> SO_DONTLINGER
include std/socket.e namespace sockets public constant SO_DONTLINGER
<IP_ADDRESS> SO_REUSEPORT
include std/socket.e namespace sockets public constant SO_REUSEPORT
<IP_ADDRESS> SO_CONNDATA
include std/socket.e namespace sockets public constant SO_CONNDATA
<IP_ADDRESS> SO_CONNOPT
include std/socket.e namespace sockets public constant SO_CONNOPT
<IP_ADDRESS> SO_DISCDATA
include std/socket.e namespace sockets public constant SO_DISCDATA
<IP_ADDRESS> SO_DISCOPT
include std/socket.e namespace sockets public constant SO_DISCOPT
<IP_ADDRESS> SO_CONNDATALEN
include std/socket.e namespace sockets public constant SO_CONNDATALEN
<IP_ADDRESS> SO_CONNOPTLEN
include std/socket.e namespace sockets public constant SO_CONNOPTLEN
<IP_ADDRESS> SO_DISCDATALEN
include std/socket.e namespace sockets public constant SO_DISCDATALEN
<IP_ADDRESS> SO_DISCOPTLEN
include std/socket.e namespace sockets public constant SO_DISCOPTLEN
<IP_ADDRESS> SO_OPENTYPE
include std/socket.e namespace sockets public constant SO_OPENTYPE
<IP_ADDRESS> SO_MAXDG
include std/socket.e namespace sockets public constant SO_MAXDG
<IP_ADDRESS> SO_MAXPATHDG
include std/socket.e namespace sockets public constant SO_MAXPATHDG
<IP_ADDRESS> SO_SYNCHRONOUS_ALTERT
include std/socket.e namespace sockets public constant SO_SYNCHRONOUS_ALTERT
<IP_ADDRESS> SO_SYNCHRONOUS_NONALERT
include std/socket.e namespace sockets public constant SO_SYNCHRONOUS_NONALERT
<IP_ADDRESS> LINUX Socket Options
<IP_ADDRESS> SO_SNDBUFFORCE
include std/socket.e namespace sockets public constant SO_SNDBUFFORCE
<IP_ADDRESS> SO_RCVBUFFORCE
include std/socket.e namespace sockets public constant SO_RCVBUFFORCE
<IP_ADDRESS> SO_NO_CHECK
include std/socket.e namespace sockets public constant SO_NO_CHECK
<IP_ADDRESS> SO_PRIORITY
include std/socket.e namespace sockets public constant SO_PRIORITY
<IP_ADDRESS> SO_BSDCOMPAT
include std/socket.e namespace sockets public constant SO_BSDCOMPAT
<IP_ADDRESS> SO_PASSCRED
include std/socket.e namespace sockets public constant SO_PASSCRED
<IP_ADDRESS> SO_PEERCRED
include std/socket.e namespace sockets public constant SO_PEERCRED
<IP_ADDRESS> - Security levels - as per NRL IPv6 - do not actually do anything
<IP_ADDRESS> SO_SECURITY_AUTHENTICATION
include std/socket.e namespace sockets public constant SO_SECURITY_AUTHENTICATION
<IP_ADDRESS> SO_SECURITY_ENCRYPTION_TRANSPORT
include std/socket.e namespace sockets public constant SO_SECURITY_ENCRYPTION_TRANSPORT
<IP_ADDRESS> SO_SECURITY_ENCRYPTION_NETWORK
include std/socket.e namespace sockets public constant SO_SECURITY_ENCRYPTION_NETWORK
<IP_ADDRESS> SO_BINDTODEVICE
include std/socket.e namespace sockets public constant SO_BINDTODEVICE
<IP_ADDRESS> LINUX Socket Filtering Options
<IP_ADDRESS> SO_ATTACH_FILTER
include std/socket.e namespace sockets public constant SO_ATTACH_FILTER
<IP_ADDRESS> SO_DETACH_FILTER
include std/socket.e namespace sockets public constant SO_DETACH_FILTER
<IP_ADDRESS> SO_PEERNAME
include std/socket.e namespace sockets public constant SO_PEERNAME
<IP_ADDRESS> SO_TIMESTAMP
include std/socket.e namespace sockets public constant SO_TIMESTAMP
<IP_ADDRESS> SCM_TIMESTAMP
include std/socket.e namespace sockets public constant SCM_TIMESTAMP
<IP_ADDRESS> SO_PEERSEC
include std/socket.e namespace sockets public constant SO_PEERSEC
<IP_ADDRESS> SO_PASSSEC
include std/socket.e namespace sockets public constant SO_PASSSEC
<IP_ADDRESS> SO_TIMESTAMPNS
include std/socket.e namespace sockets public constant SO_TIMESTAMPNS
<IP_ADDRESS> SCM_TIMESTAMPNS
include std/socket.e namespace sockets public constant SCM_TIMESTAMPNS
<IP_ADDRESS> SO_MARK
include std/socket.e namespace sockets public constant SO_MARK
<IP_ADDRESS> SO_TIMESTAMPING
include std/socket.e namespace sockets public constant SO_TIMESTAMPING
<IP_ADDRESS> SCM_TIMESTAMPING
include std/socket.e namespace sockets public constant SCM_TIMESTAMPING
<IP_ADDRESS> SO_PROTOCOL
include std/socket.e namespace sockets public constant SO_PROTOCOL
<IP_ADDRESS> SO_DOMAIN
include std/socket.e namespace sockets public constant SO_DOMAIN
<IP_ADDRESS> SO_RXQ_OVFL
include std/socket.e namespace sockets public constant SO_RXQ_OVFL
8.36.8 Send Flags
Pass to the flags parameter of send and receive
<IP_ADDRESS> MSG_OOB
include std/socket.e namespace sockets public constant MSG_OOB
Sends out-of-band data on sockets that support this notion (e.g., of type SOCK_STREAM); the underlying protocol must also support out-of-band data.
<IP_ADDRESS> MSG_PEEK
include std/socket.e namespace sockets public constant MSG_PEEK
This flag causes the receive operation to return data from the beginning of the receive queue without removing that data from the queue. Thus, a subsequent receive call will return the same data.
<IP_ADDRESS> MSG_DONTROUTE
include std/socket.e namespace sockets public constant MSG_DONTROUTE
Do not use a gateway to send out the packet, only send to hosts on directly connected networks. This is usually used only by diagnostic or routing programs. This is only defined for protocol families that route; packet sockets do not.
<IP_ADDRESS> MSG_TRYHARD
include std/socket.e namespace sockets public constant MSG_TRYHARD
<IP_ADDRESS> MSG_CTRUNC
include std/socket.e namespace sockets public constant MSG_CTRUNC
Indicates that some control data were discarded due to lack of space in the buffer for ancillary data.
<IP_ADDRESS> MSG_PROXY
include std/socket.e namespace sockets public constant MSG_PROXY
<IP_ADDRESS> MSG_TRUNC
include std/socket.e namespace sockets public constant MSG_TRUNC
Indicates that the trailing portion of a datagram was discarded because the datagram was larger than the buffer supplied.
<IP_ADDRESS> MSG_DONTWAIT
include std/socket.e namespace sockets public constant MSG_DONTWAIT
Enables non-blocking operation; if the operation would block, EAGAIN or EWOULDBLOCK is returned.
<IP_ADDRESS> MSG_EOR
include std/socket.e namespace sockets public constant MSG_EOR
Terminates a record (when this notion is supported, as for sockets of type SOCK_SEQPACKET).
<IP_ADDRESS> MSG_WAITALL
include std/socket.e namespace sockets public constant MSG_WAITALL
This flag requests that the operation block until the full request is satisfied. However, the call may still return less data than requested if a signal is caught, an error or disconnect occurs, or the next data to be received is of a different type than that returned.
<IP_ADDRESS> MSG_FIN
include std/socket.e namespace sockets public constant MSG_FIN
<IP_ADDRESS> MSG_SYN
include std/socket.e namespace sockets public constant MSG_SYN
<IP_ADDRESS> MSG_CONFIRM
include std/socket.e namespace sockets public constant MSG_CONFIRM
Tell the link layer that forward progress happened: you got a successful reply from the other side. If the link layer doesn't get this it will regularly reprobe the neighbor (e.g., via a unicast ARP). Only valid on SOCK_DGRAM and SOCK_RAW sockets and currently only implemented for IPv4 and IPv6.
<IP_ADDRESS> MSG_RST
include std/socket.e namespace sockets public constant MSG_RST
<IP_ADDRESS> MSG_ERRQUEUE
include std/socket.e namespace sockets public constant MSG_ERRQUEUE
Indicates that no data was received but an extended error from the socket error queue.
<IP_ADDRESS> MSG_NOSIGNAL
include std/socket.e namespace sockets public constant MSG_NOSIGNAL
Requests not to send SIGPIPE on errors on stream oriented sockets when the other end breaks the connection. The EPIPE error is still returned.
<IP_ADDRESS> MSG_MORE
include std/socket.e namespace sockets public constant MSG_MORE
The caller has more data to send. This flag is used with TCP sockets to obtain the same effect as the TCP_CORK socket option, with the difference that this flag can be set on a per-call basis.
8.36.9 Server and Client Sides
<IP_ADDRESS> SOCKET_SOCKET
include std/socket.e namespace sockets export enum SOCKET_SOCKET
Accessor index for socket handle of a socket type
<IP_ADDRESS> SOCKET_SOCKADDR_IN
include std/socket.e namespace sockets export enum SOCKET_SOCKADDR_IN
Accessor index for the sockaddr_in pointer of a socket type
<IP_ADDRESS> socket
include std/socket.e namespace sockets public type socket(object o)
Socket type
<IP_ADDRESS> create
include std/socket.e namespace sockets public function create(integer family, integer sock_type, integer protocol)
creates a new socket.
Parameters:
- family: an integer
- sock_type: an integer, the type of socket to create
- protocol: an integer, the communication protocol being used
family options:
sock_type options:
Returns:
An object, an atom, representing an integer code on failure, else a sequence representing a valid socket id.
Comments:
On Windows you must have Windows Sockets version 2.2 or greater installed. This means at least Windows 2000 Professional or Windows 2000 Server.
Example 1:
socket = create(AF_INET, SOCK_STREAM, 0)
<IP_ADDRESS> close
include std/socket.e namespace sockets public function close(socket sock)
closes a socket.
Parameters:
- sock: the socket to close
Returns:
An integer, 0 on success and -1 on error.
Comments:
It may take several minutes for the OS to declare the socket as closed.
<IP_ADDRESS> shutdown
include std/socket.e namespace sockets public function shutdown(socket sock, atom method = SD_BOTH)
partially or fully close a socket.
Parameters:
- sock : the socket to shutdown
- method : the way used to close the socket
Returns:
An integer, 0 on success and -1 on error.
Comments:
Three constants are defined that can be sent to method:
- SD_SEND -- shutdown the send operations.
- SD_RECEIVE -- shutdown the receive operations.
- SD_BOTH -- shutdown both send and receive operations.
It may take several minutes for the OS to declare the socket as closed.
<IP_ADDRESS> select
include std/socket.e namespace sockets public function select(object sockets_read, object sockets_write, object sockets_err, integer timeout = 0, integer timeout_micro = 0)
determines the read, write and error status of one or more sockets.
Parameters:
- sockets_read : either one socket or a sequence of sockets to check for reading.
- sockets_write : either one socket or a sequence of sockets to check for writing.
- sockets_err : either one socket or a sequence of sockets to check for errors.
- timeout : maximum time to wait to determine a sockets status, seconds part
- timeout_micro : maximum time to wait to determine a sockets status, microsecond part
Returns:
A sequence, of the same size of all unique sockets containing { socket, read_status, write_status, error_status } for each socket passed 2 to the function. Note that the sockets returned are not guaranteed to be in any particular order.
Comments:
Using select, you can check to see if a socket has data waiting and is read to be read, if a socket can be written to and if a socket has an error status.
select allows for fine-grained control over your sockets; it allows you to specify that a given socket only be checked for reading or for only reading and writing, etc.
<IP_ADDRESS> send
include std/socket.e namespace sockets public function send(socket sock, sequence data, atom flags = 0)
sends TCP data to a socket connected remotely.
Parameters:
- sock : the socket to send data to
- data : a sequence of atoms, what to send
- flags : flags (see Send Flags)
Returns:
An integer, the number of characters sent, or -1 for an error.
<IP_ADDRESS> receive
include std/socket.e namespace sockets public function receive(socket sock, atom flags = 0)
receives data from a bound socket.
Parameters:
- sock : the socket to get data from
- flags : flags (see Send Flags)
Returns:
A sequence, either a full string of data on success, or an atom indicating the error code.
Comments:
This function will not return until data is actually received on the socket, unless the flags parameter contains MSG_DONTWAIT.
MSG_DONTWAIT only works on Linux kernels 2.4 and above. To be cross-platform you should use select to determine if a socket is readable, i.e. has data waiting.
<IP_ADDRESS> get_option
include std/socket.e namespace sockets public function get_option(socket sock, integer level, integer optname)
gets options for a socket.
Parameters:
- sock : the socket
- level : an integer, the option level
- optname : requested option (See Socket Options)
Returns:
An object, either:
- On error, {"ERROR",error_code}.
- On success, either an atom or a sequence containing the option value, depending on the option.
Comments:
Primarily for use in multicast or more advanced socket applications. Level is the option level, and option_name is the option for which values are being sought. Level is usually SOL_SOCKET.
Returns:
An atom, On error, an atom indicating the error code.
A sequence or atom, On success, either an atom or a sequence containing the option value.
See Also:
<IP_ADDRESS> set_option
include std/socket.e namespace sockets public function set_option(socket sock, integer level, integer optname, object val)
sets options for a socket.
Parameters:
- sock : an atom, the socket id
- level : an integer, the option level
- optname : requested option (See Socket Options)
- val : an object, the new value for the option
Returns:
An integer, 0 on success, -1 on error.
Comments:
Primarily for use in multicast or more advanced socket applications. Level is the option level, and option_name is the option for which values are being set. Level is usually SOL_SOCKET.
See Also:
8.36.10 Client Side Only
<IP_ADDRESS> connect
include std/socket.e namespace sockets public function connect(socket sock, sequence address, integer port = - 1)
establishes an outgoing connection to a remote computer. Only works with TCP sockets.
Parameters:
- sock : the socket
- address : ip address to connect, optionally with :PORT at the end
- port : port number
Returns:
An integer, 0 for success and non-zero on failure. See the ERR_* constants for supported values.
Comments:
address can contain a port number. If it does not, it has to be supplied to the port parameter.
Example 1:
success = connect(sock, "<IP_ADDRESS>") -- uses default port 80 success = connect(sock, "<IP_ADDRESS>:110") -- uses port 110 success = connect(sock, "<IP_ADDRESS>", 345) -- uses port 345
8.36.11 Server Side Only
<IP_ADDRESS> bind
include std/socket.e namespace sockets public function bind(socket sock, sequence address, integer port = - 1)
joins a socket to a specific local internet address and port so later calls only need to provide the socket.
Parameters:
- sock : the socket
- address : the address to bind the socket to
- port : optional, if not specified you must include :PORT in the address parameter.
Returns:
An integer, 0 on success and -1 on failure.
Example 1:
-- Bind to all interfaces on the default port 80. success = bind(socket, "<IP_ADDRESS>") -- Bind to all interfaces on port 8080. success = bind(socket, "<IP_ADDRESS>:8080") -- Bind only to the <IP_ADDRESS> interface on port 345. success = bind(socket, "<IP_ADDRESS>", 345)
<IP_ADDRESS> listen
include std/socket.e namespace sockets public function listen(socket sock, integer backlog)
starts monitoring a connection. Only works with TCP sockets.
Parameters:
- sock : the socket
- backlog : the number of connection requests that can be kept waiting before the OS refuses to hear any more.
Returns:
An integer, 0 on success and an error code on failure.
Comments:
Once the socket is created and bound, this will indicate to the operating system that you are ready to being listening for connections.
The value of backlog is strongly dependent on both the hardware and the amount of time it takes the program to process each connection request.
This function must be executed after bind.
<IP_ADDRESS> accept
include std/socket.e namespace sockets public function accept(socket sock)
produces a new socket for an incoming connection.
Parameters:
- sock: the server socket
Returns:
An atom, on error
A sequence, {socket client, sequence client_ip_address} on success.
Comments:
Using this function allows communication to occur on a "side channel" while the main server socket remains available for new connections.
accept must be called after bind and listen.
8.36.12 UDP Only
<IP_ADDRESS> send_to
include std/socket.e namespace sockets public function send_to(socket sock, sequence data, sequence address, integer port = - 1, atom flags = 0)
sends a UDP packet to a given socket.
Parameters:
- sock: the server socket
- data: the data to be sent
- ip: the ip where the data is to be sent to (ip:port) is acceptable
- port: the port where the data is to be sent on (if not supplied with the ip)
- flags : flags (see Send Flags)
Returns:
An integer status code.
See Also:
<IP_ADDRESS> receive_from
include std/socket.e namespace sockets public function receive_from(socket sock, atom flags = 0)
receives a UDP packet from a given socket.
Parameters:
- sock: the server socket
- flags : flags (see Send Flags)
Returns:
A sequence containing { client_ip, client_port, data } or an atom error code.
See Also:
8.36.13 Information
<IP_ADDRESS> service_by_name
include std/socket.e namespace sockets public function service_by_name(sequence name, object protocol = 0)
gets service information by name.
Parameters:
- name : service name.
- protocol : protocol. Default is not to search by protocol.
Returns:
A sequence, containing { official protocol name, protocol, port number } or an atom indicating the error code.
Example 1:
object result = getservbyname("http") -- result = { "http", "tcp", 80 }
See Also:
<IP_ADDRESS> service_by_port
include std/socket.e namespace sockets public function service_by_port(integer port, object protocol = 0)
gets service information by port number.
Parameters:
- port : port number.
- protocol : protocol. Default is not to search by protocol.
Returns:
A sequence, containing { official protocol name, protocol, port number } or an atom indicating the error code.
Example 1:
object result = getservbyport(80) -- result = { "http", "tcp", 80 }
See Also:
<IP_ADDRESS> info
include std/socket.e namespace sockets public function info(integer Type)
gets constant definitions from the backend.
Parameters:
- type : The type of information requested.
Returns:
A sequence, containing the list of definitions from the backend. The resulting list can be indexed into using the Euphoria constants. Or an atom indicating an error.
Example 1:
object result = info(ESOCK_TYPE_AF) -- result = { AF_UNIX, AF_INET, AF_INET6, AF_APPLETALK, AF_BTH, AF_UNSPEC }
See Also:
Socket Options, Socket Backend Constants, Socket Type Euphoria Constants


| Package | Description |
|---|---|
| com.sun.jini.fiddler |
Provides the server side of an implementation of the lookup discovery service
(see
). |
| Class and Description |
|---|
| Fiddler
This interface defines the private protocol between the client-side
proxy and the server of a lookup discovery service.
|
| FiddlerAdmin
An administrative interface for the Fiddler implementation of the
lookup discovery service (see Fiddler).
|
| FiddlerAdminProxy
This class is a proxy providing access to the methods of an implementation
of the lookup discovery service which allow the administration of the
service.
|
| FiddlerImpl
This class is the server side of an implementation of the lookup
discovery service.
|
| FiddlerImpl.LogRecord
Interface defining the method(s) that must be implemented by each of
the concrete LogObj classes.
|
| FiddlerImpl.LookupDiscoveryListener
Class whose discovered() method is invoked by threads in the
LookupDiscovery class whenever a new lookup service is discovered
on behalf of a client registration
|
| FiddlerImpl.RegistrationInfo
This class acts as a record of one registration with the lookup
discovery service; containing all of the information about that
registration.
|
| FiddlerLease
When the Fiddler implementation of the lookup discovery service grants
a lease on a registration requested by a client, a proxy to that lease
is provided to allow the client to interact with the granted lease.
|
| FiddlerLeaseMap
When clients request a registration with the Fiddler implementation of
the lookup discovery service, leases of type FiddlerLease are granted
on those registrations.
|
| FiddlerProxy
This class is a proxy for a lookup discovery service.
|
| FiddlerRegistration
This class is an implementation of the LookupDiscoveryRegistration
interface.
|
| FiddlerRenewResults |
Copyright 2007-2013, multiple authors.
Licensed under the Apache License, Version 2.0, see the NOTICE file for attributions.


NMGen is adaptation of Recast's static mesh functionality in the Java language for purposes of study and experimentation. It takes an arbitrary triangle mesh as input and outputs meshes representing the traversable surface of the original mesh.
Project Documentation
Project Source
License
Navigation Mesh Generation Process
This process is an adaptation of portions of Recast, a C++ navigation mesh generator created and released by Mikko Mononen under the MIT license.
The general process is as follows:
See The High Level Process for more information.
The class which implements this process is {@link org.critterai.nmgen.NavmeshGenerator}.
Each stage of the process is implemented by data and builder classes. The output of one stage is required as input for the next:
| Stage | Builder Class | Data Class (output) | Builder Input |
| Voxelization | {@link org.critterai.nmgen.SolidHeightfieldBuilder} | {@link org.critterai.nmgen.SolidHeightfield} | Source Geometry |
| Region Generation | {@link org.critterai.nmgen.OpenHeightfieldBuilder} | {@link org.critterai.nmgen.OpenHeightfield} | {@link org.critterai.nmgen.SolidHeightfield} |
| Contour Generation | {@link org.critterai.nmgen.ContourSetBuilder} | {@link org.critterai.nmgen.ContourSet} | {@link org.critterai.nmgen.OpenHeightfield} (Fully built.) |
| Polygon Mesh Generation | {@link org.critterai.nmgen.PolyMeshField} | {@link org.critterai.nmgen.PolyMeshField} | {@link org.critterai.nmgen.ContourSet} |
| Detail Mesh Generation | {@link org.critterai.nmgen.DetailMeshBuilder} | {@link org.critterai.nmgen.TriangleMesh} | {@link org.critterai.nmgen.PolyMeshField} |


Python Asynchronous I/O
library (pyasynchio)
This Python library is created to support asynchronous I/O (Input/Output) operations. Unlike most platform-independent asynch I/O libraries, pyasynchio is simple. You do not have to know much about programming and anything about AIO in particular to use pyasynchio. Unlike, for example, famous asyncore library, pyasynchio does not require you to use some object-oriented approaches, implement certain interfaces or do anything similar. However you should understand what file or socket is J, because currently pyasynchio provides I/O only for files and sockets.
Lets move to the code. Here is a simple TCP echo implemented with pyasynchio:
import sys
import socket
import pyasynchio
#
Create and bind socket
lsock = socket.socket()
lsock.bind((sys.argv[1], int(sys.argv[2])))
lsock.listen(5)
#
Create apoll object
apoll = pyasynchio.apoll()
# Issue
first asynch accept through apoll object
apoll.accept(lsock)
while True:
# poll results from apoll
object
events = apoll.poll()
# process them one by one
for evt in events:
# if operation was accept
if evt['type'] == 'accept':
# moreover, if
it is successful
if evt['success']:
# issue
asynchronous read through apoll object
apoll.recv(evt['accept_socket'], 1024)
# issue
another asynch accept, so that more clients can connect
apoll.accept(lsock)
# if operation was recv
elif evt['type'] == 'recv':
# if received
some data and connection isnt broken (just as recv it presents empty string if
client disconnected)
if
evt['success'] and evt['data'] != '':
# issue
asynchronous send to echo data back to client. No need to pick up results of
this op
apoll.send(evt['socket'],
evt['data'])
# issue new
recv so we can echo more data
apoll.recv(evt['socket'],
1024)
# EOF
:)
done.
Uses built-in python socket handles from socketmodule (and builtin files, if
you want file I/O). In fact, pyasynchio.apoll class is just the only
class which is currently exported by this library.
If
you are interested, you can look into the docs,
or download
library itself (currently just for Windows 2000/XP/2003 family of OS and MSVC
.NET 2003 compiler, however Unix version with full socket I/O support is coming!), and/or participate
in mailing list about
pyasynchio (at this point any feedback is welcome!).
--
Vladimir
Sukhoy vladimir dot sukhoy at G mail dot com


Your Assignment
- Create a new component => CartComponent
- Add a property to that component => 'items' which initially is an
empty array
- Make 'items' bindable and set the value of items from outside (from
the AppComponent)
- Set an initial array with ['Apples', 'Bananas', 'Cherries']
- Add a 'Add Item' button and an input field to your CartComponent
- Bind the input value to a property in the CartComponent
(Two-way binding) and add a click listener for the button
- Emit a new event to which you may listen from the AppComponent on
every button click. Pass the entered value as a value with the event.
- Listen to the emitted event in your AppComponent and add the passed
data to your 'items' array.
- Output the array in the method where you add items by calling console.log(yourArray)


--- layout: page title: "OAuth 2.0 Token Introspection" description: "This specification defines a method for a protected resource to query an OAuth 2.0 authorization server to determine the active state of an OAuth 2.0 token and to determine meta-information about this token. OAuth 2.0 deployments can use this method to convey information about the authorization context of the token from the authorization server to the protected resource." ---
| Document Name: | RFC 7662 |
|---|---|
| Document URI: |
urn:ietf:rfc:7662
|
| Online Version: |
https://datatracker.ietf.org/doc/html/rfc7662
|
| Organization: | Internet Engineering Task Force (IETF) |
| Series: | Request for Comments (RFC) |
| Abstract: | This specification defines a method for a protected resource to query an OAuth 2.0 authorization server to determine the active state of an OAuth 2.0 token and to determine meta-information about this token. OAuth 2.0 deployments can use this method to convey information about the authorization context of the token from the authorization server to the protected resource. |
active
,
aud
,
client_id
,
exp
,
iat
,
iss
,
jti
,
nbf
,
scope
,
sub
,
token_type
,
username
Return to ( Series | Organization | all Specifications )


Shawn's Pond
Hello, My name is Shawn! I am 11 and I like ponds and koi fish. In this blog I will teach you how to build a pond, how to take care of koi fish, and other useful information for owning a pond. I have built my own pond by myself and have learned a lot along the way. I would like to share this knowlege with you so you dont run into problems.


Jharkhand polls in 5 phases between Nov 30 to Dec 20; result on Dec 23
Counting of votes is on December 23
by Archis MohanJharkhand, parts of which are under Maoist influence, will have a five phased polling from November 30 to December 20. Counting of votes is on December 23. Jharkhand has a BJP government with Raghubar Das as the chief minister, the first CM of the state to complete a five-year term after the state was created in November 2000


I'm doing this website from scratch, and I'm insanely aware of its shortcomings. I have a real limited knowledge of HTML
but we all have to start somewhere, right? Hence why I'm not too fussed, rather, it'll be my way to crash, burn,
and somewhat learn, HTML/CSS.
Still in its very early stages, but essentially given the link to a product, this program intends to check its price on an
hourly basis and email the user if the price has changed. Also trying to use this to find whether GA tickets
are being sold on Ticketek Marketplace for The 1975 in Sydney. I still regret not buying those tickets each and
everyday, but it's what inspired me to make this application, so at least something good came out of it, right?
I always dreamed to implement this project, and I was able to create it during my time as a STEP intern at Google in the
summer of 2020-2021! With my pod partner, we created a webapp using
Java and
JavaScript. Google Meetup intends to remove the hassle of finding a place and time to meet up with your very
large and very uncommunicative group of friends. (Because getting new friends is 100% not an option.)
Additionally, with the project being created during the COVID-19 pandemic, a heat map was created to show proximity
to current cases, and meetup location suggestions omitting any hotspots.


Home
Management Login
Username
Password
Make sure to never share your password with anyone..
Invalid username or password.
Register
Login


Appollo Commander
Lunar Phases: Mission
Identify this moon phase
New Moon
First Quarter Moon
Full Moon


The web is a collection of html documents that are all linked together by Hyper Links.
HTML = Hyper Text Markup
Everything online is made up of HTML.
HTML is made up of:
HTML Mark-up
HTML consists of opening tags and closing tags, which make up an element.
HTML tags:HTML Attributes
HTML attributes are listed after the elements, but before the corresponding value. Links (a element) and images (img element) are self-closing and are considered Void tags beacuse they do not contain any content.
Turns everything into one line. If we want to seperate the contents into multiple lines, we write "br" which is a Void tag for "break". The "p" tag is also used and is not a Void tag because it includes content.
Inline and Block ElementsThese two types of elements are used to separate content. An example of an inline element is "br" because it adds a break in the content and places the text on the next line below. An example of a block element is "p" because it creates an invisible blox around the content and also has a height and a width. Span is also an inline element and Div is a block element.
Page StructureWebsites are created like a house. The HTML is the structure, the CSS is the styling or decor, and Javascript is the functional parts or garage door.
HTML is the language of the web and includes syntax + rules.
CSS is a language that uses syntax + rules to change the way an element looks on the page.
Tags are part of the lement that make up an HTML tree.
DOM ( Document Object Model) is what puts everything together. The tree that we see in developer tools is the DOM tree that the browser built from the HTML document.
Each tag has an element that describes what type it is. An element consists of a beginning tag, a closing tag, and everything in between.
Even if the shape is a circle, in HTML everything is made up of boxes. If you want to right-click to inspect an element, you will see an assortment of diffrent boxes.
By thinking of things in boxes it’s easier to rearrange your website. A grid in background makes sure everything is aligned. When plotting your squares and layout of HTML structure, remember: START BIG AND GO SMALLER
Now for some general laws...just like in our society; we have national laws, state laws, local municipality laws, and house rules. CSS has laws/rules. The most specific ruleis applied to every element. Thus, our "house laws" would be the same as our "national laws".
Cascading means that rules are applied not only to the elements they directly match but also to all of the elements' child elements. However, if a child element has multiple overlapping rules defined for it, the more specific rules apply.
When using CSS it can be helpful to think about it as a Search-n-Replace tool. You identify a "class" or "tag" of the element you want to match and then what you want to do with, or what property values to replace with different ones. Also, where and in what order matter. Styles can be defined in different places and are applied in the following order, with definitions further down `the list overwriting previous definitions:
Inheritance: relies on the ancestor/descendant relationship to operate. The idea by which properties are applied, not only to a specified element, but also it's descendants. It relies on the document tree, the hierarchy of HTML elements. Child elements may inherit CSS properties from any ancestor element enclosing it; they can also inherit text related properties, but box related properties are not inherited.
Properties that can be inherited:
Properties that can't be inherited:
Selectors are what allows you to targe specifc HTML elements and apply style to them. By doing this, you can condense your CSS to avoid unnecessary repetition, which waste time, and time is precious. It is recommended that CSS and HTML are kept in two different files, by keeping the design away from the document they are easier to edit. Selectors can be combined. Below is a list of different type of Selectors.
ID Selectors
Most powerful type of selector, beat out other types of selectors and styles. Having lower specificity selectors are easier to override.
Class Selectors
Most useful and versatile. Well supported in all browsers. Add multiple classes separated by space on HTML elements. Also JavaScript stuff you can do specifically for manipulating classes.
Tag Selectors
Most useful when changing properties that are unique to HTML element. Like setting the list style on a "ul" or tab-size on a "pre". Typically more useful to have class define styling that you can use on any HTML element.
Attribute Selector
More useful than classes because they have the same specificity value, but they can be any attribute, not just "class". They also can have a value you can select by.
Positional Selectors
Several positional selectors beyond: nth-child; using simple expressions (like 3n="every third") you can select elements based on their position in the HTML.
Other Pseudo Selectors
":empty" is one of many pseudo selectors, which you can recognize by the ":". They typically represent something you couldn't know just by the element and attributes alone. *These are different than pseudo elements, which are recognizable by "::"-they are responsible for adding things to the page by the things they select.
 Which consists of 4 parts:
To deal with sizing issues, use: "box-sizing:border-box...however...to make sure older browsers are able to display this CSS, you must add browser specific prefixes "webkit, moz, ms". If we set box size to percentage rather than pixels, the box sizing will adjust to size of screen. When positioning boxes remember: *divs are block elements so by default they take up the entire width of a page, to deal with this we can add the "display:flex" to appropriate CSS will override this behavior and let divs appear next to each other!* See this link for more information on FlexBox
Compare your code to the design you were given... How to know what to change?
Repeat steps above till it looks like the design mock up! The fly without changing actual html and css files, just like a preview! To verify code, go to the following links: HTML checker and CSS checker


Dear data['customer_name']; ?>,
That you for ordering SPIC AND SPAN. services. You will receive the final booking comfirmation once the deposit for the first our of cleaning is made.
| Service Ordered | |
| Package | data['package']; ?> |
| Date & Time | data['date']; ?> @ data['time']; ?> |
| Hourly rate | data['hourlyPricePerCleaner']) ? '€' : '') . ($mail->data['hourlyPricePerCleaner']) . (($mail->data['hourlyPricePerCleaner'] > 1)&&is_numeric($mail->data['hourlyPricePerCleaner']) ? ' /cleaner' : ''); ?> |
| Cleaning Equipment | |
| Cleaning Solvents | data['equipment']) ? 'Available on premises' : 'Provided by a cleaner'; ?> |
| Vacuum Cleaner | data['equipment']) ? 'Available on premises' : 'Provided by a cleaner (+€10)'; ?> |
| Mop | data['equipment']) ? 'Available on premises' : 'Provided by a cleaner (+€10)'; ?> |
| Special Requests | |
| Included in price |
Should you have any further questions, please do not hesitate to contact us. Our customer support is there for you 24 hours a day, 7 days a week. You can send us an email to<EMAIL_ADDRESS>or call us at +49769869876 or +4969869876.
Best Regards,
SPIC AND SPAN.TEAM
EU Headquarters:
Sepapaja 6
Tallinn 15551
Estonia
Reg. 14080385


So i wrote this to do simple animations, like:
Shake Normally
or
Little Wiggle
or even
Shake harder
or the master
SHAKE ULTRA
. There's a lot you can do with
animations
, but remember, people are photosensitive, so be careful with what you do!
So
... Lets get started!
You don't need JS to do interesting animations, like
letter, or making the letters
, to be honest.
It's a bit harder, but this one
is a bit more technically involved for beginners
.
(Not sure why i made this one...)
this
one
just
wiggles.
that's it, really, check the HTML with Inspect Element or take a look at the files in your own IDE.


1590171 - QuoVadis: failure to reply in a timely manner RESOLVED (s.davidson) in NSS - CA Certificate Compliance. Last updated 2019-11-07.
.NET Design Review: GitHub Quick Reviews 00:00:00 - Approved: Attribute for minimal runtime impact during an unmanaged call https://github.com/dotnet/corefx/issues/40740#issuecomment-545076797 00:34:14 - Approved: Provide an `Unsafe.SkipInit` method to allow bypassing definite assignment rules....
abp.io Today is the big day! After ~3 years of continuous development, first stable ABP release, 1.0, has been released. Thanks to everyone contributed to the project or tried it so far.
Firefox 70 — a bountiful release for all – Mozilla Hacks - the Web developer blog Firefox 70 is released today, and includes great new features such as secure password generation with Lockwise and the new Firefox Privacy Protection Report, as well as cool additions for ...
Introduction to Routing in Blazor In this post, I begin to look at how navigation works in Blazor. I start by showing the differences between navigation in traditional web apps vs SPAs. Before taking a high level look at Blazor's router component and how a navigation request is handled.
New in .NET Core 3.0: local tools: Exploring ASP.NET Core 3.0 - Part 7 In this post I show how to install and run local tools in .NET Core 3.0 using a dotnet-tools manifest and discuss how to work with multiple manifests.
Meet Algo, the VPN that works I think you’ll agree when I say: there’s no VPN option on the market designed with equal emphasis on security and ease of use. That changes now. Today we’re introducing Algo, a self-hosted personal…
trailofbits/algo Set up a personal VPN in the cloud. Contribute to trailofbits/algo development by creating an account on GitHub.


Chapter 5: Compaction (*)
STxT Information analysis
This chapter deals with the compaction of STxT documents. We are going to modify a document to make it more compact, so that it is faster to parse and contains the same information.
In order to do this we must analyze the content of one document.
A document is just a set of nodes with a specific indentation, so the information is actually of order and level.
Let's see an example:
Node_0 (www.example.com/...): Node_1: Node_2: Text of node 2 Node_3: Text of node 3 Node_4: Node_5: Text of Node 5 Node_6: Text of Node 6 A line of text Other line of text Node_7: Node_8: Node_9: Last line
We see that there are 10 nodes in this document. The first node is Node_0, and is the one containing the rest. We could say that it is the first one to appear (order) and that it has level 0 (is not indented and contains the rest). The second node is Node_1. It is the second one to appear and has level 1. This way, we could qualify all the lines, and extract the information. It isn’t hard to make a table with this information:
| Order | Node | Level |
|---|---|---|
| 1 | Node_0 | 0 |
| 2 | Node_1 | 1 |
| 3 | Node_2 | 2 |
| 4 | Node_3 | 2 |
| 5 | Node_4 | 1 |
| 6 | Node_5 | 2 |
| 7 | Node_6 | 2 |
| 8 | Text | 3 |
| 9 | Text | 3 |
| 10 | Node_7 | 2 |
| 11 | Node_8 | 3 |
| 12 | Node_9 | 4 |
Now we just need to include this information. This is what the next section deals with.
A way of compacting
From the table above, we are going to propose a way to compact the information. It will be as easy as inserting the level number instead of using tabs, and separate it with the usual ':' character.
Thus, the above example would be left like this:
0:Node_0 (www.example.com/...): 1:Node_1: 2:Node_2: Text of node 2 3:Node_3: Text of node 3 1:Node_4: 2:Node_5: Text of node 5 2:Node_6: Text of node 6 3:A line of text 3:Other line of text 2:Node_7: 3:Node_8: 4:Node_9: Last line
Actually, there is still redundant information, as the first node always has level 0 (in fact the parsers can assume that it is -1), and the level 1 could be assumed to be level 0. Thus, there will be programs that will leave it the following way:
Node_0 (www.example.com/...): Node_1: 1:Node_2: Text of node 2 2:Node_3: Text of node 3 Node_4: 1:Node_5: Text of node 5 1:Node_6: Text of node 6 2:A line of text 2:Other line of text 1:Node_7: 2:Node_8: 3:Node_9: Last line
As a personal remark I will say that my I prefer that all nodes have a level (except the first one) as I find it more aesthetic and easy to read.
My preference would be thus:
Node_0 (www.example.com/...): 1:Node_1: 2:Node_2: Text of node 2 3:Node_3: Text of node 3 1:Node_4: 2:Node_5: Text of node 5 2:Node_6: Text of node 6 3:A line of text 3:Other line of text 2:Node_7: 3:Node_8: 4:Node_9: Last line
There is one basic rule for compaction:
If aliases have been used
they will be replaced by the Canonical Name
This is an important rule, since names are usually shorter than aliases, and at the same time it is faster to parse a document this way. In addition, it also plays an important role in document transformation, as we will see in Chapter 7: Equivalences and Internationalization).
In case we do not use canonical names we would talk of semicompacted documents, which although correct, would not it be as optimal as the compacted ones.
Finally keep in mind that text lines which belong to a node, will always be in a level above the node to which they belong. In the previous example we can see that after Node6 (with level 2) there are two text lines that belong to it, both with level 3.
Actually, the compacting rule is this simple:
Replace the start tabs with:
number of tabs + ':'
Other examples
If we compact the fritters recipe, we would ave the following text:
Recipe(www.cooking.demo/recipe.stxt): 1:Title: Sweet fritters from Girona 1:Description: This is a recipe for making sweet fritters at Lent 2:time. They are known also as Sweet Fritters from l'Empordà. 2:They are usually served as a dessert, and there is enough quantity 2:for up to 12 people. It is an easy to make recipe. 2:Ingredients: 1 Kg flour 2:8 eggs 2:zest of 1-2 lemons 2:150 grams sugar 2:100 grams butter 2:1/4 liter milk 2:1 glass of grassolis (blend of muscatel, anise, cointreau) 2:75 grams yeast (from a bakery) 2:aniseed 2:a pinch of salt 2:a little bit of ground cinnamon 1:Preparation: Place flour and the other ingredients in a bowl. 2:Melt the butter with some milk, as well as the 2:yeast. The milk for dissolving the yeast has to be only 2:slightly lukewarm, because otherwise it would probably 2:lose its effect. Mix everything well, and let stand 2:covered for 3-5 hours (until the dough raises). 2:With a spoon or teaspoon, depending on the size you want, 2:fry in plentiful oil until you turn golden. As you take 2:them out, sprinkle them with a little bit of the grassolis mixture, 2:and cover them with sugar.
Let’s see what the compaction of the example we saw in the grammar chapter looks like.
We had the customer's information, which compacted looks like:
Customer (www.gym.demo/client.stxt): 1:Personal information: 2:Name: Shila 2:First last name: Kween 2:Age: 28 2:Vip customer: 1 2:Photograph: 3:R0lGODlhlgCNALMAAFtepau07X2I1tvg+pOe42dwwMPK9vz+/AAAAAAAAAAAAAAAAAAAA 3:AAAAAAAAAAAACH5BAAAAAAALAAAAACWAI0AAwT/8MhJq7046827/2AojmRpnmiqrmzrvn 3:Asz3Rt3/Vg7MbgD7igsATUBQgCAYEQ2AGH0KGPR9XxAkdBIdl8Rr8qK3bJxJp5vosBmxQ 3:EvOA4yIhdvw/PonVt2OjIfXKCF1ZpPzsuA1hwg18DBDoVa0sde04bPQc9aY1Ra14+AUmQ 3:B00Se3RMO1h4lxisEoGdQgZMOrdKTwZKWW2jZUcBW25XmRaPEnezQZ8UvLFIvErAaKsFw 3:b3RZZsSpAHLOM2nbhRLyh0CkXqTWkjmTQS1jOAwfBMD5BOitx/f86fBFJGJ9o3eDCT38n 3:UzUxCDkR61qnGiwKfIGAGnDL7YdwohQCak/wh1mdJEgJ1gA0dOiveIjChZGlO07GgyVi1 3:bFYws4WOsFJ5jq+os4QLSpBZXMU3g1OEGyJtteOiY0kAgw8ojmaykS7frEMykICa1wvkG 3:W0V+HM61qgPnUcMD8dxMbfUVLAclfZqY6nEEiayeaUnWORY1pKYm1zBSQGt3AxlNB8hZG 3:eqlbgamWeuGmjRSUToAHCVZbjxhV7we8b6VTV26AxpFrQ79mKgGibB4hEaTxlsK5FpVd2 3:jnRLpwZIidopQ4BEwaD6RArJvUevtzOO1bokgoeiRwy79YzTNSclqr1CTmkkDdKsL3lOz 3:ZPxbfA4LkWlQ13+ndOu18EZ+5arhX3f9aO0BShB+RSIJHO5qMphs4f1TVRzxVCaXMP9zM 3:5wpsHMQ3IHil5JIgUI3R8cNOQV1IHVAZUrAiYRpwUsBpws1n13RdMIHRIrglg94pP+oT4 3:4MClnINELoR2Yg5V3D1hzFr1GSdHy8WyUEgBhSwXX5BziIXPPLUMdcYOalF1WUf9AHENc 3:9poKQcbgFDY0R5aAFKeR5wGKAHfUyoyoNdDoKVGyDtMZcWBcgyAABVfdAoIR9MoYmWb+Q 3:HmUa2+AWJam8EguijcM0YaZUfIvhDolVZ+uYXPA20yWCTFgAATADMSGpO6aTQ5wFsXuqQ 3:pXH4Nw1s8qhZ6xblEAqqm0xY5Qf/lpBxMSIGq0rRhShH+HREGrcxSsGMpr2ZHLVmVgBLG 3:mtc0+Key4w0LA9c4TEjg8kQY1SHtv3DXwbK3beDG+lYOm0jfQ5gq3n4RDuKqPIKZacf8y 3:47nTgXaNHaDjNKeN8Ft8aRLikVdirMwoohxM6MAmeca0dhkroFtEYugZ2z9GDBsGqbFKD 3:zLigbXFAZoOmGz7z2xVISZhhsUVAkpsm8MiHAfsFEoq1EpgnAkGjxjV80ARAvx0nMmGga 3:XD3XrwWMNtQn1mdTW7NHmVRlTgG9qdJ2N7PWGJkSShz5Bt1UvFQquIFMAXA7qtZc9DeIJ 3:GrfS39aMLJPktiGdRkGnqfc/1yLluUePgbXuqzkNUupWksEaOmDSSzNE/qu5Wg6dVyI4L 3:MjMY8awKgim6C2qM6jK7iM7ezBhc+4faQj4T9h++rZnzt4LQy6uCFGeSmg5ZgdE4y+HGP 3:UUpiEpA86HgWZXr6aaxvlR7zMOM9JUE/TzMJEtA9IOif3oN4ec7NJG8iKW67+oYhraEkx 3:ovBOn5Kjrs9x4jnSwYumHiGrrTBsOcuonU/csQWNhWg98qnPFrwWilEQC36wmJS3xrKLY 3:CQjMjoA3vPywz8wmMIpkYmG6irVFUJJQ2e10gIAalWgJOTFPMCrCT4Ylbqm9GUapHhSAE 3:RXxCSBTwgsSYbBtBC/nv8gRlYvi0iWwDhERvHthcnTUjJIiAc2eE0uGXuVjt4IidQFD0S 3:zOFcvuHA9CsoKNAUUBmKm0TdZNWpXyBLGrFoDEDC6r43RKKM7zOG2ZSylFjo7in8SCEYR 3:irBWQ4xkEwl1E7HVygzSkkQZs+UcIB7LiPEjUQZ/Yg2AXWoXQuwb3wbiyCB6TV3TmVoZC 3:1lGUPqilxISQDHB9SXXXZEWUUkO3xjXG51Z85ep0eEydQY6gdRCmdyES1+G8ccOouiToG 3:TUhFhpgWoJwSmIItoVhgLETLqjDWcoptf0yU9ftMNyZawnokTHN6V5pkodY1XqisnFSxU 3:QjErURhLukbo/pvP/WNZMoncYyIsKKnOILzNi6hrSwOGAA5NbyORHkXW1UBqobrsgIkWS 3:AFJEhU1rypzGGLFZL41y8zRUk8AzcvLMcNTnnjMqJtB+qYz6dFQxH+Ei69JVT87sNEuyG 3:OUdOjU0tcXSRcNjx7byRxSbKjNzRiJnUEtREkrtK56NautRcOMZrTXoOaFjo8HWisdG1O 3:GAPVAXJeRlyCH6o30FDZp0ssS6vWhiCUn8Qz1nhZppoOSQaxhmMi5YiqLeYJxmQIJAHoU 3:kYWJkOhRUZnB4JooeqYkvBK2oMa3RQVupjR1DzIvFGNmJhGXpsnBRjofwQQCQ3qS1ycnC 3:y9gIIsmGsoJA/5yGd/J3vQaNc4hWUKMmPGuD83gtLqqZKDai8dHnZswd7fvbUdAFnqGBV 3:KmI+pf4nmYegNXzb/5wJw6e0sRdlGdcyVCJImtaOZuZkSIg2mlAbUXI54wOvBVFVBa2e1 3:KMnZJSIeoRkNgyYNHphaaaRfCAEnvKUdaEneVoYROdilX9GjV0bfBJljRcpoEScShCHCJ 3:UGcmPOJU3iE9o1jHSYUA7phSXGmlDEHckr4DFKJ5GWUJAIVXAe3yCd5zgDrVod+SdJTAm 3:WvKoT4gXNaceq6YYajJ1FnGPbWVAFfPiImhyKCVwjEF3O4uEncBH0056xyFGupvRLkJD1 3:gHslxjhjv9HwJG1zAJzb4hAhxDB9b2+GQZSbrLgFFPqFCPsuBOI8G9xsxdcAF2G0JH+FR 3:dpLIKXKG2fneYdqwV1CztUEDVcC8FiLxND85VgbkoIJYUjIeTeFqy+OnaLoF0za/mErVx 3:8QumoE60m7FxaEKkqnHKZ2L4XkO27LtaibGvVRmpGK6FBINZibsNYbXh7b5w9ju3KuIpa 3:g2ewgkpVVPo00pGNjLuAjsW8AW5dEA9rD5/jaxxe2pKCtLuDbSC4+pAkDJaOoCrBJugTP 3:CfwZUOBFfKFie1CykcUtDZWRRNBESP8NDS0kbiDMJAb/ryYZ+NY4vq4RsUtLoKpzXxnss 3:CGeXz/IwdTTDNLF5jaG1iHgnaHLdyPta81E7SdNTRILjgPQ2oAhkkMbaNNJthrf0vAhbB 3:10BjBkRBn0D2DRUBxKNfWxx9gMzAQqLRU/dhlELmJZX5H5RF4igLvyr4Tha/bDJ2FOgvx 3:XgnLqhV6tNwE+WAFBR0Ng0LT04AguWL1EnSB8X4widjEJg2cuOe1tlB80xM4CrjQbgOj4 3:FTY2XscNigtuVk4Ryjosq8hQNagDGmWZZySyQWdgPZ5ss0wRssLdv8lv6iFwiO4KBRFIB 3:49U6jo1nDuBOnk4dR9G4M5QKLeBPuDKZ8XAutDu13fWF3khssfijvEu5Vc8/IiYaDVvW+ 3:H/8AqpnBRZAd1VwPRYAfLgw/vh3iGMAVjFCXgw0k55koCxQhVd1RclQlUwDPftx2xwRrM 3:QBTyoA4UokWRcFhFUFHRACwFJFWIJX5clAeX8E1cAxF6sAgJ5HA8cT6bonoXB0XigyVP0 3:Q1I0iBw0XHWtGgHshjpQhQiKAoyxTsAIUEdiCUwZ0cr8xToIx0plAPSQA63lTCd9XdH8x 3:PtwyZxlxN2Q35lGBKV0Q5bVUfP9wmiNRV50QWboCP7ZXmb4iKrczpD+E3QQk+M1ReUR1H 3:jdoSaUXFygUs74SKq4HpCWDV7kQpZBwJkED9rdlDWh0OTAi0toTW1AnjpNxzlQy8ukv9R 3:idFBZrJYDXcY6/YqgHgDhuYKntKHBaILV0N3QKAsZocoW5ITpUEcC4JRBiQ9UNMpttEoy 3:5J6F8F2TecqxfNY4iQh+uYpbbI2xjNQUvUqIqYHbQZSZCRTbvMzlFQbeTEQNiBNoXYgok 3:VJoCNwcPEa5QZ4ObZSkQMQVbcKEahP9NVOCcI3o4GAkIRvM4BPBfNNbAIRaiId4PEUxCI 3:Q9fdjxqQXVIAiKKVj+pRq+DEVCURDC/kYNFBxPdIdP/VyTjEYecEXtbN0dABO4DhM5mRm 3:yxRQEwUoVjM/mgckXdF2nNZIbdB5kHGOrPAQxsM4yJhdFqVP5wVi7wWTB/RSVhH/eDEEA 3:m4WA4yYXyuWL/egg2RBV3t4B5TASTNpURnFT0e2FaNojqd4HDyoeW1ACrjkQmmGStCALh 3:coVKrhSkqZlAFlR2w0FKYmOS03UXCCItsSJfLgJv0hZPGyHeaGgL9TllLWlEw0CisUXGU 3:QI9nhHsIgCH/xHw6JIBlGhqzkH9WBgEC0KKsWEN9kdnMGJLywPwpBfLOgkjPhGmtRGilU 3:FhOhA8dSgFcjDRhTKIthO1t4DHSzlZtJMNXjjNVGKvuXPuCWDg0xFAK4HFzwIOyUBos2C 3:LAYFviYAbuWByTULFrWikPyJVShHuI0PNA2JLFxattVOF4DQ6UBkghiWWdi5SOBGQdapn 3:LbdSumUCnYozxEYDsKIUsCopFw4oyEoSTIYB6hsj7aIYOfVpz40VthB5Ru8lpjRAxEECW 3:5EAI1FB4bwwGHpIgl+iy/dYZuUokmWjXYoy44t3SmEaNgkCVBcwLfIBf9iKM4UFxywaOu 3:50JAOgT/xINaUUcOeqS6AjwuaomD+J5OCgNveUckajccWKU0EBdDlQKMIz5c2nbWF6Ujo 3:DYwOqZbdhItEChqqitG4IotYG5v6gLpx6Aygad1aqd72qd++qeAGqiCOqiEWqiGeqiImq 3:iKuqiM2qiO+qiQGqlyEAEAOw== 1:Bank details: 2:Account holder: Joan Costa Mombiela 2:Account number: 0000-0000-00-000000000
Usefulness
The usefulness of compaction is to create a slightly more efficient format, which is just as easy to read and write by humans. With level numbers it is also very easy to read, and for machines, it has some advantages:
- The file size is usually lower.
- The file parsing is faster, as there is no need to calculate the level through tabs (or spaces).
It can also be used in file transformations, but we will see this further ahead (Chapter 7).


Welcome To My First Website!
This is my website after 1 week of Epicodus.
*Hobbies*Skills*Interests*
*Credits*Mentions*Contact Info*
-About Me-
-Various Things I Do And Like-
Photography!
These are my favorite subjects to photograph:
- Landscape Photography:
- Mountains
- Rivers
- Coastal Beaches
- Deep Forests
- Golden Hour (Sunset)
- Macro-Photography:
- Everyday Objects
- Textiles and Fabrics
- Flora
- Insects
- Aerial Photography:
- Cityscape
- Natural Enviroments
- Top-down Shots
- Wide-angle Shots
- Panoramics
Quick kitty break! Want to see my kitty?
"Dang. That is a nice kitty!"
- Everyone
Cooking Food!
My favorite foods to cook are:
- Southern Cooking
- American Grilled
- Comfort Food
- Italian Food
- Mexican Food
Video Games!
These are my favorite genres, starting with my most played:
- Single-Player Narrative
- RPG (Role Playing Games)
- Open World
- Simulation
Music!
I love listening to these groups and their respective genres:
- Metal
- The Contortionist
- Thy Art Is Murder
- Electronic
- Above & Beyond
- Ajunadeep
- DJ Tiesto
- Nox Vahn
Come back and visit often to check on my progress!
Back To Top


Filters enable controllers to run shared pre- and post-processing code for its actions. These filters can be used to do authentication, caching, or auditing before the intended action is performed. Or to do localization or output compression after the action has been performed. Filters have access to the request, response, and all the instance variables set by other filters in the chain or by the action (in the case of after filters).
Filter inheritance
Controller inheritance hierarchies share filters downwards, but subclasses can also add or skip filters without affecting the superclass. For example:
class BankController < ActionController::Base before_filter :audit private def audit # record the action and parameters in an audit log end end class VaultController < BankController before_filter :verify_credentials private def verify_credentials # make sure the user is allowed into the vault end end
Now any actions performed on the BankController will have the audit method called before. On the VaultController, first the audit method is called, then the verify_credentials method. If the audit method renders or redirects, then verify_credentials and the intended action are never called.
Filter types
A filter can take one of three forms: method reference (symbol), external class, or inline method (proc). The first is the most common and works by referencing a protected or private method somewhere in the inheritance hierarchy of the controller by use of a symbol. In the bank example above, both BankController and VaultController use this form.
Using an external class makes for more easily reused generic filters, such as output compression. External filter classes are implemented by having a static filter method on any class and then passing this class to the filter method. Example:
class OutputCompressionFilter def self.filter(controller) controller.response.body = compress(controller.response.body) end end class NewspaperController < ActionController::Base after_filter OutputCompressionFilter end
The filter method is passed the controller instance and is hence granted access to all aspects of the controller and can manipulate them as it sees fit.
The inline method (using a proc) can be used to quickly do something small that doesn‘t require a lot of explanation. Or just as a quick test. It works like this:
class WeblogController < ActionController::Base before_filter { |controller| head(400) if controller.params["stop_action"] } end
As you can see, the block expects to be passed the controller after it has assigned the request to the internal variables. This means that the block has access to both the request and response objects complete with convenience methods for params, session, template, and assigns. Note: The inline method doesn‘t strictly have to be a block; any object that responds to call and returns 1 or -1 on arity will do (such as a Proc or an Method object).
Please note that around_filters function a little differently than the normal before and after filters with regard to filter types. Please see the section dedicated to around_filters below.
Filter chain ordering
Using before_filter and after_filter appends the specified filters to the existing chain. That‘s usually just fine, but some times you care more about the order in which the filters are executed. When that‘s the case, you can use prepend_before_filter and prepend_after_filter. Filters added by these methods will be put at the beginning of their respective chain and executed before the rest. For example:
class ShoppingController < ActionController::Base before_filter :verify_open_shop class CheckoutController < ShoppingController prepend_before_filter :ensure_items_in_cart, :ensure_items_in_stock
The filter chain for the CheckoutController is now :ensure_items_in_cart, :ensure_items_in_stock, :verify_open_shop. So if either of the ensure filters renders or redirects, we‘ll never get around to see if the shop is open or not.
You may pass multiple filter arguments of each type as well as a filter block. If a block is given, it is treated as the last argument.
Around filters
Around filters wrap an action, executing code both before and after. They may be declared as method references, blocks, or objects responding to filter or to both before and after.
To use a method as an around_filter, pass a symbol naming the Ruby method. Yield (or block.call) within the method to run the action.
around_filter :catch_exceptions private def catch_exceptions yield rescue => exception logger.debug "Caught exception! #{exception}" raise end
To use a block as an around_filter, pass a block taking as args both the controller and the action block. You can‘t call yield directly from an around_filter block; explicitly call the action block instead:
around_filter do |controller, action| logger.debug "before #{controller.action_name}" action.call logger.debug "after #{controller.action_name}" end
To use a filter object with around_filter, pass an object responding to :filter or both :before and :after. With a filter method, yield to the block as above:
around_filter BenchmarkingFilter class BenchmarkingFilter def self.filter(controller, &block) Benchmark.measure(&block) end end
With before and after methods:
around_filter Authorizer.new class Authorizer # This will run before the action. Redirecting aborts the action. def before(controller) unless user.authorized? redirect_to(login_url) end end # This will run after the action if and only if before did not render or redirect. def after(controller) end end
If the filter has before and after methods, the before method will be called before the action. If before renders or redirects, the filter chain is halted and after will not be run. See Filter Chain Halting below for an example.
Filter chain skipping
Declaring a filter on a base class conveniently applies to its subclasses, but sometimes a subclass should skip some of its superclass’ filters:
class ApplicationController < ActionController::Base before_filter :authenticate around_filter :catch_exceptions end class WeblogController < ApplicationController # Will run the :authenticate and :catch_exceptions filters. end class SignupController < ApplicationController # Skip :authenticate, run :catch_exceptions. skip_before_filter :authenticate end class ProjectsController < ApplicationController # Skip :catch_exceptions, run :authenticate. skip_filter :catch_exceptions end class ClientsController < ApplicationController # Skip :catch_exceptions and :authenticate unless action is index. skip_filter :catch_exceptions, :authenticate, :except => :index end
Filter conditions
Filters may be limited to specific actions by declaring the actions to include or exclude. Both options accept single actions (:only => :index) or arrays of actions (:except => [:foo, :bar]).
class Journal < ActionController::Base # Require authentication for edit and delete. before_filter :authorize, :only => [:edit, :delete] # Passing options to a filter with a block. around_filter(:except => :index) do |controller, action_block| results = Profiler.run(&action_block) controller.response.sub! "", "#{results}" end private def authorize # Redirect to login unless authenticated. end end
Filter Chain Halting
before_filter and around_filter may halt the request before a controller action is run. This is useful, for example, to deny access to unauthenticated users or to redirect from HTTP to HTTPS. Simply call render or redirect. After filters will not be executed if the filter chain is halted.
Around filters halt the request unless the action block is called. Given these filters
after_filter :after around_filter :around before_filter :before
The filter chain will look like:
... . # . #around (code before yield) . . # . . #before (actual filter code is run) . . . # . . . execute controller action . . . / . . ... . . / . #around (code after yield) . / #after (actual filter code is run, unless the around filter does not yield)
If around returns before yielding, after will still not be run. The before filter and controller action will not be run. If before renders or redirects, the second half of around and will still run but after and the action will not. If around fails to yield, after will not be run.
- after_filter
- append_after_filter
- append_around_filter
- append_before_filter
- around_filter
- before_filter
- filter_chain
- prepend_after_filter
- prepend_around_filter
- prepend_before_filter
- skip_after_filter
- skip_before_filter
- skip_filter
Alias for append_after_filter
The passed filters will be appended to the array of filters that run after actions on this controller are performed.
[ show source ]
# File vendor/rails/actionpack/lib/action_controller/filters.rb, line 498 498: def append_after_filter(*filters, &block) 499: filter_chain.append_filter_to_chain(filters, :after, &block) 500: end
If you append_around_filter A.new, B.new, the filter chain looks like
B#before A#before # run the action A#after B#after
With around filters which yield to the action block, before and after are the code before and after the yield.
[ show source ]
# File vendor/rails/actionpack/lib/action_controller/filters.rb, line 521 521: def append_around_filter(*filters, &block) 522: filter_chain.append_filter_to_chain(filters, :around, &block) 523: end
The passed filters will be appended to the filter_chain and will execute before the action on this controller is performed.
[ show source ]
# File vendor/rails/actionpack/lib/action_controller/filters.rb, line 483 483: def append_before_filter(*filters, &block) 484: filter_chain.append_filter_to_chain(filters, :before, &block) 485: end
Alias for append_around_filter
Alias for append_before_filter
Returns an array of Filter objects for this controller.
[ show source ]
# File vendor/rails/actionpack/lib/action_controller/filters.rb, line 573 573: def filter_chain 574: if chain = read_inheritable_attribute('filter_chain') 575: return chain 576: else 577: write_inheritable_attribute('filter_chain', FilterChain.new) 578: return filter_chain 579: end 580: end
The passed filters will be prepended to the array of filters that run after actions on this controller are performed.
[ show source ]
# File vendor/rails/actionpack/lib/action_controller/filters.rb, line 504 504: def prepend_after_filter(*filters, &block) 505: filter_chain.prepend_filter_to_chain(filters, :after, &block) 506: end
If you prepend_around_filter A.new, B.new, the filter chain looks like:
A#before B#before # run the action B#after A#after
With around filters which yield to the action block, before and after are the code before and after the yield.
[ show source ]
# File vendor/rails/actionpack/lib/action_controller/filters.rb, line 535 535: def prepend_around_filter(*filters, &block) 536: filter_chain.prepend_filter_to_chain(filters, :around, &block) 537: end
The passed filters will be prepended to the filter_chain and will execute before the action on this controller is performed.
[ show source ]
# File vendor/rails/actionpack/lib/action_controller/filters.rb, line 489 489: def prepend_before_filter(*filters, &block) 490: filter_chain.prepend_filter_to_chain(filters, :before, &block) 491: end
Removes the specified filters from the after filter chain. Note that this only works for skipping method-reference filters, not procs. This is especially useful for managing the chain in inheritance hierarchies where only one out of many sub-controllers need a different hierarchy.
You can control the actions to skip the filter for with the :only and :except options, just like when you apply the filters.
[ show source ]
# File vendor/rails/actionpack/lib/action_controller/filters.rb, line 558 558: def skip_after_filter(*filters) 559: filter_chain.skip_filter_in_chain(*filters, &:after?) 560: end
Removes the specified filters from the before filter chain. Note that this only works for skipping method-reference filters, not procs. This is especially useful for managing the chain in inheritance hierarchies where only one out of many sub-controllers need a different hierarchy.
You can control the actions to skip the filter for with the :only and :except options, just like when you apply the filters.
[ show source ]
# File vendor/rails/actionpack/lib/action_controller/filters.rb, line 548 548: def skip_before_filter(*filters) 549: filter_chain.skip_filter_in_chain(*filters, &:before?) 550: end
Removes the specified filters from the filter chain. This only works for method reference (symbol) filters, not procs. This method is different from skip_after_filter and skip_before_filter in that it will match any before, after or yielding around filter.
You can control the actions to skip the filter for with the :only and :except options, just like when you apply the filters.
[ show source ]
# File vendor/rails/actionpack/lib/action_controller/filters.rb, line 568 568: def skip_filter(*filters) 569: filter_chain.skip_filter_in_chain(*filters) 570: end


All have same timing and duration
ease
ease-in
ease-out
ease-in-out
linear
step-start
step-end
step()


Moody's sees 'negative' outlook for German banks
'Banks' weak profitability will decline further as net interest income falls' amid low or negative interest rates set by the European Central Bank, Moody's vice-president Bernhard Held said in a statement.
Rating agency Moody's on Thursday slashed its outlook for German banks from "stable" to "negative", warning their profitability and creditworthiness would "decline" in the coming months.
"Banks' weak profitability will decline further as net interest income falls" amid low or negative interest rates set by the European Central Bank, Moody's vice-president Bernhard Held said in a statement.
While banks must for now set aside little cash to cover the risk of borrowers falling behind on payments, such charges are "unsustainably low", he judged.
Especially smaller banks that rely on customers' deposits for their funding are seeing profits sapped by low rates, which have prompted many bosses to blast the ECB for the policy.
Moody's noted that German banks "have had very limited success in improving their high cost-to-income ratios", spending around 80 euro cents for each euro of revenue in 2018.
Meanwhile, risk-averse depositors prefer to heap up cash in savings accounts rather than opt for riskier investments like stocks -- building deposits up to 40 percent of the sector's assets.
As banks cannot always find ways -- such as lending -- to put that cash to work in the real economy, they deposit large amounts with the ECB, which presently inflicts a negative interest rate of -0.5 per cent.
Banks have even been attempting to fend off new clients from opening accounts, passing on the negative rates to savers.
One Bavarian cooperative bank recently became the first to charge a negative rate from the first euro deposited in a savings account.