General Updates
This month there is a hobbyist / maker event, "Teardown" happening in Portland.
Teardown is about the practice of hardware prototyping, manufacturing, testing, and disassembling. Stephano will be giving a firmware presentation. Our hope is that we can find some maker boards that would be appropriate to support for our future CI efforts. These boards should be affordable and cover multiple architectures (ARM, x86).
Continuous Integration
Azure pipelines supports all our needs so that is our first candidate for CI. Azure does not have a caching capability, so each build is essentially from scratch, but they are looking to improve this and code is in the works. We're starting with "cloud" CI services so that we can get a good setup before we worry about buying hardware, spinning up our own infra, keeping things maintained, etc.
We recognize that creating a complete CI environment, unit test infrastructure, functional tests, and regression test is a very large task. Instead of working on all of this all at once we are breaking out pieces so as to do this one step at a time. Basic build services are first.
Andrew Fish recommended that we find a way to easily evaluate development branches. He suggested a command line tool (probably python) that a maintainer could invoke to generate builds against a branch. However, if we open it up to the world we would crush our CI server, so we need to restrict it to maintainers. This will also force us to think about how we do builds and how we can standardize across platforms, rather than having each platform “roll their own” build process.
If you're aware of other CI services, please let us know. (Cirrus CI does not cover all 3 OSs)
Hard Freeze / Stable Tag
In an effort to avoid policing the maintainers, we will be creating a release meeting before each soft freeze to assure that everyone is aligned. The stewards and maintainers will meet to discuss what is in scope and we can discuss any patches that are currently under review. Our goal is to achieve clear communications and avoid revert commits as much as possible. See the release planning page for upcoming details:
Also, it has been noted that many contributions have been coming in that do not meet our standards. It is easy to forget what correct contributions should look like. Please review our code contribution guidelines:
As developers, it’s important to refresh our memory from time to time on these formalities in order to assure our workflow is as seamless as possible.
TianoCore Mailling Lists
We have added two new mailing lists: discuss & rfc. The goal is to keep the `devel` list as close as possible to pure patch review and developer discussion. Please post your RFCs to the new `rfc` list, and CC the devel list so that those who have not joined the new list will see your discussion. We encourage folks new to the group, or those with questions that may not be of an engineering / development nature, to post to the `discuss` list.
We realize that for those of you who simply use MUAs to read the list, this change is not a big win. However, for those using the web interface (Groups.io), keeping these topics separate will make for a cleaner user experience.
EDK2 Core Cleanup
We continue to move non-essential items out of the edk2 tree and into edk2-platforms as appropriate. June will be the majority of the movement so that things can stabilize for the august release. Some of those are out for discussion (FSP, Silicon). Any comments are welcome, in terms of the general goal: EDK2 is common to all platforms and emulation, as well as QEMU OVMF. The rest of the platform code will live in edk2-platforms. The end goal will be to CI EDK2 only, so as to validate the core. Then the physical platform code can be CI'd separately.
Documentation
Rebecca is hosting the Doxygen docs from packages on her server, and it is probably better if we use a cloud service to host these, or better yet, our current gitbooks system. However, there is a small issue with the way Doxygen changes folder structures between builds. Since we would be checking this into git (see: gitbook/TianoCore-Docs), it would cause a lot of git history thrashing. Mike has found ways around this, however we want to be sure that searching (particularly across packages) would be possible before we go down this road.
Action Items
Rebecca: Look into adding BSD as a supported platform. Ping Stephano if documentation changes are needed.
Stephano: Update the “about” branch as it is out of date
Stephano: Send out an invite to maintainers for the next “soft freeze” release meeting


Atexta
| MyAtexta.com | See the skill in action!Alexa skill that allows users to send customizable group messages using voice commands
- Built web application that interfaces with the Alexa skill, allowing users to create and update their personal contacts, groups, and messages that they can send using their Alexa device
- Designed, scaffolded, and built out the inner workings of the Alexa skill using the AWS Lambda service
- Set up integration with Mailgun and Twilio API’s for easy usability and seamless user experience


QPushButton Class
The QPushButton widget provides a command button. More...
| Header: | #include <QPushButton> |
| qmake: | QT += widgets |
| Inherits: | QAbstractButton |
| Inherited By: |
Properties
- autoDefault : bool
- default : bool
- flat : bool
- 11 properties inherited from QAbstractButton
- 59 properties inherited from QWidget
- 1 property inherited from QObject
Public Functions
| QPushButton(QWidget *parent = Q_NULLPTR) | |
| QPushButton(const QString &text, QWidget *parent = Q_NULLPTR) | |
| QPushButton(const QIcon &icon, const QString &text, QWidget *parent = Q_NULLPTR) | |
| ~QPushButton() | |
| bool | autoDefault() const |
| bool | isDefault() const |
| bool | isFlat() const |
| QMenu * | menu() const |
| void | setAutoDefault(bool) |
| void | setDefault(bool) |
| void | setFlat(bool) |
| void | setMenu(QMenu *menu) |
Reimplemented Public Functions
| virtual QSize | minimumSizeHint() const |
| virtual QSize | sizeHint() const |
- 21 public functions inherited from QAbstractButton
- 214 public functions inherited from QWidget
- 32 public functions inherited from QObject
- 14 public functions inherited from QPaintDevice
Public Slots
| void | showMenu() |
- 5 public slots inherited from QAbstractButton
- 19 public slots inherited from QWidget
- 1 public slot inherited from QObject
Protected Functions
| void | initStyleOption(QStyleOptionButton *option) const |
Reimplemented Protected Functions
| virtual bool | event(QEvent *e) |
| virtual void | focusInEvent(QFocusEvent *e) |
| virtual void | focusOutEvent(QFocusEvent *e) |
| virtual void | keyPressEvent(QKeyEvent *e) |
| virtual void | paintEvent(QPaintEvent *) |
- 14 protected functions inherited from QAbstractButton
- 35 protected functions inherited from QWidget
- 9 protected functions inherited from QObject
- 1 protected function inherited from QPaintDevice
Additional Inherited Members
- 4 signals inherited from QAbstractButton
- 3 signals inherited from QWidget
- 2 signals inherited from QObject
- 1 public variable inherited from QObject
- 5 static public members inherited from QWidget
- 10 static public members inherited from QObject
- 1 protected slot inherited from QWidget
- 2 protected variables inherited from QObject
- 1 protected type inherited from QPaintDevice
Detailed Description
The QPushButton widget provides a command button.
[Missing image windows-pushbutton.jpg]
The push button, or command button, is perhaps the most commonly used widget in any graphical user interface. Push (click) a button to command the computer to perform some action, or to answer a question. Typical buttons are OK, Apply, Cancel, Close, Yes, No and Help.
A command button is rectangular and typically displays a text label describing its action. A shortcut key can be specified by preceding the preferred character with an ampersand in the text. For example:
QPushButton *button = new QPushButton("&Download", this);
In this example the shortcut is Alt+D. See the QShortcut documentation for details (to display an actual ampersand, use '&&').
Push buttons display a textual label, and optionally a small icon. These can be set using the constructors and changed later using setText() and setIcon(). If the button is disabled, the appearance of the text and icon will be manipulated with respect to the GUI style to make the button look "disabled".
A push button emits the signal clicked() when it is activated by the mouse, the Spacebar or by a keyboard shortcut. Connect to this signal to perform the button's action. Push buttons also provide less commonly used signals, for example pressed() and released().
Command buttons in dialogs are by default auto-default buttons, i.e., they become the default push button automatically when they receive the keyboard input focus. A default button is a push button that is activated when the user presses the Enter or Return key in a dialog. You can change this with setAutoDefault(). Note that auto-default buttons reserve a little extra space which is necessary to draw a default-button indicator. If you do not want this space around your buttons, call setAutoDefault(false).
Being so central, the button widget has grown to accommodate a great many variations in the past decade. The Microsoft style guide now shows about ten different states of Windows push buttons and the text implies that there are dozens more when all the combinations of features are taken into consideration.
The most important modes or states are:
- Available or not (grayed out, disabled).
- Standard push button, toggling push button or menu button.
- On or off (only for toggling push buttons).
- Default or normal. The default button in a dialog can generally be "clicked" using the Enter or Return key.
- Auto-repeat or not.
- Pressed down or not.
As a general rule, use a push button when the application or dialog window performs an action when the user clicks on it (such as Apply, Cancel, Close and Help) and when the widget is supposed to have a wide, rectangular shape with a text label. Small, typically square buttons that change the state of the window rather than performing an action (such as the buttons in the top-right corner of the QFileDialog) are not command buttons, but tool buttons. Qt provides a special class (QToolButton) for these buttons.
If you need toggle behavior (see setCheckable()) or a button that auto-repeats the activation signal when being pushed down like the arrows in a scroll bar (see setAutoRepeat()), a command button is probably not what you want. When in doubt, use a tool button.
Note: On macOS when a push button's width becomes smaller than 50 or its height becomes smaller than 30, the button's corners are changed from round to square. Use the setMinimumSize() function to prevent this behavior.
A variation of a command button is a menu button. These provide not just one command, but several, since when they are clicked they pop up a menu of options. Use the method setMenu() to associate a popup menu with a push button.
Other classes of buttons are option buttons (see QRadioButton) and check boxes (see QCheckBox).
In Qt, the QAbstractButton base class provides most of the modes and other API, and QPushButton provides GUI logic. See QAbstractButton for more information about the API.
See also QToolButton, QRadioButton, QCheckBox, and GUI Design Handbook: Push Button.
Property Documentation
autoDefault : bool
This property holds whether the push button is an auto default button
If this property is set to true then the push button is an auto default button.
In some GUI styles a default button is drawn with an extra frame around it, up to 3 pixels or more. Qt automatically keeps this space free around auto-default buttons, i.e., auto-default buttons may have a slightly larger size hint.
This property's default is true for buttons that have a QDialog parent; otherwise it defaults to false.
See the default property for details of how default and auto-default interact.
Access functions:
| bool | autoDefault() const |
| void | setAutoDefault(bool) |
default : bool
This property holds whether the push button is the default button
Default and autodefault buttons decide what happens when the user presses enter in a dialog.
A button with this property set to true (i.e., the dialog's default button,) will automatically be pressed when the user presses enter, with one exception: if an autoDefault button currently has focus, the autoDefault button is pressed. When the dialog has autoDefault buttons but no default button, pressing enter will press either the autoDefault button that currently has focus, or if no button has focus, the next autoDefault button in the focus chain.
In a dialog, only one push button at a time can be the default button. This button is then displayed with an additional frame (depending on the GUI style).
The default button behavior is provided only in dialogs. Buttons can always be clicked from the keyboard by pressing Spacebar when the button has focus.
If the default property is set to false on the current default button while the dialog is visible, a new default will automatically be assigned the next time a push button in the dialog receives focus.
This property's default is false.
Access functions:
| bool | isDefault() const |
| void | setDefault(bool) |
flat : bool
This property holds whether the button border is raised
This property's default is false. If this property is set, most styles will not paint the button background unless the button is being pressed. setAutoFillBackground() can be used to ensure that the background is filled using the QPalette::Button brush.
Access functions:
| bool | isFlat() const |
| void | setFlat(bool) |
Member Function Documentation
QPushButton::QPushButton(QWidget *parent = Q_NULLPTR)
Constructs a push button with no text and a parent.
QPushButton::QPushButton(const QString &text, QWidget *parent = Q_NULLPTR)
Constructs a push button with the parent parent and the text text.
QPushButton::QPushButton(const QIcon &icon, const QString &text, QWidget *parent = Q_NULLPTR)
Constructs a push button with an icon and a text, and a parent.
Note that you can also pass a QPixmap object as an icon (thanks to the implicit type conversion provided by C++).
QPushButton::~QPushButton()
Destroys the push button.
[virtual protected]
bool QPushButton::event(QEvent *e)
Reimplemented from QObject::event().
[virtual protected]
void QPushButton::focusInEvent(QFocusEvent *e)
Reimplemented from QWidget::focusInEvent().
[virtual protected]
void QPushButton::focusOutEvent(QFocusEvent *e)
Reimplemented from QWidget::focusOutEvent().
[protected]
void QPushButton::initStyleOption(QStyleOptionButton *option) const
Initialize option with the values from this QPushButton. This method is useful for subclasses when they need a QStyleOptionButton, but don't want to fill in all the information themselves.
See also QStyleOption::initFrom().
[virtual protected]
void QPushButton::keyPressEvent(QKeyEvent *e)
Reimplemented from QWidget::keyPressEvent().
QMenu *QPushButton::menu() const
Returns the button's associated popup menu or 0 if no popup menu has been set.
See also setMenu().
[virtual]
QSize QPushButton::minimumSizeHint() const
Reimplemented from QWidget::minimumSizeHint().
[virtual protected]
void QPushButton::paintEvent(QPaintEvent *)
Reimplemented from QWidget::paintEvent().
void QPushButton::setMenu(QMenu *menu)
Associates the popup menu menu with this push button. This turns the button into a menu button, which in some styles will produce a small triangle to the right of the button's text.
Ownership of the menu is not transferred to the push button.
A push button with popup menus shown in the Fusion widget style.
See also menu().
[slot]
void QPushButton::showMenu()
Shows (pops up) the associated popup menu. If there is no such menu, this function does nothing. This function does not return until the popup menu has been closed by the user.
[virtual]
QSize QPushButton::sizeHint() const
Reimplemented from QWidget::sizeHint().


Top trading ideas by CapitalVia Global Research: Buy TCS, Pidilite
Technical Calls by Gaurav Garg, Head of Research at CapitalVia Global Research Limited- Investment Advisor
by Gaurav GargGrueling optimism of Market towards newer highs driven by RIL and Pharma stocks – Time to stay cautious
The Nifty traded near the important resistance level of 12,000 on Wednesday and if it is able to sustain above this level in the coming trading sessions, it will set the path towards a newer high surpassing the previous high of 12,103. Reliance Industries (RIL),and pharma stocks traded with positive sentiments throughout the day and gained most among indices. Nifty bank closed flat at 31,341 as compared to its opening of 31,340. If we look at crude oil prices, it has come down sharply over the last two trading sessions because of surge in US inventory.
From option chain we can observe that maximum put open interest was seen at 11,900 followed by 11,800 strike, while maximum Call open interest was seen at 12,000 followed by 12,200 strike. For this week, we can expect a range-bound movement of market and some profit booking in PSU bank stocks and pharma stocks.
In the current market scenario, we see some upside movement in the following stocks:
Buy TCS: (Above Rs. 2,140)
Target: Rs 2,190
Stop loss: Rs 2,090
The stock is showing signals of reversal from lower zones, with the support of 200 EMA. Breaking the immediate resistance of 2,140 will bring an upside momentum in the stock. Considering the technical evidence discussed above, we recommend buying the stock above RS 2,140 for the target of Rs 2,190, keeping a stop loss at Rs 2,090 on a closing basis.
Buy Pidilite Industries Limited: (Above Rs 1,334)
Target: Rs 1,420
Stop loss: Rs 1,280
The stock is showing signals of reversal from lower zones, with the support of 200 EMA. Breaking the immediate resistance of 1,334 will bring an upside momentum in the stock. Considering the technical evidence discussed above, we recommend buying the stock above Rs 1,334 for the target of Rs 1420, keeping a stop loss at Rs 1,280 on a closing basis.
Disclaimer: The analyst does not hold position in any of the stocks mentioned above.


Let me tell you a little about me!
I was born in Ciudad Juarez, Chihuahua, Mexico.  Yet if you ask me where I'm from I would say that from everywhere. I've lived in two countries, four states, about six cities, and ten houses. Impressive huh? Although the constant moving came with its issues, I learned to adapt to unknown enviroments/situations, I met people from different backgrounds, among other things. So yeah... that's me in a nutshell.
Now there is two things I love; Basketball and computers.  In the other hand both my parent are software engineers so naturally computers were a given. Since my height wont help me to play at the NBA I aspire to become a software engineer.
Which leads us to my educaiton. I was in Mexico up to middle school. After that I moved to California where I got my High School diploma and enrolled in a comunity college planning to transfere to UCSD to get a B.S. in computer science. Sadly there was some missunderstandigs with my student visa so I had to take my career goal and continue it in Mexico at El Tecnologico de Monterrey where I'm a sophmore now.
Education (relevant classes)
Tecnologico de Monterrey
August 2019 - August 2023
- Pensamiento computacional y programación(Python)
- Programación Orientada a Objetos (C++).
- Implementación de internet de las cosas.
- Estructura de datos y algoritmosfundamentales(C++).
- Análisis de requerimientos de software.
Computational thinking and programming(Python).
Object Oriented Programming (C++).
Implementation of internet of things.
Data structures and fundamental algorithms(C++).
Software requirements analysis.
Diablo Valley College
2016 - 2018
- Introduction to programming (C++).
- Advanced programming with C and C++.
Other
- CS50's Introduction to AI with Python.
- Wireshark: Packet Analysis and Ethical Hacking: Core Skills.
HarvardX
Udemy
Projects
SECOM LAN application (In development).
Python based application to keep track of the inventory for a small company dedicated to electric installations.
bIoT.
IoT network of garbage containers for the recollection of data to train AI to increase efficiency of garbage recollection routes inside school campus.
LAN server
With help of docer containers and open source software I configure my raspberry pi as a NAS server as well as a network wide filter for ads.
Search streaming services.
Object oriented C++ console application for searching and rating movies and series.
Hangman.
Python console game for a second-degree equation-based hangman.
Help me to get better
I'm more of a back-end person. Please feel free to give feedback or ideas/challenges to make this website better and make me a better developer.


Titanic 2300 - rebooting
Document Id: KBDOC-00124
Created: 2011-02-18
Updated: 2011-02-19
Titanic 2300 rebooting
Sometimes your phone may reboot. This is perfectly normal and perfectly healthy. It keeps the phone working in top condition.
Reboots help
- Protect from viruses.
- Lower taxes.
- Give IT people a simple answer to all problems.
Tags: phone, rebooting, though, yours, than, than


Document Version: 1.0
29 April 1996
FastCGI is an open extension to CGI that provides high performance for all Internet applications without the penalties of Web server APIs.
This specification has narrow goal: to specify, from an application perspective, the interface between a FastCGI application and a Web server that supports FastCGI. Many Web server features related to FastCGI, e.g. application management facilities, have nothing to do with the application to Web server interface, and are not described here.
This specification is for Unix (more precisely, for POSIX systems that support Berkeley Sockets). The bulk of the specification is a simple communications protocol that is independent of byte ordering and will extend to other systems.
We'll introduce FastCGI by comparing it with conventional Unix implementations of CGI/1.1. FastCGI is designed to support long-lived application processes, i.e. application servers. That's a major difference compared with conventional Unix implementations of CGI/1.1, which construct an application process, use it respond to one request, and have it exit.
The initial state of a FastCGI process is more spartan than the initial state of a CGI/1.1 process, because the FastCGI process doesn't begin life connected to anything. It doesn't have the conventional open files stdin, stdout, and stderr, and it doesn't receive much information through environment variables. The key piece of initial state in a FastCGI process is a listening socket, through which it accepts connections from a Web server.
After a FastCGI process accepts a connection on its listening socket, the process executes a simple protocol to receive and send data. The protocol serves two purposes. First, the protocol multiplexes a single transport connection between several independent FastCGI requests. This supports applications that are able to process concurrent requests using event-driven or multi-threaded programming techniques. Second, within each request the protocol provides several independent data streams in each direction. This way, for instance, both stdout and stderr data pass over a single transport connection from the application to the Web server, rather than requiring separate pipes as with CGI/1.1.
A FastCGI application plays one of several well-defined roles. The most familiar is the Responder role, in which the application receives all the information associated with an HTTP request and generates an HTTP response; that's the role CGI/1.1 programs play. A second role is Authorizer, in which the application receives all the information associated with an HTTP request and generates an authorized/unauthorized decision. A third role is Filter, in which the application receives all the information associated with an HTTP request, plus an extra stream of data from a file stored on the Web server, and generates a "filtered" version of the data stream as an HTTP response. The framework is extensible so that more FastCGI can be defined later.
In the remainder of this specification the terms "FastCGI application," "application process," or "application server" are abbreviated to "application" whenever that won't cause confusion.
By default the Web server creates an argument list containing a single element, the name of the application, taken to be the last component of the executable's path name. The Web server may provide a way to specify a different application name, or a more elaborate argument list.
Note that the file executed by the Web server might be an interpreter file (a text file that starts with the characters #!), in which case the application's argument list is constructed as described in the execve manpage.
The Web server leaves a single file descriptor, FCGI_LISTENSOCK_FILENO, open when the application begins execution. This descriptor refers to a listening socket created by the Web server.
FCGI_LISTENSOCK_FILENO equals STDIN_FILENO. The standard descriptors STDOUT_FILENO and STDERR_FILENO are closed when the application begins execution. A reliable method for an application to determine whether it was invoked using CGI or FastCGI is to call getpeername(FCGI_LISTENSOCK_FILENO), which returns -1 with errno set to ENOTCONN for a FastCGI application.
The Web server's choice of reliable transport, Unix stream pipes (AF_UNIX) or TCP/IP (AF_INET), is implicit in the internal state of the FCGI_LISTENSOCK_FILENO socket.
The Web server may use environment variables to pass parameters to the application. This specification defines one such variable, FCGI_WEB_SERVER_ADDRS; we expect more to be defined as the specification evolves. The Web server may provide a way to bind other environment variables, such as the PATH variable.
The Web server may provide a way to specify other components of an application's initial process state, such as the priority, user ID, group ID, root directory, and working directory of the process.
We use C language notation to define protocol message formats. All structure elements are defined in terms of the unsigned char type, and are arranged so that an ISO C compiler lays them out in the obvious manner, with no padding. The first byte defined in the structure is transmitted first, the second byte second, etc.
We use two conventions to abbreviate our definitions.
First, when two adjacent structure components are named identically except for the suffixes "B1" and "B0," it means that the two components may be viewed as a single number, computed as B1<<8 + B0. The name of this single number is the name of the components, minus the suffixes. This convention generalizes in an obvious way to handle numbers represented in more than two bytes.
Second, we extend C structs to allow the form
struct { unsigned char mumbleLengthB1; unsigned char mumbleLengthB0; ... /* other stuff */ unsigned char mumbleData[mumbleLength]; };
meaning a structure of varying length, where the length of a component is determined by the values of the indicated earlier component or components.
A FastCGI application calls accept() on the socket referred to by file descriptor FCGI_LISTENSOCK_FILENO to accept a new transport connection. If the accept() succeeds, and the FCGI_WEB_SERVER_ADDRS environment variable is bound, the application application immediately performs the following special processing:
If FCGI_WEB_SERVER_ADDRS was bound, the application checks the peer IP address of the new connection for membership in the list. If the check fails (including the possibility that the connection didn't use TCP/IP transport), the application responds by closing the connection.
FCGI_WEB_SERVER_ADDRS is expressed as a comma-separated list of IP addresses. Each IP address is written as four decimal numbers in the range [0..255] separated by decimal points. So one legal binding for this variable is FCGI_WEB_SERVER_ADDRS=<IP_ADDRESS>,<IP_ADDRESS>.
An application may accept several concurrent transport connections, but it need not do so.
Applications execute requests from a Web server using a simple protocol. Details of the protocol depend upon the application's role, but roughly speaking the Web server first sends parameters and other data to the application, then the application sends result data to the Web server, and finally the application sends the Web server an indication that the request is complete.
All data that flows over the transport connection is carried in FastCGI records. FastCGI records accomplish two things. First, records multiplex the transport connection between several independent FastCGI requests. This multiplexing supports applications that are able to process concurrent requests using event-driven or multi-threaded programming techniques. Second, records provide several independent data streams in each direction within a single request. This way, for instance, both stdout and stderr data can pass over a single transport connection from the application to the Web server, rather than requiring separate connections.
typedef struct { unsigned char version; unsigned char type; unsigned char requestIdB1; unsigned char requestIdB0; unsigned char contentLengthB1; unsigned char contentLengthB0; unsigned char paddingLength; unsigned char reserved; unsigned char contentData[contentLength]; unsigned char paddingData[paddingLength]; } FCGI_Record;
A FastCGI record consists of a fixed-length prefix followed by a variable number of content and padding bytes. A record contains seven components:
We use a relaxed C struct initializer syntax to specify constant FastCGI records. We omit the version component, ignore padding, and treat requestId as a number. Thus {FCGI_END_REQUEST, 1, {FCGI_REQUEST_COMPLETE,0}} is a record with type == FCGI_END_REQUEST, requestId == 1, and contentData == {FCGI_REQUEST_COMPLETE,0}.
The protocol allows senders to pad the records they send, and requires receivers to interpret the paddingLength and skip the paddingData. Padding allows senders to keep data aligned for more efficient processing. Experience with the X window system protocols shows the performance benefit of such alignment.
We recommend that records be placed on boundaries that are multiples of eight bytes. The fixed-length portion of a FCGI_Record is eight bytes.
The Web server re-uses FastCGI request IDs; the application keeps track of the current state of each request ID on a given transport connection. A request ID R becomes active when the application receives a record {FCGI_BEGIN_REQUEST, R, ...} and becomes inactive when the application sends a record {FCGI_END_REQUEST, R, ...} to the Web server.
While a request ID R is inactive, the application ignores records with requestId == R, except for FCGI_BEGIN_REQUEST records as just described.
The Web server attempts to keep FastCGI request IDs small. That way the application can keep track of request ID states using a short array rather than a long array or a hash table. An application also has the option of accepting only one request at a time. In this case the application simply checks incoming requestId values against the current request ID.
There are two useful ways of classifying FastCGI record types.
The first distinction is between management records and application records. A management record contains information that is not specific to any Web server request, such as information about the protocol capabilities of the application. An application record contains information about a particular request, identified by the requestId component.
Management records have a requestId value of zero, also called the null request ID. Application records have a nonzero requestId.
The second distinction is between discrete and stream records. A discrete record contains a meaningful unit of data all by itself. A stream record is part of a stream, i.e. a series of zero or more non-empty records (length != 0) of the stream type, followed by an empty record (length == 0) of the stream type. The contentData components of a stream's records, when concatenated, form a byte sequence; this byte sequence is the value of the stream. Therefore the value of a stream is independent of how many records it contains or how its bytes are divided among the non-empty records.
These two classifications are independent. Among the record types defined in this version of the FastCGI protocol, all management record types are also discrete record types, and nearly all application record types are stream record types. But three application record types are discrete, and nothing prevents defining a management record type that's a stream in some later version of the protocol.
In many of their roles, FastCGI applications need to read and write varying numbers of variable-length values. So it is useful to adopt a standard format for encoding a name-value pair.
FastCGI transmits a name-value pair as the length of the name, followed by the length of the value, followed by the name, followed by the value. Lengths of 127 bytes and less can be encoded in one byte, while longer lengths are always encoded in four bytes:
typedef struct { unsigned char nameLengthB0; /* nameLengthB0 >> 7 == 0 */ unsigned char valueLengthB0; /* valueLengthB0 >> 7 == 0 */ unsigned char nameData[nameLength]; unsigned char valueData[valueLength]; } FCGI_NameValuePair11; typedef struct { unsigned char nameLengthB0; /* nameLengthB0 >> 7 == 0 */ unsigned char valueLengthB3; /* valueLengthB3 >> 7 == 1 */ unsigned char valueLengthB2; unsigned char valueLengthB1; unsigned char valueLengthB0; unsigned char nameData[nameLength]; unsigned char valueData[valueLength ((B3 & 0x7f) << 24) + (B2 << 16) + (B1 << 8) + B0]; } FCGI_NameValuePair14; typedef struct { unsigned char nameLengthB3; /* nameLengthB3 >> 7 == 1 */ unsigned char nameLengthB2; unsigned char nameLengthB1; unsigned char nameLengthB0; unsigned char valueLengthB0; /* valueLengthB0 >> 7 == 0 */ unsigned char nameData[nameLength ((B3 & 0x7f) << 24) + (B2 << 16) + (B1 << 8) + B0]; unsigned char valueData[valueLength]; } FCGI_NameValuePair41; typedef struct { unsigned char nameLengthB3; /* nameLengthB3 >> 7 == 1 */ unsigned char nameLengthB2; unsigned char nameLengthB1; unsigned char nameLengthB0; unsigned char valueLengthB3; /* valueLengthB3 >> 7 == 1 */ unsigned char valueLengthB2; unsigned char valueLengthB1; unsigned char valueLengthB0; unsigned char nameData[nameLength ((B3 & 0x7f) << 24) + (B2 << 16) + (B1 << 8) + B0]; unsigned char valueData[valueLength ((B3 & 0x7f) << 24) + (B2 << 16) + (B1 << 8) + B0]; } FCGI_NameValuePair44;
The high-order bit of the first byte of a length indicates the length's encoding. A high-order zero implies a one-byte encoding, a one a four-byte encoding.
This name-value pair format allows the sender to transmit binary values without additional encoding, and enables the receiver to allocate the correct amount of storage immediately even for large values.
The Web server controls the lifetime of transport connections. The Web server can close a connection when no requests are active. Or the Web server can delegate close authority to the application (see FCGI_BEGIN_REQUEST). In this case the application closes the connection at the end of a specified request.
This flexibility accommodates a variety of application styles. Simple applications will process one request at a time and accept a new transport connection for each request. More complex applications will process concurrent requests, over one or multiple transport connections, and will keep transport connections open for long periods of time.
A simple application gets a significant performance boost by closing the transport connection when it has finished writing its response. The Web server needs to control the connection lifetime for long-lived connections.
When an application closes a connection or finds that a connection has closed, the application initiates a new connection.
The Web server can query specific variables within the application. The server will typically perform a query on application startup in order to to automate certain aspects of system configuration.
The application receives a query as a record {FCGI_GET_VALUES, 0, ...}. The contentData portion of a FCGI_GET_VALUES record contains a sequence of name-value pairs with empty values.
The application responds by sending a record {FCGI_GET_VALUES_RESULT, 0, ...} with the values supplied. If the application doesn't understand a variable name that was included in the query, it omits that name from the response.
FCGI_GET_VALUES is designed to allow an open-ended set of variables. The initial set provides information to help the server perform application and connection management:
An application may receive a FCGI_GET_VALUES record at any time. The application's response should not involve the application proper but only the FastCGI library.
The set of management record types is likely to grow in future versions of this protocol. To provide for this evolution, the protocol includes the FCGI_UNKNOWN_TYPE management record. When an application receives a management record whose type T it does not understand, the application responds with {FCGI_UNKNOWN_TYPE, 0, {T}}.
The contentData component of a FCGI_UNKNOWN_TYPE record has the form:
typedef struct { unsigned char type; unsigned char reserved[7]; } FCGI_UnknownTypeBody;
The type component is the type of the unrecognized management record.
The Web server sends a FCGI_BEGIN_REQUEST record to start a request.
The contentData component of a FCGI_BEGIN_REQUEST record has the form:
typedef struct { unsigned char roleB1; unsigned char roleB0; unsigned char flags; unsigned char reserved[5]; } FCGI_BeginRequestBody;
The role component sets the role the Web server expects the application to play. The currently-defined roles are:
Roles are described in more detail in Section 6 below.
The flags component contains a bit that controls connection shutdown:
is a stream record type used in sending name-value pairs from the Web server to the application. The name-value pairs are sent down the stream one after the other, in no specified order.
is a stream record type used in sending arbitrary data from the Web server to the application. FCGI_DATA is a second stream record type used to send additional data to the application.
FCGI_STDOUT and FCGI_STDERR are stream record types for sending arbitrary data and error data respectively from the application to the Web server.
The Web server sends a FCGI_ABORT_REQUEST record to abort a request. After receiving {FCGI_ABORT_REQUEST, R}, the application responds as soon as possible with {FCGI_END_REQUEST, R, {FCGI_REQUEST_COMPLETE, appStatus}}. This is truly a response from the application, not a low-level acknowledgement from the FastCGI library.
A Web server aborts a FastCGI request when an HTTP client closes its transport connection while the FastCGI request is running on behalf of that client. The situation may seem unlikely; most FastCGI requests will have short response times, with the Web server providing output buffering if the client is slow. But the FastCGI application may be delayed communicating with another system, or performing a server push.
When a Web server is not multiplexing requests over a transport connection, the Web server can abort a request by closing the request's transport connection. But with multiplexed requests, closing the transport connection has the unfortunate effect of aborting all the requests on the connection.
The application sends a FCGI_END_REQUEST record to terminate a request, either because the application has processed the request or because the application has rejected the request.
The contentData component of a FCGI_END_REQUEST record has the form:
typedef struct { unsigned char appStatusB3; unsigned char appStatusB2; unsigned char appStatusB1; unsigned char appStatusB0; unsigned char protocolStatus; unsigned char reserved[3]; } FCGI_EndRequestBody;
The appStatus component is an application-level status code. Each role documents its usage of appStatus.
The protocolStatus component is a protocol-level status code; the possible protocolStatus values are:
Role protocols only include records with application record types. They transfer essentially all data using streams.
To make the protocols reliable and to simplify application programming, role protocols are designed to use nearly sequential marshalling. In a protocol with strictly sequential marshalling, the application receives its first input, then its second, etc. until it has received them all. Similarly, the application sends its first output, then its second, etc. until it has sent them all. Inputs are not interleaved with each other, and outputs are not interleaved with each other.
The sequential marshalling rule is too restrictive for some FastCGI roles, because CGI programs can write to both stdout and stderr without timing restrictions. So role protocols that use both FCGI_STDOUT and FCGI_STDERR allow these two streams to be interleaved.
All role protocols use the FCGI_STDERR stream just the way stderr is used in conventional applications programming: to report application-level errors in an intelligible way. Use of the FCGI_STDERR stream is always optional. If an application has no errors to report, it sends either no FCGI_STDERR records or one zero-length FCGI_STDERR record.
When a role protocol calls for transmitting a stream other than FCGI_STDERR, at least one record of the stream type is always transmitted, even if the stream is empty.
Again in the interests of reliable protocols and simplified application programming, role protocols are designed to be nearly request-response. In a truly request-response protocol, the application receives all of its input records before sending its first output record. Request-response protocols don't allow pipelining.
The request-response rule is too restrictive for some FastCGI roles; after all, CGI programs aren't restricted to read all of stdin before starting to write stdout. So some role protocols allow that specific possibility. First the application receives all of its inputs except for a final stream input. As the application begins to receive the final stream input, it can begin writing its output.
When a role protocol uses FCGI_PARAMS to transmit textual values, such as the values that CGI programs obtain from environment variables, the length of the value does not include the terminating null byte, and the value itself does not include a null byte. An application that needs to provide environ(7) format name-value pairs must insert an equal sign between the name and value and append a null byte after the value.
Role protocols do not support the non-parsed header feature of CGI. FastCGI applications set response status using the Status and Location CGI headers.
A Responder FastCGI application has the same purpose as a CGI/1.1 program: It receives all the information associated with an HTTP request and generates an HTTP response.
It suffices to explain how each element of CGI/1.1 is emulated by a Responder:
A Responder performing an update, e.g. implementing a POST method, should compare the number of bytes received on FCGI_STDIN with CONTENT_LENGTH and abort the update if the two numbers are not equal.
An Authorizer FastCGI application receives all the information associated with an HTTP request and generates an authorized/unauthorized decision. In case of an authorized decision the Authorizer can also associate name-value pairs with the HTTP request; when giving an unauthorized decision the Authorizer sends a complete response to the HTTP client.
Since CGI/1.1 defines a perfectly good way to represent the information associated with an HTTP request, Authorizers use the same representation:
An Authorizer application's 200 response may include headers whose names are prefixed with Variable-. These headers communicate name-value pairs from the application to the Web server. For instance, the response header
Variable-AUTH_METHOD: database lookuptransmits the value "database lookup" with name AUTH-METHOD. The server associates such name-value pairs with the HTTP request and includes them in subsequent CGI or FastCGI requests performed in processing the HTTP request. When the application gives a 200 response, the server ignores response headers whose names aren't prefixed with Variable- prefix, and ignores any response content.
For Authorizer response status values other than "200" (OK), the Web server denies access and sends the response status, headers, and content back to the HTTP client.
A Filter FastCGI application receives all the information associated with an HTTP request, plus an extra stream of data from a file stored on the Web server, and generates a "filtered" version of the data stream as an HTTP response.
A Filter is similar in functionality to a Responder that takes a data file as a parameter. The difference is that with a Filter, both the data file and the Filter itself can be access controlled using the Web server's access control mechanisms, while a Responder that takes the name of a data file as a parameter must perform its own access control checks on the data file.
The steps taken by a Filter are similar to those of a Responder. The server presents the Filter with environment variables first, then standard input (normally form POST data), finally the data file input:
A Filter should compare the number of bytes received on FCGI_STDIN with CONTENT_LENGTH and on FCGI_DATA with FCGI_DATA_LENGTH. If the numbers don't match and the Filter is a query, the Filter response should provide an indication that data is missing. If the numbers don't match and the Filter is an update, the Filter should abort the update.
A FastCGI application exits with zero status to indicate that it terminated on purpose, e.g. in order to perform a crude form of garbage collection. A FastCGI application that exits with nonzero status is assumed to have crashed. How a Web server or other application manager responds to applications that exit with zero or nonzero status is outside the scope of this specification.
A Web server can request that a FastCGI application exit by sending it SIGTERM. If the application ignores SIGTERM the Web server can resort to SIGKILL.
FastCGI applications report application-level errors with the FCGI_STDERR stream and the appStatus component of the FCGI_END_REQUEST record. In many cases an error will be reported directly to the user via the FCGI_STDOUT stream.
On Unix, applications report lower-level errors, including FastCGI protocol errors and syntax errors in FastCGI environment variables, to syslog. Depending upon the severity of the error, the application may either continue or exit with nonzero status.
/* * Listening socket file number */ #define FCGI_LISTENSOCK_FILENO 0 typedef struct { unsigned char version; unsigned char type; unsigned char requestIdB1; unsigned char requestIdB0; unsigned char contentLengthB1; unsigned char contentLengthB0; unsigned char paddingLength; unsigned char reserved; } FCGI_Header; /* * Number of bytes in a FCGI_Header. Future versions of the protocol * will not reduce this number. */ #define FCGI_HEADER_LEN 8 /* * Value for version component of FCGI_Header */ #define FCGI_VERSION_1 1 /* * Values for type component of FCGI_Header */ #define FCGI_BEGIN_REQUEST 1 #define FCGI_ABORT_REQUEST 2 #define FCGI_END_REQUEST 3 #define FCGI_PARAMS 4 #define FCGI_STDIN 5 #define FCGI_STDOUT 6 #define FCGI_STDERR 7 #define FCGI_DATA 8 #define FCGI_GET_VALUES 9 #define FCGI_GET_VALUES_RESULT 10 #define FCGI_UNKNOWN_TYPE 11 #define FCGI_MAXTYPE (FCGI_UNKNOWN_TYPE) /* * Value for requestId component of FCGI_Header */ #define FCGI_NULL_REQUEST_ID 0 typedef struct { unsigned char roleB1; unsigned char roleB0; unsigned char flags; unsigned char reserved[5]; } FCGI_BeginRequestBody; typedef struct { FCGI_Header header; FCGI_BeginRequestBody body; } FCGI_BeginRequestRecord; /* * Mask for flags component of FCGI_BeginRequestBody */ #define FCGI_KEEP_CONN 1 /* * Values for role component of FCGI_BeginRequestBody */ #define FCGI_RESPONDER 1 #define FCGI_AUTHORIZER 2 #define FCGI_FILTER 3 typedef struct { unsigned char appStatusB3; unsigned char appStatusB2; unsigned char appStatusB1; unsigned char appStatusB0; unsigned char protocolStatus; unsigned char reserved[3]; } FCGI_EndRequestBody; typedef struct { FCGI_Header header; FCGI_EndRequestBody body; } FCGI_EndRequestRecord; /* * Values for protocolStatus component of FCGI_EndRequestBody */ #define FCGI_REQUEST_COMPLETE 0 #define FCGI_CANT_MPX_CONN 1 #define FCGI_OVERLOADED 2 #define FCGI_UNKNOWN_ROLE 3 /* * Variable names for FCGI_GET_VALUES / FCGI_GET_VALUES_RESULT records */ #define FCGI_MAX_CONNS "FCGI_MAX_CONNS" #define FCGI_MAX_REQS "FCGI_MAX_REQS" #define FCGI_MPXS_CONNS "FCGI_MPXS_CONNS" typedef struct { unsigned char type; unsigned char reserved[7]; } FCGI_UnknownTypeBody; typedef struct { FCGI_Header header; FCGI_UnknownTypeBody body; } FCGI_UnknownTypeRecord;
National Center for Supercomputer Applications, The Common Gateway Interface, version CGI/1.1.
D.R.T. Robinson, The WWW Common Gateway Interface Version 1.1, Internet-Draft, 15 February 1996.
The following chart lists all of the record types and indicates these properties of each:
WS->App management stream FCGI_GET_VALUES x x FCGI_GET_VALUES_RESULT x FCGI_UNKNOWN_TYPE x FCGI_BEGIN_REQUEST x FCGI_ABORT_REQUEST x FCGI_END_REQUEST FCGI_PARAMS x x FCGI_STDIN x x FCGI_DATA x x FCGI_STDOUT x FCGI_STDERR x
Additional notational conventions for the examples:
1. A simple request with no data on stdin, and a successful response:
{FCGI_BEGIN_REQUEST, 1, {FCGI_RESPONDER, 0}} {FCGI_PARAMS, 1, "\013\002SERVER_PORT80\013\016SERVER_ADDR<IP_ADDRESS> ... "} {FCGI_PARAMS, 1, ""} {FCGI_STDIN, 1, ""} {FCGI_STDOUT, 1, "Content-type: text/html\r\n\r\n<html>\n<head> ... "} {FCGI_STDOUT, 1, ""} {FCGI_END_REQUEST, 1, {0, FCGI_REQUEST_COMPLETE}}
2. Similar to example 1, but this time with data on stdin. The Web server chooses to send the parameters using more FCGI_PARAMS records than before:
{FCGI_BEGIN_REQUEST, 1, {FCGI_RESPONDER, 0}} {FCGI_PARAMS, 1, "\013\002SERVER_PORT80\013\016SER"} {FCGI_PARAMS, 1, "VER_ADDR<IP_ADDRESS> ... "} {FCGI_PARAMS, 1, ""} {FCGI_STDIN, 1, "quantity=100&item=3047936"} {FCGI_STDIN, 1, ""} {FCGI_STDOUT, 1, "Content-type: text/html\r\n\r\n<html>\n<head> ... "} {FCGI_STDOUT, 1, ""} {FCGI_END_REQUEST, 1, {0, FCGI_REQUEST_COMPLETE}}
3. Similar to example 1, but this time the application detects an error. The application logs a message to stderr, returns a page to the client, and returns non-zero exit status to the Web server. The application chooses to send the page using more FCGI_STDOUT records:
{FCGI_BEGIN_REQUEST, 1, {FCGI_RESPONDER, 0}} {FCGI_PARAMS, 1, "\013\002SERVER_PORT80\013\016SERVER_ADDR<IP_ADDRESS> ... "} {FCGI_PARAMS, 1, ""} {FCGI_STDIN, 1, ""} {FCGI_STDOUT, 1, "Content-type: text/html\r\n\r\n<ht"} {FCGI_STDERR, 1, "config error: missing SI_UID\n"} {FCGI_STDOUT, 1, "ml>\n<head> ... "} {FCGI_STDOUT, 1, ""} {FCGI_STDERR, 1, ""} {FCGI_END_REQUEST, 1, {938, FCGI_REQUEST_COMPLETE}}
4. Two instances of example 1, multiplexed onto a single connection. The first request is more difficult than the second, so the application finishes the requests out of order:
{FCGI_BEGIN_REQUEST, 1, {FCGI_RESPONDER, FCGI_KEEP_CONN}} {FCGI_PARAMS, 1, "\013\002SERVER_PORT80\013\016SERVER_ADDR<IP_ADDRESS> ... "} {FCGI_PARAMS, 1, ""} {FCGI_BEGIN_REQUEST, 2, {FCGI_RESPONDER, FCGI_KEEP_CONN}} {FCGI_PARAMS, 2, "\013\002SERVER_PORT80\013\016SERVER_ADDR<IP_ADDRESS> ... "} {FCGI_STDIN, 1, ""} {FCGI_STDOUT, 1, "Content-type: text/html\r\n\r\n"} {FCGI_PARAMS, 2, ""} {FCGI_STDIN, 2, ""} {FCGI_STDOUT, 2, "Content-type: text/html\r\n\r\n<html>\n<head> ... "} {FCGI_STDOUT, 2, ""} {FCGI_END_REQUEST, 2, {0, FCGI_REQUEST_COMPLETE}} {FCGI_STDOUT, 1, "<html>\n<head> ... "} {FCGI_STDOUT, 1, ""} {FCGI_END_REQUEST, 1, {0, FCGI_REQUEST_COMPLETE}}


The pages in this site use your private data through your camera or mic. We do not use without your permissions. We do not record and share with someone else.


Index
All Classes and Interfaces|All Packages|Constant Field Values|Serialized Form
A
- addInjector(Consumer<Builder>) - Method in interface io.avaje.inject.spi.Builder
-
Add field and method injection.
- addPostConstruct(Runnable) - Method in interface io.avaje.inject.spi.Builder
-
Add lifecycle PostConstruct method.
- addPreDestroy(AutoCloseable) - Method in interface io.avaje.inject.spi.Builder
-
Add lifecycle PreDestroy method.
- all() - Method in interface io.avaje.inject.BeanScope
-
Return all the bean entries from the scope.
- arguments() - Method in interface io.avaje.inject.aop.Invocation
-
Return the arguments used for this invocation.
- arguments() - Method in class io.avaje.inject.aop.Invocation.Build
- arguments(Throwable) - Method in interface io.avaje.inject.aop.Invocation
-
Return the arguments additionally appending the throwable.
- arguments(Throwable) - Method in class io.avaje.inject.aop.Invocation.Build
- Aspect - Annotation Type in io.avaje.inject.aop
-
Meta annotation used to define an Aspect.
- AspectProvider<T extends Annotation> - Interface in io.avaje.inject.aop
-
Provides the
MethodInterceptor
for the given aspect.
B
- bean() - Method in interface io.avaje.inject.BeanEntry
-
Return the bean instance.
- bean() - Method in class io.avaje.inject.spi.SuppliedBean
-
Return the bean instance to use for injection.
- Bean - Annotation Type in io.avaje.inject
-
Marks methods on a
@Factory
bean that create dependencies. - BeanEntry - Interface in io.avaje.inject
-
A bean entry with priority and optional name.
- BeanFactory<T,
R> - Interface in io.avaje.inject.spi -
Factory for creating a bean given a single request scope argument.
- BeanFactory2<T,
R, R2> - Interface in io.avaje.inject.spi -
Factory for creating a bean given two request scope arguments.
- BeanScope - Interface in io.avaje.inject
-
Holds beans created by dependency injection.
- BeanScopeBuilder - Interface in io.avaje.inject
-
Build a bean scope with options for shutdown hook and supplying external dependencies.
- BeanScopeBuilder.ForTesting - Interface in io.avaje.inject
-
Extends the building with testing specific support for mocks and spies.
- build() - Method in interface io.avaje.inject.BeanScopeBuilder
-
Build and return the bean scope.
- build(boolean) - Method in interface io.avaje.inject.spi.Builder
-
Build and return the bean scope.
- build(Builder) - Method in interface io.avaje.inject.spi.Module
-
Build all the beans.
- Build() - Constructor for class io.avaje.inject.aop.Invocation.Build
- Builder - Interface in io.avaje.inject.spi
-
Mutable builder object used when building a bean scope.
C
- Call(Invocation.CheckedSupplier<T>) - Constructor for class io.avaje.inject.aop.Invocation.Call
-
Create with a given supplier.
- classes() - Method in interface io.avaje.inject.spi.Module
-
Return public classes of the beans that would be registered by this module.
- close() - Method in interface io.avaje.inject.BeanScope
-
Close the scope firing any
@PreDestroy
lifecycle methods. - create(R) - Method in interface io.avaje.inject.spi.BeanFactory
-
Create and return the bean.
- create(R, R2) - Method in interface io.avaje.inject.spi.BeanFactory2
-
Create and return the bean.
- customScopeType() - Element in annotation type io.avaje.inject.InjectModule
-
Internal use only - identifies the custom scope annotation associated to this module.
D
- DependencyMeta - Annotation Type in io.avaje.inject.spi
-
Hold bean dependency meta data intended for internal use by code generation (Java annotation processing).
- dependsOn() - Element in annotation type io.avaje.inject.spi.DependencyMeta
-
The list of dependencies.
- destroyMethod() - Element in annotation type io.avaje.inject.Bean
-
Specify a method to be treated like a
@PreDestroy
E
- enrich(B) - Method in class io.avaje.inject.spi.EnrichBean
-
Return the spy enhanced bean instance to use.
- EnrichBean<B> - Class in io.avaje.inject.spi
-
Holds Spy setup consumers for dependency injection using Mockito Spy.
- EnrichBean(Class<B>, String, Consumer<B>) - Constructor for class io.avaje.inject.spi.EnrichBean
- equals(Object) - Method in class io.avaje.inject.spi.GenericType
F
- Factory - Annotation Type in io.avaje.inject
-
A singleton bean that has methods marked with the
@Bean
annotation. - Fallback - Interface in io.avaje.inject.aop
-
A fallback or recovery method used with Aspects.
- finalResult() - Method in class io.avaje.inject.aop.Invocation.Build
-
Return the final invocation result.
- finalResult() - Method in class io.avaje.inject.aop.Invocation.Call
- find(String, Method) - Static method in interface io.avaje.inject.aop.Fallback
-
Find and return the fallback given the name and original method.
- forTesting() - Method in interface io.avaje.inject.BeanScopeBuilder
-
Extend the builder to support testing using mockito with
withMock()
andwithSpy()
methods.
G
- Generated - Annotation Type in io.avaje.inject.spi
-
Marks source code that has been generated.
- GenericType<T> - Class in io.avaje.inject.spi
-
Represents a full type including generics declaration, to avoid information loss due to type erasure.
- get(Class<T>) - Method in interface io.avaje.inject.BeanScope
-
Return a single bean given the type.
- get(Class<T>) - Method in interface io.avaje.inject.spi.Builder
-
Get a dependency.
- get(Class<T>, String) - Method in interface io.avaje.inject.BeanScope
-
Return a single bean given the type and name.
- get(Class<T>, String) - Method in interface io.avaje.inject.spi.Builder
-
Get a named dependency.
- get(Type, String) - Method in interface io.avaje.inject.BeanScope
-
Return a single bean given the generic type and name.
- getNullable(Class<T>) - Method in interface io.avaje.inject.spi.Builder
-
Get an optional dependency potentially returning null.
- getNullable(Class<T>, String) - Method in interface io.avaje.inject.spi.Builder
-
Get an optional named dependency potentially returning null.
- getOptional(Class<T>) - Method in interface io.avaje.inject.BeanScope
-
Optionally return a single bean given the type and empty if it is not found.
- getOptional(Class<T>) - Method in interface io.avaje.inject.spi.Builder
-
Get an optional dependency.
- getOptional(Class<T>, String) - Method in interface io.avaje.inject.spi.Builder
-
Get an optional named dependency.
- getOptional(Type, String) - Method in interface io.avaje.inject.BeanScope
-
Optionally return a single bean given the type and name and empty if it is not found.
- getProvider(Class<T>) - Method in interface io.avaje.inject.spi.Builder
-
Return Provider of T given the type.
- getProvider(Class<T>, String) - Method in interface io.avaje.inject.spi.Builder
-
Return Provider of T given the type and name.
- getProviderFor(Class<?>, Type) - Method in interface io.avaje.inject.spi.Builder
-
Return Provider for a generic interface type.
- getTypeName() - Method in class io.avaje.inject.spi.GenericType
H
- hashCode() - Method in class io.avaje.inject.spi.GenericType
- hasKey(Class<?>) - Method in interface io.avaje.inject.BeanEntry
-
Return true if the entry has a key for this type.
I
- initMethod() - Element in annotation type io.avaje.inject.Bean
-
Specify a method to be treated like a
@PostConstruct
- InjectModule - Annotation Type in io.avaje.inject
-
Used to explicitly specify if it depends on externally provided beans or provides.
- instance() - Method in class io.avaje.inject.aop.Invocation.Build
- instance() - Method in interface io.avaje.inject.aop.Invocation
-
Return the 'this' instance of the invocation.
- interceptor(Method, T) - Method in interface io.avaje.inject.aop.AspectProvider
-
Return the method interceptor to use for the given method and aspect annotation.
- interfaces() - Method in class io.avaje.inject.spi.SuppliedBean
-
Return the interfaces to additionally register along with the type.
- Invocation - Interface in io.avaje.inject.aop
-
Method invocation using in
invoke(Invocation)
for Aspects. - Invocation.Build<T> - Class in io.avaje.inject.aop
-
Builds Invocation for both callable and runnable methods.
- Invocation.Call<T> - Class in io.avaje.inject.aop
-
Callable based Invocation with checked exceptions.
- Invocation.CheckedRunnable - Interface in io.avaje.inject.aop
-
Runnable with checked exceptions.
- Invocation.CheckedSupplier<T> - Interface in io.avaje.inject.aop
-
Callable with checked exceptions.
- Invocation.Run - Class in io.avaje.inject.aop
-
Runnable based Invocation.
- InvocationException - Exception in io.avaje.inject.aop
-
Exception occurring during method interception.
- InvocationException(String, Throwable) - Constructor for exception io.avaje.inject.aop.InvocationException
-
Create with a given message and cause.
- InvocationException(Throwable) - Constructor for exception io.avaje.inject.aop.InvocationException
-
Create with a given cause.
- invoke() - Method in class io.avaje.inject.aop.Invocation.Call
- invoke() - Method in interface io.avaje.inject.aop.Invocation.CheckedRunnable
-
Invoke the method.
- invoke() - Method in interface io.avaje.inject.aop.Invocation.CheckedSupplier
-
Invoke the method returning the result.
- invoke() - Method in interface io.avaje.inject.aop.Invocation
-
Invoke the underlying method returning the result.
- invoke() - Method in class io.avaje.inject.aop.Invocation.Run
- invoke(Invocation) - Method in interface io.avaje.inject.aop.MethodInterceptor
-
Implementation can perform before and after invocation logic.
- invoke(Invocation, Throwable) - Method in interface io.avaje.inject.aop.Fallback
-
Invoke the fallback method given the invocation and exception.
- io.avaje.inject - module io.avaje.inject
- io.avaje.inject - package io.avaje.inject
-
Avaje Inject API - see
BeanScope
. - io.avaje.inject.aop - package io.avaje.inject.aop
-
Support for AOP Aspects.
- io.avaje.inject.spi - package io.avaje.inject.spi
-
Building bean scope objects expected to only be used by generated code.
- isAddBeanFor(Type...) - Method in interface io.avaje.inject.spi.Builder
-
Return true if the bean should be created and registered with the context.
- isAddBeanFor(String, Type...) - Method in interface io.avaje.inject.spi.Builder
-
Return true if the bean should be created and registered with the context.
K
- key() - Method in class io.avaje.inject.spi.EnrichBean
-
Return the key for this enriched bean.
- keys() - Method in interface io.avaje.inject.BeanEntry
-
Return the type keys for this bean.
L
- list(Class<T>) - Method in interface io.avaje.inject.BeanScope
-
Return the list of beans that implement the interface.
- list(Class<T>) - Method in interface io.avaje.inject.spi.Builder
-
Get a list of dependencies for the interface type .
- listByAnnotation(Class<?>) - Method in interface io.avaje.inject.BeanScope
-
Return the list of beans that have an annotation.
- listByPriority(Class<T>) - Method in interface io.avaje.inject.BeanScope
-
Return the list of beans that implement the interface sorting by priority.
- listByPriority(Class<T>, Class<? extends Annotation>) - Method in interface io.avaje.inject.BeanScope
-
Return the beans that implement the interface sorting by the priority annotation used.
M
- method() - Method in class io.avaje.inject.aop.Invocation.Build
- method() - Method in interface io.avaje.inject.aop.Invocation
-
Return the method being called for this invocation.
- method() - Element in annotation type io.avaje.inject.spi.DependencyMeta
-
The bean factory method (for
@Bean
annotated methods). - MethodInterceptor - Interface in io.avaje.inject.aop
-
Provides method interception such that logic can be provided both before and after method invocation.
- Module - Interface in io.avaje.inject.spi
-
A Module that can be included in BeanScope.
- Module.Custom - Interface in io.avaje.inject.spi
-
Marker for custom scoped modules.
N
- name() - Element in annotation type io.avaje.inject.InjectModule
-
Explicitly specify the name of the module.
- name() - Element in annotation type io.avaje.inject.spi.DependencyMeta
-
The qualified name of the dependency being provided.
- name() - Method in class io.avaje.inject.spi.SuppliedBean
-
Return the qualifier name of the supplied bean.
- newBuilder() - Static method in interface io.avaje.inject.BeanScope
-
Build a bean scope with options for shutdown hook and supplying external dependencies.
- newBuilder(List<SuppliedBean>, List<EnrichBean>, BeanScope, boolean) - Static method in interface io.avaje.inject.spi.Builder
-
Create the root level Builder.
- NORMAL - Static variable in interface io.avaje.inject.BeanEntry
-
Priority of normal bean.
O
- of(Class<?>, Object) - Static method in class io.avaje.inject.spi.SuppliedBean
-
Create with a class type and bean instance.
- of(String, Class<B>, B) - Static method in class io.avaje.inject.spi.SuppliedBean
-
Create for a class type with name.
- of(String, Class<B>, B, Consumer<B>) - Static method in class io.avaje.inject.spi.SuppliedBean
-
Create for a class type with a consumer that runs once when the bean is obtained.
- ofType(String, Type, B) - Static method in class io.avaje.inject.spi.SuppliedBean
-
Create a supplied bean for a generic type.
- ordering() - Element in annotation type io.avaje.inject.aop.Aspect
-
Specify the priority ordering when multiple aspects are on a method.
P
- PostConstruct - Annotation Type in io.avaje.inject
-
The
PostConstruct
annotation is used on a method that needs to be executed after dependency injection is done to perform any initialization. - PreDestroy - Annotation Type in io.avaje.inject
-
The
PreDestroy
annotation is used on a method as a callback notification to signal that the instance is in the process of being removed by the container. - Primary - Annotation Type in io.avaje.inject
-
Identify a bean as being the preferred bean to inject when multiple beans implement the intended interface.
- PRIMARY - Static variable in interface io.avaje.inject.BeanEntry
-
Priority of
@Primary
bean. - priority() - Method in interface io.avaje.inject.BeanEntry
-
Return the priority indicating if the bean is Supplied Primary, Normal or Secondary.
- Priority - Annotation Type in io.avaje.inject
-
The
Priority
annotation can be applied to classes to indicate in what order they should be returned via @BeanScope.listByPriority(Class)
. - Prototype - Annotation Type in io.avaje.inject
-
Specify a bean that has prototype scope.
- provides() - Element in annotation type io.avaje.inject.InjectModule
-
Explicitly define features that are provided by this module and required by other modules.
- provides() - Element in annotation type io.avaje.inject.spi.DependencyMeta
-
The interfaces the bean implements.
- provides() - Method in interface io.avaje.inject.spi.Module
-
Return the set of types this module explicitly provides to other modules.
- Proxy - Annotation Type in io.avaje.inject.spi
-
Marks the type as being a Proxy.
Q
- qualifierName() - Method in interface io.avaje.inject.BeanEntry
-
Return the bean name.
R
- register(T) - Method in interface io.avaje.inject.spi.Builder
-
Register the bean instance into the context.
- registerPrimary(T) - Method in interface io.avaje.inject.spi.Builder
-
Register the bean as a Primary bean.
- registerProvider(Provider<T>) - Method in interface io.avaje.inject.spi.Builder
-
Register the provider into the context.
- registerSecondary(T) - Method in interface io.avaje.inject.spi.Builder
-
Register the bean as a secondary bean.
- requires() - Element in annotation type io.avaje.inject.InjectModule
-
The dependencies that are provided externally or by other modules and that are required when wiring this module.
- requires() - Method in interface io.avaje.inject.spi.Module
-
Return the types this module needs to be provided externally or via other modules.
- result(Object) - Method in class io.avaje.inject.aop.Invocation.Build
- result(Object) - Method in interface io.avaje.inject.aop.Invocation
-
Set the result that will be returned to the caller.
- Run(Invocation.CheckedRunnable) - Constructor for class io.avaje.inject.aop.Invocation.Run
-
Create with a given closure to run.
S
- Secondary - Annotation Type in io.avaje.inject
-
Identify a bean as being the least preferred bean to inject when multiple beans implement the intended interface.
- SECONDARY - Static variable in interface io.avaje.inject.BeanEntry
-
Priority of
@Secondary
bean. - set(Class<T>) - Method in interface io.avaje.inject.spi.Builder
-
Get a set of dependencies for the interface type .
- SUPPLIED - Static variable in interface io.avaje.inject.BeanEntry
-
Priority of externally supplied bean.
- SuppliedBean<B> - Class in io.avaje.inject.spi
-
Holds beans supplied to the dependency injection.
T
- target() - Element in annotation type io.avaje.inject.aop.Aspect
-
Specify the
AspectProvider
for this aspect. - toString() - Method in class io.avaje.inject.spi.GenericType
- type() - Method in interface io.avaje.inject.BeanEntry
-
The bean instance type.
- type() - Element in annotation type io.avaje.inject.spi.DependencyMeta
-
The bean type.
- type() - Method in class io.avaje.inject.spi.GenericType
-
Return the type represented by this generic type instance.
- type() - Method in class io.avaje.inject.spi.SuppliedBean
-
Return the dependency injection target type.
V
- value() - Element in annotation type io.avaje.inject.Priority
- value() - Element in annotation type io.avaje.inject.spi.Generated
-
The name of the generator used to generate this source.
W
- with(Object, Method, Object...) - Method in class io.avaje.inject.aop.Invocation.Build
-
Set the instance, method and arguments for the invocation.
- withBean(Class<D>, D) - Method in interface io.avaje.inject.BeanScopeBuilder
-
Add a supplied bean instance with the given injection type (typically an interface type).
- withBean(Class<T>, T) - Method in interface io.avaje.inject.spi.Builder
-
Register the externally provided bean.
- withBean(Type, D) - Method in interface io.avaje.inject.BeanScopeBuilder
-
Add a supplied bean instance with a generic type.
- withBean(String, Class<D>, D) - Method in interface io.avaje.inject.BeanScopeBuilder
-
Add a supplied bean instance with the given name and injection type.
- withBean(String, Type, D) - Method in interface io.avaje.inject.BeanScopeBuilder
-
Add a supplied bean instance with the given name and generic type.
- withBeans(Object...) - Method in interface io.avaje.inject.BeanScopeBuilder
-
Supply a bean to the scope that will be used instead of any similar bean in the scope.
- withMock(Class<?>) - Method in interface io.avaje.inject.BeanScopeBuilder.ForTesting
-
Use a mockito mock when injecting this bean type.
- withMock(Class<?>, String) - Method in interface io.avaje.inject.BeanScopeBuilder.ForTesting
-
Register as a Mockito mock with a qualifier name.
- withMock(Class<D>, Consumer<D>) - Method in interface io.avaje.inject.BeanScopeBuilder.ForTesting
-
Use a mockito mock when injecting this bean type additionally running setup on the mock instance.
- withModules(Module...) - Method in interface io.avaje.inject.BeanScopeBuilder
-
Specify the modules to include in dependency injection.
- withParent(BeanScope) - Method in interface io.avaje.inject.BeanScopeBuilder
-
Use the given BeanScope as the parent.
- withParent(BeanScope, boolean) - Method in interface io.avaje.inject.BeanScopeBuilder
-
Use the given BeanScope as the parent additionally specifying if beans added will effectively override beans that exist in the parent scope.
- withShutdownHook(boolean) - Method in interface io.avaje.inject.BeanScopeBuilder
-
Create the bean scope registering a shutdown hook (defaults to false, no shutdown hook).
- withSpy(Class<?>) - Method in interface io.avaje.inject.BeanScopeBuilder.ForTesting
-
Use a mockito spy when injecting this bean type.
- withSpy(Class<?>, String) - Method in interface io.avaje.inject.BeanScopeBuilder.ForTesting
-
Register a Mockito spy with a qualifier name.
- withSpy(Class<D>, Consumer<D>) - Method in interface io.avaje.inject.BeanScopeBuilder.ForTesting
-
Use a mockito spy when injecting this bean type additionally running setup on the spy instance.
- wrap(MethodInterceptor) - Method in class io.avaje.inject.aop.Invocation.Build
-
Wrap this invocation using a methodInterceptor returning the wrapped call.
- wrap(MethodInterceptor) - Method in class io.avaje.inject.aop.Invocation.Call
- wrap(MethodInterceptor) - Method in class io.avaje.inject.aop.Invocation.Run
All Classes and Interfaces|All Packages|Constant Field Values|Serialized Form


Controls
Move: A, D, Left, Right
Unattack: J, X
Unjump: K, C
Credits
Graphics
Monsters by
Stephen Challener (Redshrike), hosted by OpenGameArt.org
with changes to size and opacity, License:
CC BY 3.0
Jump effect by
rubberduck
Skull by
Jorge Avila
, License:
CC BY 3.0
, changed rotation
Sounds
Jump effect by
LloydEvans09
, sound reversed for landing, License:
CC BY 3.0


Blackroot Wood [aq77], forest, in Imperia, peasants: 101
Last updated Turn #140
Blackroot Wood [aq77], forest, in Imperia, peasants: 101
------------------------------------------------------------------------
2: Lanthara [r4v], Imperial Empire, duke, with 39 nazgul, arrived from
2: the south, accompanied by:
2: Manis [h3g], Imperial Empire, with 17 archers, 18 hvy. xbowmen
2: Lars the very big Guy [o4l], refugee, prisoner
3: Lanthara [r4v], Imperial Empire, duke, with 39 nazgul, went north,
3: accompanied by:
3: Manis [h3g], Imperial Empire, with 17 archers, 18 hvy. xbowmen
3: Lars the very big Guy [o4l], refugee, prisoner
4: Stack of nazgul [as2h], nazgul, number: 2, arrived from the west.
5: Stack of giants [hu8i], giants, number: 3, arrived from the north.
7: Stack of nazgul [as2h], nazgul, number: 2, went north.
7: Stack of giants [hu8i], giants, number: 3, went west.
24: Stack of nazgul [ix8l], nazgul, number: 3, arrived from the north.
24: Stack of nazgul [jg9n], nazgul, number: 2, arrived from the north.
26: Stack of nazgul [ix8l], nazgul, number: 3, went north.
26: Stack of nazgul [jg9n], nazgul, number: 2, went west.
29: Stack of nazgul [iz3q], nazgul, arrived from the north.
Routes leaving Blackroot Wood:
North, forest, to Blackroot Wood [ap77], 8 days
East, to Ocean [aq78], The Outer Sea, 2 days
South, to Ocean [ar77], The Outer Sea, 2 days
West, forest, to Blackroot Wood [aq76], 8 days
Seen here:
Stack of giants [ck3b], giants, number: 15
Stack of nazgul [bn6u], nazgul, number: 4
Stack of nazgul [he1a], nazgul, number: 2


A jQuery plugin provides appear and disappear events to do lazyload, infinite scroll or else effect.
Lazyload (Overflow and Tabs)
(You could also refer to jQuery-lazyload-any)
Infinite Scroll
You can also install jquery-appear by using Bower.
bower install jquery-appear
You could just use jQuery bind
, delegate
or on
to listen event. HTML

JavaScript
// trigger when first appear or disappear
$('#you-want-to-detect').bind('appear', appearHandler);
$('#you-want-to-detect').bind('disappear', disappearHandler);
// trigger when scrolling and visible in screen
$('#you-want-to-detect').bind('appearing', appearingHandler);
Force to trigger detection event.
Set interval of timer that check container display status.
Number
(default: 50
)Interval of timer. Set 0 to disable timer, and you can use $.appear.check()
to trigger detection manually.
Refresh status of elements bound event. Element will bind scroll event to parent scrollable automatically when binding appear event. If you move element, you should use this method to bind again.
String
or Object
(default: undefined
)The elements that you want to refresh. It will refresh all elements bound appear event if you don't pass this parameter.
You can set prefix to avoid event conflict.
String
The prefix that you want to set. It will apply to new event bindings. You should define it at first.
$.appear.check()
to force detection.element.is(':visible')
, it will return false if element's width and height are equal to zero. So you have to make
sure the appear element with any width or height.HTML

JavaScript
$('#loading').bind('appear', ajaxLoad);
The project is released under the MIT license.
The project's website is located at https://github.com/emn178/jquery-appear
Author: Yi-Cyuan Chen (emn178@gmail.com)


See the train schedule below. If you need to add a train, complete the form below.
Puns about monorails always make for decent one .... liners


"x"
"1" "ASHBY,J, VOGEL,EW, TINWELL,H, CALLANDER,RD AND SHUKER,DEG,MUTAGENICITY TO SALMONELLA, DROSOPHILA AND THE MOUSE BONE MARROW OF THE HUMANANTINEOPLASTIC AGENT FOTEMUSTINE: PREDICTION OF CARCINOGENIC POTE __ NCY, MUTAT.RES. 286(1):101- 109, 1993"


You are not limited to images alone. Any content will do. I guess, you are just limited by your imagination. As you can see i am poor at that.
This is some standard paragraph text without much styling
This is some strong text
Here is some linked text
How about some emphasized text?
Some {code}
if you are a developer?
Do you like this style instead?
This is some standard paragraph text
This is some strong text
Here is some linked text
How about some emphasized text?
Some {code}
if you are a developer?
Here is some linked text
$(".nonImageContent .carousel").jCarouselLite({ btnNext: ".nonImageContent .next", btnPrev: ".nonImageContent .prev" });


By Ross Smith
#include "rs-core/float.hpp"
#define
RS_DEFINE_CONSTANT
(name, value)
static constexpr float
name##_f
= value##f
static constexpr double
name##_d
= value
static constexpr long double
name##_ld
= value##l
template <typename T> static constexpr T
name##_c
= T(name##_ld)
Defines a floating point constant, in several forms. This generates a set of
three named constants (for the three standard floating point types) and a
variable template. The value
argument must be a floating point literal with
no type suffix.
(This intentionally uses a different naming convention to P0631, to avoid collisions if P0631 becomes part of the standard library.)
The values quoted for the following constants are approximate; the values
actually supplied are accurate to at least long double
precision where an
exact value is defined, or to the best known accuracy for the empirical
constants.
e
= 2.7183log2e
= log2 e = 1.4427log10e
= log10 e = 0.4343ln2
= loge 2 = 0.6931ln10
= loge 10 = 2.3026pi
= π = 3.1416pi_2
= π/2 = 1.5708pi_4
= π/4 = 0.7854one_pi
= 1/π = 0.3183two_pi
= 2/π = 0.6366two_sqrtpi
= 2/√π = 1.1284sqrt2
= √2 = 1.4142one_sqrt2
= 1/√2 = 0.7071sqrt3
= √3 = 1.7321sqrt5
= √5 = 2.2361sqrtpi
= √π = 1.7725sqrt2pi
= √(2π) = 2.5066inch
= 0.0254 mfoot
= 0.3048 myard
= 0.9144 mmile
= 1609 mnautical_mile
= 1852 mounce
= 0.02835 kgpound
= 0.4536 kgshort_ton
= 907.2 kglong_ton
= 1016 kgpound_force
= 4.448 Nerg
= 10-7 Jfoot_pound
= 1.356 Jcalorie
= 4.184 Jkilocalorie
= 4184 Jton_tnt
= 4.184×109 Jhorsepower
= 745.7 WmmHg
= 133.3 Paatmosphere
= 101300 Pazero_celsius
= 273.15 Katomic_mass_unit
= 1.661×10-27 kgavogadro_constant
= 6.022×1023 mol-1boltzmann_constant
= 1.381×10-23 J K-1elementary_charge
= 1.602×10-19 Cgas_constant
= 8.314 J mol-1 K-1gravitational_constant
= 6.674×10-11 m3 kg-1 s-2planck_constant
= 6.626×10-34 J sspeed_of_light
= 2.998×108 m s-1stefan_boltzmann_constant
= 5.670×10-8 W m-2 K-4earth_mass
= 5.972×1024 kgearth_radius
= 6.371×106 mearth_gravity
= 9.807 m s-2jupiter_mass
= 1.899×1027 kgjupiter_radius
= 6.991×107 msolar_mass
= 1.989×1030 kgsolar_radius
= 6.963×108 msolar_luminosity
= 3.846×1026 Wsolar_temperature
= 5778 Kastronomical_unit
= 1.496×1011 mlight_year
= 9.461×1015 mparsec
= 3.086×1016 mjulian_day
= 86400 sjulian_year
= 31557600 ssidereal_year
= 31558150 stropical_year
= 31556925 stemplate <typename T> constexpr T
degrees
(T rad) noexcept
template <typename T> constexpr T
radians
(T deg) noexcept
Convert between degrees and radians.
template <typename T1, typename T2> constexpr T2
interpolate
(T1 x1, T2 y1, T1 x2, T2 y2, T1 x) noexcept
Returns the value of y
corresponding to x
, by interpolating or
extrapolating the line between (x1,y1)
and (x2,y2)
. If x1=x2
it will
return the average of y1
and y2
. The usual arithmetic rules apply if the
result is not representable by the return type.
template <typename T2, typename T1> T2
iceil
(T1 value) noexcept
template <typename T2, typename T1> T2
ifloor
(T1 value) noexcept
template <typename T2, typename T1> T2
iround
(T1 value) noexcept
Rounds the argument toward positive infinity (iceil()
), toward negative
infinity (ifloor()
), or to the nearest integer (iround()
; halves round
up), converting the result to the specified return type. The usual arithmetic
rules apply if the result is not representable by the return type.
namespace RS::
Literals
constexpr float
operator""_degf
(long double x) noexcept
constexpr float
operator""_degf
(unsigned long long x) noexcept
constexpr double
operator""_deg(
long double x) noexcept
constexpr double
operator""_deg(
unsigned long long x) noexcept
constexpr long double
operator""_degl
(long double x) noexcept
constexpr long double
operator""_degl
(unsigned long long x) noexcept
Angle literals, converting degrees to radians.
template <typename T, typename F> T
line_integral
(T x1, T x2, size_t k, F f)
Computes the integral of f(x)
over the interval [x1,x2]
by the trapezoid
algorithm, using k
subdivisions. This has complexity O(k)
. Behaviour is
undefined if k=0
or the function has a pole within the interval.
template <typename T, size_t N, typename F> T
volume_integral
(Vector<T, N> x1, Vector<T, N> x2, size_t k, F f)
Computes the volume integral of f(x)
over the rectangular prism whose
opposite corners are x1
and x2
, dividing each side into k
subdivisions.
This has complexity O(kN)
Behaviour is undefined if
k=0
or the function has a pole within the volume.
template <typename SinglePassRange> [value type]
precision_sum
(const SinglePassRange& range)
Calculates the sum of a sequence of numbers using the high precision algorithm from
Shewchuk
and Hettinger.
The range's value type must be a floating point arithmetic type. This is
always much more accurate than simple addition, and is guaranteed to give the
correct answer (the exact sum correctly rounded) if the value type implements
IEEE arithmetic (on GCC this requires the -ffloat-store
option).
For all of these algorithms, T
must be a floating point arithmetic type, F
(and DF
if it is used) must be a function from T
to T
.
The structure members specify the tolerance and the maximum number of
iterations; iteration will stop when the absolute value of f()
is less than
or equal to epsilon
, or the maximum number of iterations is reached. The
count
and error
members are filled with the actual iteration count and
absolute error. If the function has multiple roots, the one closest to the
initial values will typically be found, but the nature of the algorithms means
that this cannot be promised.
The default epsilon is arbitrarily set to 10-4 for float
,
10-8 for double
and long double
. Behaviour is undefined if
epsilon
is not positive, if the function has no root, or for the algorithms
that take two initial values, if f(a)
and f(b)
have the same sign.
template <typename T> struct
Bisection
T Bisection::
epsilon
= [see above]
size_t Bisection::
limit
= 100
size_t Bisection::
count
T Bisection::
error
template <typename F> T Bisection::
operator()
(F f, T a, T b)
Use the bisection algorithm to find a root of a function. The function call operator takes the function to be solved and two initial values, which the caller is expected to ensure are on opposite sides of the root.
template <typename T> struct
FalsePosition
T FalsePosition::
epsilon
= [see above]
size_t FalsePosition::
limit
= 100
size_t FalsePosition::
count
T FalsePosition::
error
template <typename F> T FalsePosition::
operator()
(F f, T a, T b)
Use the false position algorithm to find a root of a function. The function call operator takes the function to be solved and two initial values, which the caller is expected to ensure are on opposite sides of the root.
template <typename T> struct
NewtonRaphson
T NewtonRaphson::
epsilon
= [see above]
size_t NewtonRaphson::
limit
= 100
size_t NewtonRaphson::
count
T NewtonRaphson::
error
template <typename F, typename DF> T NewtonRaphson::
operator()
(F f, DF df, T a = 0)
Use the Newton-Raphson
algorithm to find a root of a function. The function call operator takes the
function to be solved, the derivative of this function, and an initial value.
Results are unpredictable if df()
is not a good approximation to the
derivative of f()
.
template <typename T> struct
PseudoNewtonRaphson
T PseudoNewtonRaphson::
epsilon
= [see above]
T PseudoNewtonRaphson::
delta
= [same as default epsilon]
size_t PseudoNewtonRaphson::
limit
= 100
size_t PseudoNewtonRaphson::
count
T PseudoNewtonRaphson::
error
template <typename F> T PseudoNewtonRaphson::
operator()
(F f, T a = 0)
This uses the Newton-Raphson algorithm, but calculates an approximation to the
derivative by evaluating f()
at a nearby point(f(x+delta)
), instead of
taking the derivative as a separate function. Results are unpredictable if the
function exhibits significant irregularities on a scale smaller than delta
.
Behaviour is undefined if delta
is zero.


| DOSE: |
8.0 mg |
oral |
2C-T-2 |
(pill / tablet) |
| |
20 mg |
oral |
2C-T-2 |
(pill / tablet) |
2C-T-2 has been sold in the Dutch smartshops from November 1997 until now without any problems known to me. Experiences are very similar.
First some tips:
-Take your total amount at once. Double dosing does not work.
-Drink a lot. This tweeto gives dehydration. Food is good too.
 Rooms of oak, large mirrors and five good friends. After two hours I feel like a intense psychedelic is knocking on my door, but he never comes in. It touches the surface. Dept and colour are different. The humorous substance does not allow me to stop laughing. This ceiling seems miles away, letting me drift into deep spaces, but as soon as I forget to focus, I am back to baseline. I wonder whether to smoke some grass or drink some alcohol as I know that a lot of people go out on it in combi with alcohol. Because we would like to go more into the psychedelic realm we choose the joint. Wrong answer!!! Now we are just veeeerrrry stoned and all the psychedelic effects are gone. We went to bed. I woke up with a head ache and stayed in bed for five more hours. Then my friends told me they had the same problem, but solved it with food. They turned out to be my saviours. I felt extremely great the days afterwards.
(with 20 mg) Setting: very small houseparty Within 15 minutes I feel something strong bouncing in and away again. This one did not land on my head until 1:50 after swallowing two and a half white pills. Then it landed hard. Some pressure on my head for half an hour. Sitting was better. I wondered where this would go and started to smile. The smile transformed into a laugh until my belly hurt. Then I was energy. The walls danced with me. So was anything else. Music was good to me and I was good to the turntables. Talking was nice but I had no interest in the sensual efforts of a woman. The experience lasted 7 hours in total. No after effects.
This is a very controllable substance which gives the visuals without losing yourself in the experience. [erowid note: this seems to be true at low dosages for most people, other users have reported strong dissociation, memory loss, confusion, delerium, etc at higher dosages or much different sensitivities.]
Experience Reports are the writings and opinions of the individual authors who submit them.
Some of the activities described are dangerous and/or illegal and none are recommended by Erowid.


SMALL DONOR ELECTIONS PORTLAND
A password reset has been requested
Click here to reset your password.
If this email was sent to you by mistake, please disregard it.


Before Change
// Form a 1D array of values to be used in the matrix, containing a reversed
// copy of r[1:], followed by c.
vals = np.concatenate((r[-1:0:-1], c))
a, b = np.ogrid[0:len(c), len(r) - 1:-1:-1]
indx = a + b
// `indx` is a 2D array of indices into the 1D array `vals`, arranged so
// that `vals[indx]` is the Toeplitz matrix.
return vals[indx]
def circulant(c):
After Change
// Form a 1D array containing a reversed c followed by r[1:] that could be
// strided to give us toeplitz matrix.
vals = np.concatenate((c[::-1], r[1:]))
out_shp = len(c), len(r)
n = vals.strides[0]
return as_strided(vals[len(c)-1:], shape=out_shp, strides=(-n, n)).copy()
def circulant(c):


Just Filters
Select File
Select a filter
Grayscale
Red Room
Blur
Darken
Light Cross
Warm Amber
Download


Match Play. 0-3 to 7. Should Red double? If doubled, should White take?
pips Red=134 White=130
(CorrectAnswer= 0/0, ErrorScore= 0)
For money it is close, but this would be no double/take. White’s ace-point anchor and his better home board ensure the take is trivial. That should provide a clue for the match-play situation.
White can use two or four points efficiently, so it is likely to be a comfortable take. However, Red does trail 0-3 and the position is very volatile. If Red makes the 3-pt and White fans it will be double/pass (or even too good). Therefore, Red should double now to avoid losing his market.
Not doubling is a double blunder and dropping as White is also a double blunder.
White can use two or four points efficiently, so it is likely to be a comfortable take. However, Red does trail 0-3 and the position is very volatile. If Red makes the 3-pt and White fans it will be double/pass (or even too good). Therefore, Red should double now to avoid losing his market.
Not doubling is a double blunder and dropping as White is also a double blunder.
Cube analysis 2-ply cubeless equity +0.393 (Money: +0.409) 0.645 0.237 0.020 - 0.355 0.128 0.010 Cubeful equities: 1. Double, take +0.840 2. Double, pass +1.000 (+0.160) 3. No double +0.671 (-0.169) Proper cube action: Double, take


The Scalar API allows you to easily extend the Scalar framework to adapt it to your own needs,
and allows you to perform scalability tests of your own system.
In order to extend the Scalar platform, the following classes are relevant.
- {@link be.kuleuven.distrinet.scalar.users.User} allows you to implement custom user behavior,
i.e., "use cases" against which the scalability of the system will be tested.
- {@link be.kuleuven.distrinet.scalar.requests.Request} classes are the way by which
user objects interact with the system under test.
- {@link be.kuleuven.distrinet.scalar.data.DataProvider} classes realize inter user and
inter node communication and synchronization.
- {@link be.kuleuven.distrinet.scalar.core.Plugin} allows you to extend the core
framework functionality. Examples of tasks that are typically performed by a plugin are
configuring a service, cleaning up a database, synchronizing time, etc.
@author Thomas Heyman


Analytics
Sponsorhip Required5>
Rich analytics takes time and money to develop. Please consider making a donation to help us reach our funding requirement sooner so that we can offer this feature to you.
{% extends "console/console.html" %}
{% load icon %}
{% block title %}Analytics | Cannlytics{% endblock title %}
{% block console_body %}
Rich analytics takes time and money to develop. Please consider making a donation
to help us reach our funding requirement sooner so that we can offer this feature to you.
Analytics
Sponsorhip Required5>
Goal: $2,000
👐 Become a sponsor


VAST 4.0 test: Linear 30 seconds video ad, skippable after 10 seconds
VAST 4.0 Response
Media Liceses


[CHAPTER 321D]
INTERDEPARTMENTAL CLUSTER FOR SERVICES TO CHILDREN
Cross References
Statewide juvenile justice interdepartmental cluster, see §571-86.5.
Section
321D-1 Interdepartmental cluster for services to children;
establishment, functions


How will global warming shift climates across the globe? That is the question we sought to answer with this map, based on data published by the World Bank that contrasts 20th century weather observations (1976 to 2000) with 21st century model predictions (2076 to 2100) based on the Köppen-Geiger Climate Classification System.
The Köppen-Geiger classification System groups climates based on common characteristics, like precipitation patterns, permafrost, and distance from the equator. These categories are commonly presented as a chorochromatic map that assigns a unique color to each classification. Click on an area in this map and toggle the buttons to see how the range shifts between current and future scenarios. For example, the dry, hot desert region (Bwh) expands to cover the Middle East and Central Asia, while the Tundras (ET) and Ice Caps (EF) of mountain ranges and far northern latitudes all but disappear.
The original research supplied us with the colors, and the XYZ Hub allows us to host and tag the classification zones of current and future climates, making visualizing the radical climate shifts in d3.js a snap.
Source files and data can be accessed on GitHub.
This map was designed and built by Stamen Design with publicly available data.


ESPL
Students
Admitted
Enquiry
Fee Reports
Staff
Staff List
Staff Attendance
Login
{{loginData.staffname}}
Settings
Logout
{{batchnamelecrec}}
HOLIDAY
CANCELLED
EXAM
Date
Day
Lecture Timing
Teacher
Subject
Lecture Timing
Teacher
Subject
Lecture Timing
Teacher
Subject
{{x[0].date}}
{{x[0].day}}
{{y.startTime}} To {{y.endTime}}
{{y.tname}}
{{y.subject}}


Miniature Shetland pony makes grandmother's day at a care home
EDINBURGH, Scotland -- A grandmother in Edinburgh, Scotland, went for a spin in her care home when a miniature Shetland pony came to visit.
RELATED: Miniature horse hitches ride on BART
Wilson, a therapy pony, trots up and down the corridor beside the elderly woman in a wheelchair as residents wait for a turn.
Elaine Sangster, who helps run the organization, wrote on Facebook that there was a "queue of residents waiting for a 'wee go'!"
Sangster and her husband began Therapy Ponies Scotland in 2015 and have brought their Shetland ponies to care homes, schools, hospitals, and hospices across Scotland.


Web QoE Experiment
School of Computer Science
Hamed Jahromi
The experiement is now completed. Thank you for your participation!
Start Again


Setting location of auto-save folder in Google Chrome.
Go to Settings > Show advanced settings.. > Downloads > Select the location.


HELLO
Title
Subheading
Subheading Heavy
Subheading Bold
Subheading Light
Subheading Small
Default
Default Heavy
Default Light
Body Bold
Body
Sharp Buttons
Round Buttons
Extra Round Buttons
Pill Buttons
White Text Dark Background
Dark Text Dark Background
Text Muted
Dark Text Light Background
Text Muted
Card Types
New York
City That Never Sleeps
New York is a state in the northeastern United States. New York was one of the original thirteen colonies that formed the United States. With an estimated 19.85 million residents in 2017, it is the fourth most populous state in the United States.
New York
City That Never Sleeps
New York is a state in the northeastern United States. New York was one of the original thirteen colonies that formed the United States. With an estimated 19.85 million residents in 2017, it is the fourth most populous state in the United States.
New York
City That Never Sleeps
New York is a state in the northeastern United States. New York was one of the original thirteen colonies that formed the United States. With an estimated 19.85 million residents in 2017, it is the fourth most populous state in the United States.
Card Elevations
New York
City That Never Sleeps
New York is a state in the northeastern United States. New York was one of the original thirteen colonies that formed the United States. With an estimated 19.85 million residents in 2017, it is the fourth most populous state in the United States.
New York
City That Never Sleeps
New York is a state in the northeastern United States. New York was one of the original thirteen colonies that formed the United States. With an estimated 19.85 million residents in 2017, it is the fourth most populous state in the United States.
New York
City That Never Sleeps
New York is a state in the northeastern United States. New York was one of the original thirteen colonies that formed the United States. With an estimated 19.85 million residents in 2017, it is the fourth most populous state in the United States.
New York
City That Never Sleeps
New York is a state in the northeastern United States. New York was one of the original thirteen colonies that formed the United States. With an estimated 19.85 million residents in 2017, it is the fourth most populous state in the United States.
New York
City That Never Sleeps
New York is a state in the northeastern United States. New York was one of the original thirteen colonies that formed the United States. With an estimated 19.85 million residents in 2017, it is the fourth most populous state in the United States.
Card Types
New York
City That Never Sleeps
New York is a state in the northeastern United States. New York was one of the original thirteen colonies that formed the United States. With an estimated 19.85 million residents in 2017, it is the fourth most populous state in the United States.
New York
City That Never Sleeps
New York is a state in the northeastern United States. New York was one of the original thirteen colonies that formed the United States. With an estimated 19.85 million residents in 2017, it is the fourth most populous state in the United States.
New York
City That Never Sleeps
New York is a state in the northeastern United States. New York was one of the original thirteen colonies that formed the United States. With an estimated 19.85 million residents in 2017, it is the fourth most populous state in the United States.
Spiderman: Homecoming
2017PG-13 2 h 10 m
Following the events of Captain America: Civil War, Peter Parker, with the help of his mentor Tony Stark, tries to balance his life as an ordinary high school student in Queens, New York City, with fighting crime as his superhero alter ego Spider-Man as a new threat, the Vulture, emerges.
Spiderman: Homecoming
2017PG-13 2 h 10 m
2017PG-13 2 h 10 m
Spiderman: Homecoming
Following the events of Captain America: Civil War, Peter Parker, with the help of his mentor Tony Stark, tries to balance his life as an ordinary high school student in Queens, New York City, with fighting crime as his superhero alter ego Spider-Man as a new threat, the Vulture, emerges.
Login
Don't Have An Account? Sign Up
New York
City That Never Sleeps
New York is a state in the northeastern United States. New York was one of the original thirteen colonies that formed the United States. With an estimated 19.85 million residents in 2017, it is the fourth most populous state in the United States.


Welcome to the Whirled!
This tour can help you jump right into the great stuff in Whirled. What sounds fun?
Set up your
profile
Change your
avatar
Change the
backdrop
of your home
Buy some
new furniture
Rearrange
your furniture
Play games
and earn flow
Find friends
in Whirled
Upload
furniture, photos or songs