Hi and welcome to our website!
We’re Ellora, Mathilde and Elisabetta and we’re so excited to present our newborn child to the world. We’ll be honest, the work that has gone into the creation of this website was quite a lot, but it couldn’t have been more rewarding to
us.
Enjoy reading through some of the main benefits of drinking water and be inspired to make your lifestyle healthier!


To run Selenium Grid, you need a valid Java 5+ JDK install on your system.
Mac OS X
If you are running Mac OS X you can safely skip this step — the system comes with a ready-to-use Java runtime and development environment.
Need more detailed instructions? Check out our step-by-step installation instructions for Mac OS X.
Ubuntu
If you are running Ubuntu 8.04 "Hardy Heron", the easier way to install the JDK is to run:
sudo apt-get install sun-java6-jdk
Other Systems
Download Java 6 JDK,
install it on your file system and make sure it is in your PATH
:
$ java -version java version "1.6.0" Java(TM) SE Runtime Environment (build 1.6.0-b105) Java HotSpot(TM) Server VM (build 1.6.0-b105, mixed mode)


Preparation time
1-2 hours
Cooking time
over 2 hours
Serves
Serves 12
Dietary
Gloriously billowy and wildly retro, to say this complex meringue dessert decorated with fondant violets will be a talking point is an understatement!

Line 3 large baking trays with baking parchment. Draw 2 x 20cm/8in circles on 2 of the trays and 1 x 20cm/8in circle on 1 of the trays. (You should end up with 5 x 20cm/8in circles). Preheat the oven to 120C/100C Fan/Gas ½.
For the meringue shell, tip the egg whites and cream of tartar into a large spotlessly clean bowl and whisk with an electric mixer on high speed until the whites form stiff peaks. Add the caster sugar, a tablespoon at a time, whisking continuously to make a thick, glossy meringue.
Spoon two-thirds of the meringue into a piping bag fitted with a 1.5cm/⅝in plain nozzle. Pipe a thick ring inside one of the circles on the baking tray and continue spiraling until the entire circle is filled. Repeat with a second circle. These create the base and the top of the meringue cake.
Repeat the process with the 3 remaining circles, except don't fill in the circles, so that you have three hoops of meringue - these create the sides of the meringue shell. Bake for 45 minutes. Remove from the oven and leave to cool.
Meanwhile, make the fondant violets.  Dust 2 pieces of greaseproof paper with icing sugar and place the balls of fondant between the sheets of greaseproof and flatten each ball out with your fingers, to a thin circle, approximately 1cm/½in in diameter - these form the petals.
Using a small paintbrush and a tiny amount of water, stick the petals and stamens together to form a violet, with the 2 dusky lavender petals at the top, 2 dark purple petals below them and the remaining dark purple petal on the bottom, in the middle. Press the yellow stamens into the centre. Repeat to make 13 violets. Leave to dry on greaseproof paper for at least 1 hour.
When the meringues are dry, gently slide 1 of the cooked, filled meringues onto a 30cm/12in heatproof (to 120C) serving plate. Spoon the remaining meringue into the piping bag and pipe 8 blobs of meringue, evenly spaced around the edge of the circle. Place 1 of the meringue hoops on top and press down very gently to stick the hoop to the base.
Repeat the process with the remaining 2 hoops of meringue. Roughly pipe the remaining one-third of meringue around the sides to disguise the hoops.  Bake on the serving plate for 45 minutes. Remove from the oven and leave to cool.
For the Swiss meringue decoration, set a large mixing bowl over a pan of gently simmering water. Tip the egg whites and sugar into the bowl and whisk until the sugar is dissolved and the meringue reaches 70C on a sugar thermometer.
Remove from the heat and continue whisking until cool and stiff. Spoon the meringue into a piping bag fitted with a large star nozzle. Pipe a pretty border around the base, the middle and the top edge of the meringue shell. Pipe a border around the outside edge and the middle of the filled meringue circle that will become the lid. Bake for 30 minutes. Remove from the oven and leave to cool.
For the filling, whip the cream and icing sugar together in a bowl until soft peaks form when the whisk is removed from the bowl. Whisk in the orange blossom water and gently fold in the strawberries and raspberries. Spoon into the cooled meringue cake shell. Top with the meringue lid.
To decorate, use tiny blobs of meringue to stick 6 violets around the middle piped border on the sides of the cake, 6 violets around the top of the cake and 1 violet in the centre of the top of the cake. Serve immediately.


Software Experience
- HTML,CSS,JavaScript/EJS
- MySQL/PostGres Databases
- Python
- Java
- LAMP/WAMP/MAMP Servers
- Unix/Linux
- LISP
- Prolog

Frameworks
- Express-Node
- Agile
- Waterfall
- Kaizen
Summary Of Qualifications
Considerable background and experience in
technical and/or functional roles providing
leadership in most aspects of project/IT
management. Demonstrated depth and breadth
of expertise to deliver value to stakeholders,
management teams, and recipient organizations.
Ability to leverage skills in motivating, facilitating,
influencing and driving results for firms dealing with
both legacy and cutting edge technologies (IBM, AVAYA, Cisco,
Google, Nice, Siemens, ROLM, Nortel to name but a few).


Intention to submit: October 26 November 1, 2018
Regular paper submission: November 2 November 6, 2018
Supplemental material deadline: November 9, 2018
Long abstract submission: January 11, 2019
Author notification: February 1, 2019, end of February, 2019
Conference: June 18-19, 2019
We are happy to announce the following Award winners after a successful IPCAI 2019 conference:
These awards are generously supported by the following sponsors.
In preparation for IPCAI 2019 conference, please consult CARS 2019 website for on-site information such as conference map and registration instructions. In particular,
We thank the CAI community for your tremendous interests and support.
We thank the CAI community for your tremendous interests and support.
We thank the CAI community for your tremendous interests and support.
The abstract can be modified, if needed, at the time of the full paper submission.


3
2
Do it Yourself
3
5
0
1
2
3
4
5
6
7
8
9
10
2
+
3
=
0
1
2
3
4
5
6
7
8
9
10
5
+
3
=
Enter the sum of given numbers
Enter the sum of given numbers


Back
Event manager
Event:
New Year's Eve
John's Birthday
Jane's Welcome Party
Attendees:
Extra guests allowed:
No
One
Two


Hangman or Die...Pow...Pow
Do you want prove your gaming worth?


The highest ideal of a translation... is achieved when the reader flings it impatiently into the fire, and begins patiently to learn the language for himself.
Philip Vellacott
A / B / C / D / E / F / G / H / I / J / K / L / M / N / O / P / Q / R / S / T / U / V / W / X / Y / Z
The dictionary below is alphabetical and includes entries on every opcode listed in the table above, as well as brief notes on a few opcodes once thought to exist but now disproved.
The Z-machine has the same concept of "table" (as an internal data structure) as Inform. Specifically, a table is an array of words (in dynamic or static memory) of which the initial entry is the number of subsequent words in the table. For example, a table with three entries occupies 8 bytes, arranged as the words 3, x, y, z.
In all cases below where one operand is supposed to be in a particular range, behaviour is undefined if it is not. For instance an interpreter complies with the Standard even if it crashes when an illegal object number (including 0) is given for an object operand. However, see S A for guidelines on detecting and dealing with errors.
2OP:20 14 add a b -> (result)
Signed 16-bit addition.
2OP:9 9 and a b -> (result)
Bitwise AND.
This is the Inform name for the keyboard-reading opcode under Version 5 and later. (Inform calls the same opcode sread under Versions 3 and 4.) See read for the specification.
EXT:3 3 5/- art_shift number places -> (result)
Does an arithmetic shift of number by the given number of places, shifting left (i.e. increasing) if places is positive, right if negative. In a right shift, the sign bit is preserved as well as being shifted on down. (The alternative behaviour is log_shift.)
The "places" operand must be in the range -15 to +15, otherwise behaviour is undefined.
VAR:242 12 4 buffer_mode flag
If set to 1, text output on the lower window in stream 1 is buffered up so that it can be word-wrapped properly. If set to 0, it isn't.
In Version 6, this opcode is redundant (the "buffering" window attribute can be set instead). It is used twice in each of Infocom's Version 6 story files, in the $verify routine. Frotz responds by setting the current window's "buffering" attribute, while Infocom's own interpreters respond by doing nothing. This standard leaves the result of buffer_mode undefined in Version 6.
EXT:29 1D 6/* buffer_screen mode -> (result)
Tells the interpreter how to handle display buffering. If mode is 0, updates must be made as soon as possible. If mode is 1, the interpreter may make changes to a backing store, and need not update the screen. The interpreter is free to ignore the advice, but if so must always act as though the mode is 0 (update the screen as soon as possible).
With buffer_screen in either state, an update of the visible display can be forced immediately by issuing buffer_screen -1, without altering the current buffering state. Note that buffer_screen -1 does not flush the text buffer.
The return value is the old buffer_screen state.
See S 8 for more details.
***[1.1] This opcode will only be present in interpreters obeying Standard 1.1 or later, so story files should check the standard number of the interpreter before executing this opcode.
VAR:224 0 1 call routine ...up to 3 args... -> (result)
The only call instruction in Version 3, Inform reads this as call_vs in higher versions: it calls the routine with 0, 1, 2 or 3 arguments as supplied and stores the resulting return value. (When the address 0 is called as a routine, nothing happens and the return value is false.)
1OP:143 F 5 call_1n routine
Executes routine() and throws away result.
1OP:136 8 4 call_1s routine -> (result)
Stores routine().
2OP:26 1A 5 call_2n routine arg1
Executes routine(arg1) and throws away result.
2OP:25 19 4 call_2s routine arg1 -> (result)
Stores routine(arg1).
VAR:249 19 5 call_vn routine ...up to 3 args...
Like call, but throws away result.
VAR:224 0 4 call_vs routine ...up to 3 args... -> (result)
See call.
VAR:250 1A 5 call_vn2 routine ...up to 7 args...
Call with a variable number (from 0 to 7) of arguments, then throw away the result. This (and call_vs2) uniquely have an extra byte of opcode types to specify the types of arguments 4 to 7. Note that it is legal to use these opcodes with fewer than 4 arguments (in which case the second byte of type information will just be $ff).
VAR:236 C 4 call_vs2 routine ...up to 7 args... -> (result)
See call_vn2.
0OP:185 9 5/6 catch -> (result)
Opposite to throw (and occupying the same opcode that pop used in Versions 3 and 4). catch returns the current "stack frame".
VAR:255 1F 5 check_arg_count argument-number
Branches if the given argument-number (counting from 1) has been provided by the routine call to the current routine. (This allows routines in Versions 5 and later to distinguish between the calls routine(1) and routine(1,0), which would otherwise be impossible to tell apart.)
EXT:12 C 5/* check_unicode char-number -> (result)
Determines whether or not the interpreter can print, or receive from the keyboard, the given Unicode character. Bit 0 of the result should be set if and only if the interpreter can print the character; bit 1 if and only if the interpreter can receive it from the keyboard. Bits 2 to 15 are undefined.
***[1.0] This opcode will only be present in interpreters obeying Standard 1.0 or later, so story files should check the standard number of the interpreter before executing this opcode.
2OP:12 C clear_attr object attribute
Make object not have the attribute numbered attribute.
VAR:253 1D 5 copy_table first second size
If second is zero, then size bytes of first are zeroed.
Otherwise first is copied into second, its length in bytes being the absolute value of size (i.e., size if size is positive, -size if size is negative).
The tables are allowed to overlap. If size is positive, the interpreter must copy either forwards or backwards so as to avoid corrupting first in the copying process. If size is negative, the interpreter must copy forwards even if this corrupts first. ('Beyond Zork' uses this to fill an array with spaces.)
(Version 0.2 of this document wrongly specified that if size is positive then copying should always run backward. This results in the player being unable to cross the river near the start of 'Journey', as the game uses copy_table to shuffle menu options, and the menu "Downstream, Upstream, Cross, Return" is changed to "Return, Return, Return".)
1OP:134 6 dec (variable)
Decrement variable by 1. This is signed, so 0 decrements to -1.
2OP:4 4 dec_chk (variable) value ?(label)
Decrement variable, and branch if it is now less than the given value.
2OP:23 17 div a b -> (result)
Signed 16-bit division. Division by zero should halt the interpreter with a suitable error message.
EXT:5 5 6 draw_picture picture-number y x
Displays the picture with the given number. (y,x) coordinates (of the top left of the picture) are each optional, in that a value of zero for y or x means the cursor y or x coordinate in the current window. It is illegal to call this with an invalid picture number.
VAR:252 1C 5 encode_text zscii-text length from coded-text
Translates a ZSCII word to Z-encoded text format (stored at coded-text), as if it were an entry in the dictionary. The text begins at from in the zscii-text buffer and is length characters long. (Some interpreters ignore this and keep translating until they hit a 0 character anyway, or have already filled up the 6-byte Z-encoded string.)
VAR:238 E 4/6 erase_line value
Versions 4 and 5: if the value is 1, erase from the current cursor position to the end of its line in the current window. If the value is anything other than 1, do nothing.
Version 6: if the value is 1, erase from the current cursor position to the end of the its line in the current window. If not, erase the given number of pixels minus one across from the cursor (clipped to stay inside the right margin). The cursor does not move.
EXT:7 7 6 erase_picture picture-number y x
Like draw_picture, but paints the appropriate region to the background colour for the given window. It is illegal to call this with an invalid picture number.
VAR:237 D 4 erase_window window
Erases window with given number (to background colour); or if -1 it unsplits the screen and clears the lot; or if -2 it clears the screen without unsplitting it. In cases -1 and -2, the cursor may move (see S 8 for precise details).
This byte (decimal 190) is not an instruction, but indicates that the opcode is "extended": the next byte contains the number in the extended set.
1OP:130 2 get_child object -> (result) ?(label)
Get first object contained in given object, branching if this exists, i.e. is not nothing (i.e., is not 0).
VAR:240 10 4/6 get_cursor array
Puts the current cursor row into the word 0 of the given array, and the current cursor column into word 1. (The array is not a table and has no size information in its initial entry.)
2OP:19 13 get_next_prop object property -> (result)
Gives the number of the next property provided by the quoted object. This may be zero, indicating the end of the property list; if called with zero, it gives the first property number present. It is illegal to try to find the next property of a property which does not exist, and an interpreter should halt with an error message (if it can efficiently check this condition).
1OP:131 3 get_parent object -> (result)
Get parent object (note that this has no "branch if exists" clause).
2OP:17 11 get_prop object property -> (result)
Read property from object (resulting in the default value if it had no such declared property). If the property has length 1, the value is only that byte. If it has length 2, the first two bytes of the property are taken as a word value. It is illegal for the opcode to be used if the property has length greater than 2, and the result is unspecified.
2OP:18 12 get_prop_addr object property -> (result)
Get the byte address (in dynamic memory) of the property data for the given object's property. This must return 0 if the object hasn't got the property.
1OP:132 4 get_prop_len property-address -> (result)
Get length of property data (in bytes) for the given object's property. It is illegal to try to find the property length of a property which does not exist for the given object, and an interpreter should halt with an error message (if it can efficiently check this condition).
@get_prop_len 0 must return 0. This is required by some Infocom games and files generated by old versions of Inform.
1OP:129 1 get_sibling object -> (result) ?(label)
Get next object in tree, branching if this exists, i.e. is not 0.
EXT:19 13 6 get_wind_prop window property-number -> (result)
Reads the given property of the given window (see S 8).
1OP:133 5 inc (variable)
Increment variable by 1. (This is signed, so -1 increments to 0.)
2OP:5 5 inc_chk (variable) value ?(label)
Increment variable, and branch if now greater than value.
VAR:244 14 3 input_stream number
Selects the current input stream.
2OP:14 E insert_obj object destination
Moves object O to become the first child of the destination object D. (Thus, after the operation the child of D is O, and the sibling of O is whatever was previously the child of D.) All children of O move with it. (Initially O can be at any point in the object tree; it may legally have parent zero.)
2OP:1 1 je a b c d ?(label)
Jump if a is equal to any of the subsequent operands. (Thus @je a never jumps and @je a b jumps if a = b.)
je with just 1 operand is not permitted.
2OP:3 3 jg a b ?(label)
Jump if a > b (using a signed 16-bit comparison).
2OP:6 6 jin obj1 obj2 ?(label)
Jump if object a is a direct child of b, i.e., if parent of a is b.
2OP:2 2 jl a b ?(label)
Jump if a < b (using a signed 16-bit comparison).
1OP:140 C jump ?(label)
Jump (unconditionally) to the given label. (This is not a branch instruction and the operand is a 2-byte signed offset to apply to the program counter.) It is legal for this to jump into a different routine (which should not change the routine call state), although it is considered bad practice to do so and the Txd disassembler is confused by it.
The destination of the jump opcode is:
Address after instruction + Offset - 2
This is analogous to the calculation for branch offsets.
1OP:128 0 jz a ?(label)
Jump if a = 0.
1OP:142 E load (variable) -> (result)
The value of the variable referred to by the operand is stored in the result. (Inform doesn't use this; see the notes to S 14.)
2OP:16 10 loadb array byte-index -> (result)
Stores array->byte-index (i.e., the byte at address array+byte-index, which must lie in static or dynamic memory).
2OP:15 F loadw array word-index -> (result)
Stores array-->word-index (i.e., the word at address array+2*word-index, which must lie in static or dynamic memory).
EXT:2 2 5 log_shift number places -> (result)
Does a logical shift of number by the given number of places, shifting left (i.e. increasing) if places is positive, right if negative. In a right shift, the sign is zeroed instead of being shifted on. (See also art_shift.)
The "places" operand must be in the range -15 to +15, otherwise behaviour is undefined.
EXT:27 1B 6 make_menu number table ?(label)
Controls menus with numbers greater than 2 (i.e., it doesn't control the three system menus). If the table supplied is 0, the menu is removed. Otherwise it is a table of tables. Each table is a ZSCII string: the first item being a menu name, subsequent ones the entries.
2OP:24 18 mod a b -> (result)
Remainder after signed 16-bit division. Division by zero should halt the interpreter with a suitable error message.
EXT:23 17 6 mouse_window window
Constrain the mouse arrow to sit inside the given window. By default it sits in window 1. Setting to -1 takes all restriction away. (The mouse clicks are not reported if the arrow is outside the window and interpreters are presumably supposed to hold the arrow there by hardware means if possible.)
EXT:16 10 6 move_window window y x
Moves the given window to pixels (y,x): (1,1) being the top left. Nothing actually happens (since windows are entirely notional transparencies): but any future plotting happens in the new place.
2OP:22 16 mul a b -> (result)
Signed 16-bit multiplication.
0OP:187 B new_line
Print carriage return.
0OP:180 4 1/- nop
Probably the official "no operation" instruction, which, appropriately, was never operated (in any of the Infocom datafiles): it may once have been a breakpoint.
1OP:143 F 1/4 not value -> (result)
VAR:248 18 5/6 not value -> (result)
Bitwise NOT (i.e., all 16 bits reversed). Note that in Versions 3 and 4 this is a 1OP instruction, reasonably since it has 1 operand, but in later Versions it was moved into the extended set to make room for call_1n.
2OP:8 8 or a b -> (result)
Bitwise OR.
VAR:243 13 3 output_stream number table
6 output_stream number table width
If stream is 0, nothing happens. If it is positive, then that stream is selected; if negative, deselected. (Recall that several different streams can be selected at once.)
When stream 3 is selected, a table must be given into which text can be printed. The first word always holds the number of characters printed, the actual text being stored at bytes table+2 onward. It is not the interpreter's responsibility to worry about the length of this table being overrun.
In Version 6, a width field may optionally be given: text will then be justified as if it were in the window with that number (if width is zero or positive) or a box -width pixels wide (if negative). Then the table will contain not ordinary text but formatted text: see print_form.
EXT:6 6 6 picture_data picture-number array ?(label)
Asks the interpreter for data on the picture with the given number. If the picture number is valid, a branch occurs and information is written to the array: the height in word 0, the width in word 1, in pixels. (This is an array, not a "table" with initial size information.)
Otherwise, if the picture number is zero, the interpreter writes the number of available pictures into word 0 of the array and the release number of the picture file into word 1, and branches if any pictures are available. (Infocom's first Version 6 Amiga interpreter did not handle this case properly, and early releases of 'Zork Zero' did not use it. The feature may have been added on the MSDOS release of 'Zork Zero'.)
Otherwise, nothing happens.
EXT:28 1C 6 picture_table table
Given a table of picture numbers, the interpreter may if it wishes load or unpack these pictures from disc into a cache for convenient rapid plotting later. 'Zork Zero' makes frequent use of this, for instance for its peggleboard display. Moreover, it expects rapid plotting only for those images listed in the last call to picture_table. In other words, any images still in the cache when picture_table is called can safely be thrown away. (The Amiga interpreter 6.14 uses a cache of size 5K and never caches any individual image larger than 1K.)
0OP:191 F 5/- piracy ?(label)
Branches if the game disc is believed to be genuine by the interpreter (which is assumed to have some arcane way of finding out). Interpreters are asked to be gullible and to unconditionally branch.
0OP:185 9 1 pop
Throws away the top item on the stack. (This was useful to lose unwanted routine call results in early Versions.)
EXT:21 15 6 pop_stack items stack
The given number of items are thrown away from the top of a stack: by default the system stack, otherwise the one given as a second operand.
0OP:178 2 print <literal-string>
Print the quoted (literal) Z-encoded string.
1OP:135 7 print_addr byte-address-of-string
Print (Z-encoded) string at given byte address, in dynamic or static memory.
VAR:229 5 print_char output-character-code
Print a ZSCII character. The operand must be a character code defined in ZSCII for output (see S 3). In particular, it must certainly not be negative or larger than 1023.
EXT:26 1A 6 print_form formatted-table
Prints a formatted table of the kind written to output stream 3 when formatting is on. This is an elaborated version of print_table to cope with fonts, pixels and other impedimenta. It is a sequence of lines, terminated with a zero word. Each line is a word containing the number of characters, followed by that many bytes which hold the characters concerned.
VAR:230 6 print_num value
Print (signed) number in decimal.
1OP:138 A print_obj object
Print short name of object (the Z-encoded string in the object header, not a property). If the object number is invalid, the interpreter should halt with a suitable error message.
1OP:141 D print_paddr packed-address-of-string
Print the (Z-encoded) string at the given packed address in high memory.
0OP:179 3 print_ret <literal-string>
Print the quoted (literal) Z-encoded string, then print a new-line and then return true (i.e., 1).
VAR:254 1E 5 print_table zscii-text width height skip
Print a rectangle of text on screen spreading right and down from the current cursor position, of given width and height, from the table of ZSCII text given. (Height is optional and defaults to 1.) If a skip value is given, then that many characters of text are skipped over in between each line and the next. (So one could make this display, for instance, a 2 by 3 window onto a giant 40 by 40 character graphics map.)
EXT:11 B 5/* print_unicode char-number
Print a Unicode character. See S <IP_ADDRESS> and S 7.5 for details. The given character code must be defined in Unicode.
***[1.0] This opcode will only be present in interpreters obeying Standard 1.0 or later, so story files should check the standard number of the interpreter before executing this opcode.
VAR:233 9 1 pull (variable)
6 pull stack -> (result)
Pulls value off a stack. (If the stack underflows, the interpreter should halt with a suitable error message.) In Version 6, the stack in question may be specified as a user one: otherwise it is the game stack.
VAR:232 8 push value
Pushes value onto the game stack.
EXT:24 18 6 push_stack value stack ?(label)
Pushes the value onto the specified user stack, and branching if this was successful. If the stack overflows, nothing happens (this is not an error condition).
VAR:227 3 put_prop object property value
Writes the given value to the given property of the given object. If the property does not exist for that object, the interpreter should halt with a suitable error message. If the property length is 1, then the interpreter should store only the least significant byte of the value. (For instance, storing -1 into a 1-byte property results in the property value 255.) As with get_prop the property length must not be more than 2: if it is, the behaviour of the opcode is undefined.
EXT:25 19 6 put_wind_prop window property-number value
Writes a window property (see get_wind_prop). This should only be used when there is no direct command (such as move_window) to use instead, as some such operations may have side-effects.
0OP:186 A quit
Exit the game immediately. (Any "Are you sure?" question must be asked by the game, not the interpreter.) It is not legal to return from the main routine (that is, from where execution first begins) and this must be used instead.
VAR:231 7 random range -> (result)
If range is positive, returns a uniformly random number between 1 and range. If range is negative, the random number generator is seeded to that value and the return value is 0. Most interpreters consider giving 0 as range illegal (because they attempt a division with remainder by the range), but correct behaviour is to reseed the generator in as random a way as the interpreter can (e.g. by using the time in milliseconds).
(Some version 3 games, such as 'Enchanter' release 29, had a debugging verb #random such that typing, say, #random 14 caused a call of random with -14.)
VAR:228 4 1 sread text parse
4 sread text parse time routine
5 aread text parse time routine -> (result)
(Note that Inform internally names the read opcode as aread in Versions 5 and later and sread in Versions 3 and 4.)
This opcode reads a whole command from the keyboard (no prompt is automatically displayed). It is legal for this to be called with the cursor at any position on any window.
In Versions 1 to 3, the status line is automatically redisplayed first.
A sequence of characters is read in from the current input stream until a carriage return (or, in Versions 5 and later, any terminating character) is found.
In Versions 1 to 4, byte 0 of the text-buffer should initially contain the maximum number of letters which can be typed, minus 1 (the interpreter should not accept more than this). The text typed is reduced to lower case (so that it can tidily be printed back by the program if need be) and stored in bytes 1 onward, with a zero terminator (but without any other terminator, such as a carriage return code). (This means that if byte 0 contains n then the buffer must contain n+1 bytes, which makes it a string array of length n in Inform terminology.)
In Versions 5 and later, byte 0 of the text-buffer should initially contain the maximum number of letters which can be typed (the interpreter should not accept more than this). The interpreter stores the number of characters actually typed in byte 1 (not counting the terminating character), and the characters themselves (reduced to lower case) in bytes 2 onward (not storing the terminating character). (Some interpreters wrongly add a zero byte after the text anyway, so it is wise for the buffer to contain at least n+3 bytes.)
Moreover, if byte 1 contains a positive value at the start of the input, then read assumes that number of characters are left over from an interrupted previous input, and writes the new characters after those already there. Note that the interpreter does not redisplay the characters left over: the game does this, if it wants to. This is unfortunate for any interpreter wanting to give input text a distinctive appearance on-screen, but 'Beyond Zork', 'Zork Zero' and 'Shogun' clearly require it. ("Just a tremendous pain in my butt" -- Andrew Plotkin; "the most unfortunate feature of the Z-machine design" -- Stefan Jokisch.)
In Version 4 and later, if the operands time and routine are supplied (and non-zero) then the routine call routine() is made every time/10 seconds during the keyboard-reading process. If this routine returns true, all input is erased (to zero) and the reading process is terminated at once. (The terminating character code is 0.) The routine is permitted to print to the screen even if it returns false to signal "carry on": the interpreter should notice and redraw the input line so far, before input continues. (Frotz notices by looking to see if the cursor position is at the left-hand margin after the interrupt routine has returned.)
If input was terminated in the usual way, by the player typing a carriage return, then a carriage return is printed (so the cursor moves to the next line). If it was interrupted, the cursor is left at the rightmost end of the text typed in so far.
Next, lexical analysis is performed on the text (except that in Versions 5 and later, if parse-buffer is zero then this is omitted). Initially, byte 0 of the parse-buffer should hold the maximum number of textual words which can be parsed. (If this is n, the buffer must be at least 2 + 4*n bytes long to hold the results of the analysis.)
The interpreter divides the text into words and looks them up in the dictionary, as described in S 13. The number of words is written in byte 1 and one 4-byte block is written for each word, from byte 2 onwards (except that it should stop before going beyond the maximum number of words specified). Each block consists of the byte address of the word in the dictionary, if it is in the dictionary, or 0 if it isn't; followed by a byte giving the number of letters in the word; and finally a byte giving the position in the text-buffer of the first letter of the word.
In Version 5 and later, this is a store instruction: the return value is the terminating character (note that the user pressing his "enter" key may cause either 10 or 13 to be returned; the interpreter must return 13). A timed-out input returns 0.
(Versions 1 and 2 and early Version 3 games mistakenly write the parse buffer length 240 into byte 0 of the parse buffer: later games fix this bug and write 59, because 2+4*59 = 238 so that 59 is the maximum number of textual words which can be parsed into a buffer of length 240 bytes. Old versions of the Inform 5 library commit the same error. Neither mistake has very serious consequences.)
(Interpreters are asked to halt with a suitable error message if the text or parse buffers have length of less than 3 or 6 bytes, respectively: this sometimes occurs due to a previous array being overrun, causing bugs which are very difficult to find.)
VAR:246 16 4 read_char 1 time routine -> (result)
Reads a single character from input stream 0 (the keyboard). The first operand must be 1 (presumably it was provided to support multiple input devices, but only the keyboard was ever used). time and routine are optional (in Versions 4 and later only) and dealt with as in read above.
EXT:22 16 6 read_mouse array
The four words in the array are written with the mouse y coordinate, x coordinate, button bits, and a menu word.
The buttons bits are arranged so that the "primary" button is the lowest bit, the "secondary" (if present) is the next lowest bit, and so on, up to a potential 16 buttons. The ordering of buttons should be that which is most natural for the host system. Here are some suggested assignments:
Button assignments Platform Bit 0 (low) Bit 1 Bit 2 ---------------------------------------- RISC OS Select Adjust Menu MacOS Primary/only Secondary Tertiary ... Windows Left Right Middle X Left Right Middle
In the menu word, the upper byte is the menu number and the lower byte is the item number (from 0). (Note that the array isn't a table and has no initial size information. The data is written to words 0 to 3 in the array.)
1OP:137 9 remove_obj object
Detach the object from its parent, so that it no longer has any parent. (Its children remain in its possession.)
0OP:183 7 1 restart
Restart the game. (Any "Are you sure?" question must be asked by the game, not the interpreter.) The only pieces of information surviving from the previous state are the "transcribing to printer" bit (bit 0 of 'Flags 2' in the header, at address $10) and the "use fixed pitch font" bit (bit 1 of 'Flags 2').
In particular, changing the program start address before a restart will not have the effect of restarting from this new address.
0OP:182 6 1 restore ?(label)
0OP:182 5 4 restore -> (result)
EXT:1 1 5 restore table bytes name prompt-> (result)
See save. In Version 3, the branch is never actually made, since either the game has successfully picked up again from where it was saved, or it failed to load the save game file.
As with restart, the transcription and fixed font bits survive. The interpreter gives the game a way of knowing that a restore has just happened (see save).
***[1.0] From Version 5 it can have optional parameters as save does, and returns the number of bytes loaded if so. (Whether Infocom intended these options as part of Version 5 is doubtful, but it's too useful a feature to exclude from this Standard.)
If the restore fails, 0 is returned, but once again this necessarily happens since otherwise control is already elsewhere.
EXT:10 A 5 restore_undo -> (result)
Like restore, but restores the state saved to memory by save_undo. (The optional parameters of restore may not be supplied.) The behaviour of restore_undo is unspecified if no save_undo has previously occurred (and a game may not legally use it): an interpreter might simply ignore this.
1OP:139 B ret value
Returns from the current routine with the value given.
0OP:184 8 ret_popped
Pops top of stack and returns that. (This is equivalent to ret sp, but is one byte cheaper.)
0OP:177 1 rfalse
Return false (i.e., 0) from the current routine.
0OP:176 0 rtrue
Return true (i.e., 1) from the current routine.
0OP:181 5 1 save ?(label)
0OP:181 5 4 save -> (result)
EXT:0 0 5 save table bytes name prompt -> (result)
On Versions 3 and 4, attempts to save the game (all questions about filenames are asked by interpreters) and branches if successful. From Version 5 it is a store rather than a branch instruction; the store value is 0 for failure, 1 for "save succeeded" and 2 for "the game is being restored and is resuming execution again from here, the point where it was saved".
It is illegal to use this opcode within an interrupt routine (one called asynchronously by a sound effect, or keyboard timing, or newline counting).
***[1.0] The extension also has (optional) parameters, which save a region of the save area, whose address and length are in bytes, and provides a suggested filename: name is a pointer to an array of ASCII characters giving this name (as usual preceded by a byte giving the number of characters). See S 7.6. (Whether Infocom intended these options as part of Version 5 is doubtful, but it's too useful a feature to exclude from this Standard.)
***[1.1] As of Standard 1.1 an additional optional parameter, prompt, is allowed on Version 5 extended save/restore. This allows a game author to tell the interpreter whether it should ask for confirmation of the provided file name (prompt is 1), or just silently save/restore using the provided filename (prompt is 0). If the parameter is not provided, whether to prompt or not is a matter for the interpreter - this might be globally user-configurable. Infocom's interpreters do prompt for filenames, many modern ones do not.
EXT:9 9 5 save_undo -> (result)
Like save, except that the optional parameters may not be specified: it saves the game into a cache of memory held by the interpreter. If the interpreter is unable to provide this feature, it must return -1: otherwise it returns the save return value.
It is illegal to use this opcode within an interrupt routine (one called asynchronously by a sound effect, or keyboard timing, or newline counting).
(This call is typically needed once per turn, in order to implement "UNDO", so it needs to be quick.)
VAR:247 17 4 scan_table x table len form -> (result)
Is x one of the words in table, which is len words long? If so, return the address where it first occurs and branch. If not, return 0 and don't.
The form is optional (and only used in Version 5?): bit 7 is set for words, clear for bytes: the rest contains the length of each field in the table. (The first word or byte in each field being the one looked at.) Thus $82 is the default.
EXT:20 14 6 scroll_window window pixels
Scrolls the given window by the given number of pixels (a negative value scrolls backwards, i.e., down) writing in blank (background colour) pixels in the new lines. This can be done to any window and is not related to the "scrolling" attribute of a window.
2OP:11 B set_attr object attribute
Make object have the attribute numbered attribute.
2OP:27 1B 5 set_colour foreground background
6 set_colour foreground background window
If coloured text is available, set text to be foreground-against-background. (Flush any buffered text to screen, in the old colours, first.) In version 6, the window argument is optional and is by default the current window. (This option is supported in Infocom's Amiga and DOS interpreters.)
(One Version 5 game uses this: 'Beyond Zork' (Paul David Doherty reports it as used "76 times in 870915 and 870917, 58 times in 871221") and from the structure of the table it clearly logically belongs in version 5.)
VAR:239 F 4 set_cursor line column
6 set_cursor line column window
Move cursor in the current window to the position (x,y) (in units) relative to (1,1) in the top left. (In Version 6 the window is supplied and need not be the current one. Also, if the cursor would lie outside the current margin settings, it is moved to the left margin of the current line.)
In Version 6, set_cursor -1 turns the cursor off, and either set_cursor -2 or set_cursor -2 0 turn it back on. It is not known what, if anything, this second argument means: in all known cases it is 0.
EXT:4 4 5 set_font font -> (result)
EXT:4 4 6 set_font font window -> (result)
If the requested font is available, then it is chosen for the current window, and the store value is the font ID of the previous font (which is always positive). If the font is unavailable, nothing will happen and the store value is 0.
If the font ID requested is 0, the font is not changed, and the ID of the current font is returned.
(Infocom's old interpreters did not store 0 for an unavailable font, but the feature is clearly useful and so was introduced in release 0.2 of this Standard.
***[1.1] In Version 6, set_font has an optional window parameter, as for set_colour. This was part of the original Infocom design, but omitted by earlier Standards. It is reinstated here, as it is useful to be able to measure a font that is about to be used in another window, so that window can be sized before attempting to place the cursor in it. A window number of -3 signifies "the currently selected window"
EXT:8 8 6 set_margins left right window
Sets the margin widths (in pixels) on the left and right for the given window (which are by default 0). If the cursor is overtaken and now lies outside the margins altogether, move it back to the left margin of the current line (see S <IP_ADDRESS>.2.1).
VAR:241 11 4 set_text_style style
Sets the text style to: Roman (if 0), Reverse Video (if 1), Bold (if 2), Italic (4), Fixed Pitch (8). In some interpreters (though this is not required) a combination of styles is possible (such as reverse video and bold). In these, changing to Roman should turn off all the other styles currently set.
***[1.1] As of Standard 1.1, it is legal to request style combinations in a single set_text_style opcode by adding the values (which are powers of two) together. If the parameter is non-zero, then all the styles given are activated. If the parameter is zero, then all styles are deactivated. If the interpreter is unable to provide the requested style combination, it must give precedence first to the styles requested in the most recent call to set_text_style, and within that to the highest bit, making the priority Fixed, Italic, Bold, Reverse.
EXT:13 D 5/* set_true_colour foreground background
EXT:13 D 6/* set_true_colour foreground background window
The foreground and background are 15-bit colour values:
bit 15 = 0 bits 14-10 blue bits 9-5 green bits 4-0 red
The optional window parameter is only allowed in V6, and operates the same as in set_colour.
***[1.1] This opcode will only be present in interpreters obeying Standard 1.1 or later, so story files should check the standard number of the interpreter before executing this opcode.
VAR:235 B 3 set_window window
Selects the given window for text output.
0OP:188 C 3 show_status
(In Version 3 only.) Display and update the status line now (don't wait until the next keyboard input). (In theory this opcode is illegal in later Versions but an interpreter should treat it as nop, because Version 5 Release 23 of 'Wishbringer' contains this opcode by accident.)
VAR:245 15 5/3 sound_effect number effect volume routine
The given effect happens to the given sound number. The low byte of volume holds the volume level, the high byte the number of repeats. (The value 255 means "loudest possible" and "forever" respectively.) (The "repeats" parameter indicates the total number of times to play the sound, not the number of times to repeat it after the first play.) (In Version 3, repeats are unsupported and the high byte must be 0.)
Note that sound effect numbers 1 and 2 are bleeps (see S 9) and in these cases the other operands must be omitted. Conversely, if any of the other operands are present, the sound effect number must be 3 or higher.
The effect can be: 1 (prepare), 2 (start), 3 (stop), 4 (finish with).
In Versions 5 and later, the routine is called (with no parameters) after the sound has been finished (it has been playing in the background while the Z-machine has been working on other things). (This is used by 'Sherlock' to implement fading in and out, which explains why mysterious numbers like $34FB were previously thought to be to do with fading.) The routine is not called if the sound is stopped by another sound or by an effect 3 call.
See the remarks to S 9 for which forms of this opcode were actually used by Infocom.
In theory, @sound_effect; (with no operands at all) is illegal. However interpreters are asked to beep (as if the operand were 1) if possible, and in any case not to halt.
Setting repeats to zero in V5 is illegal - it is suggested that interpreters treat this as a request to play the sound once, and maybe issue a warning.
To clarify:
@sound_effect number 3/4
will stop (and optionally unload) sound "number" if it is currently playing (or loaded). Otherwise it is ignored.
@sound_effect 0 3/4
will stop (and unload) all sounds - music and effects.
VAR:234 A 3 split_window lines
Splits the screen so that the upper window has the given number of lines: or, if this is zero, unsplits the screen again. In Version 3 (only) the upper window should be cleared after the split.
In Version 6, this is supposed to roughly emulate the earlier Version 5 behaviour (see S 8), though the line count is in units rather than lines. (Existing Version 6 games seem to use this opcode only for bounding cursor movement. 'Journey' creates a status region which is the whole screen and then overlays it with two other windows.)
Windows 0 and 1 are tiled together to fill the screen, so that window 1 has the given height and is placed at the top left, while window 0 is placed just below it (with its height suitably shortened, possibly making it disappear altogether if window 1 occupies the whole screen).
A cursor remains in the same absolute screen position (which means that its y-coordinate will be different relative to the window origin, since this origin will have moved) unless this position is no longer in the window at all, in which case it is moved to the window origin (at the top left of the window).
This is the Inform name for the keyboard-reading opcode under Versions 3 and 4. (Inform calls the same opcode aread in later Versions.) See read for the specification.
2OP:13 D store (variable) value
Set the VARiable referenced by the operand to value.
VAR:226 2 storeb array byte-index value
array->byte-index = value, i.e. stores the given value in the byte at address array+byte-index (which must lie in dynamic memory). (See loadb.)
VAR:225 1 storew array word-index value
array-->word-index = value, i.e. stores the given value in the word at address array+2*word-index (which must lie in dynamic memory). (See loadw.)
2OP:21 15 sub a b -> (result)
Signed 16-bit subtraction.
2OP:7 7 test bitmap flags ?(label)
Jump if all of the flags in bitmap are set (i.e. if bitmap & flags == flags).
See clear_flag. (ITF implements this as unconditionally false.)
2OP:10 A test_attr object attribute ?(label)
Jump if object has attribute.
2OP:28 1C 5/6 throw value stack-frame
Opposite of catch: resets the routine call state to the state it had when the given stack frame value was 'caught', and then returns. In other words, it returns as if from the routine which executed the catch which found this stack frame value.
VAR:251 1B 5 tokenise text parse dictionary flag
This performs lexical analysis (see read above).
The dictionary and flag operands are optional.
If a non-zero dictionary is supplied, it is used (if not, the ordinary game dictionary is). If the flag is set, unrecognised words are not written into the parse buffer and their slots are left unchanged: this is presumably so that if several tokenise instructions are performed in a row, each fills in more slots without wiping those filled by the others.
Parsing a user dictionary is slightly different. A user dictionary should look just like the main one but need not be alphabetically sorted. If the number of entries is given as -n, then the interpreter reads this as "n entries unsorted". This is very convenient if the table is being altered in play: if, for instance, the player is naming things.
0OP:189 D 3 verify ?(label)
Verification counts a (two byte, unsigned) checksum of the file from $0040 onwards (by taking the sum of the values of each byte in the file, modulo $10000) and compares this against the value in the game header, branching if the two values agree. (Early Version 3 games do not have the necessary checksums to make this possible.)
The interpreter must stop calculating when the file length (as given in the header) is reached. It is legal for the file to contain more bytes than this, but if so the extra bytes should all be 0. (Some story files are padded out to an exact number of virtual-memory pages.) However, many Infocom story files in fact contain non-zero data in the padding, so interpreters must be sure to exclude the padding from checksum calculations.
EXT:17 11 6 window_size window y x
Change size of window in pixels. (Does not change the current display.)
EXT:18 12 6 window_style window flags operation
Changes attributes for a given window. A bitmap of attributes is given, in which the bits are: 0 -- keep text within margins, 1 -- scroll when at bottom, 2 -- copy text to output stream 2 (the printer), 3 -- buffer text to word-wrap it between the margins of the window.
The operation, by default, is 0, meaning "set to these settings". 1 means "set the bits supplied". 2 means "clear the ones supplied", and 3 means "reverse the bits supplied" (i.e. eXclusive OR).
Section 1 / 2 / 3 / 4 / 5 / 6 / 7 / 8 / 9 / 10 / 11 / 12 / 13 / 14 / 15 / 16
Appendix A / B / C / D / E / F


{% macro warnings_and_loader() -%}
Oppia is a free, open-source learning platform full of interactive activities called 'explorations'. Sadly, Oppia requires JavaScript to be enabled in your web browser in order to function properly and your web browser has JavaScript disabled. If you need help enabling JavaScript, click here.
Thank you.


Strong is used to indicate strong importance
This text has added emphasis
The b element is stylistically different text from normal text, without any special importance
The i element is text that is set off from the normal text
A paragraph (from the Greek paragraphos, "to write beside" or "written beside") is a self-contained unit of a discourse in writing dealing with a particular point or idea. A paragraph consists of one or more sentences. Though not required by the syntax of any language, paragraphs are usually an expected part of formal writing, used to organize longer prose.
A block quotation (also known as a long quotation or extract) is a quotation in a written document, that is set off from the main text as a paragraph, or block of text, and typically distinguished visually using indentation and a different typeface or smaller size quotation.
Strong is used to indicate strong importance
This text has added emphasis
The b element is stylistically different text from normal text, without any special importance
The i element is text that is set off from the normal text


---
layout: post
title: 2/13
date: '2013-02-13T22:30:00.001-07:00'
author: Jacob .
tags:
modified_time: '2013-02-13T22:30:36.414-07:00'
blogger_id: tag:blogger.com,1999:blog-6400085873105072120.post-5872128825678723584
blogger_orig_url: http://www.svlark.com/2013/02/213.html
---
We took a night off housework tonight, but Audrey did a nice job with lesson 65 today and I got to spend some good time on the bus today reviewing Pat's swing trading strategies.
239.4


REST Web Services
Aperture services are implemented in REST. The JavaScript API wraps these service interfaces for JavaScript clients, adding a minimal amount of message formatting and handling for convenience. Other clients may make use of Aperture services by calling their REST interfaces directly.Common MIME Types
Aperture REST services currently exchange all messages as application/json, except where services return images. Support for XML and / or binary protocol buffers are future considerations.Optional, Modular Deployment
The client JavaScript library exposes Aperture services for optional use. It is possible to write Aperture visualizations that require no Aperture services at all. In these cases, deployment is simply a matter of including aperture.js.Similarly, Aperture services can be deployed and used without the client JavaScript library, as independent modules. The easiest method of deploying the full collection of services is to simply drop a copy of the compiled aperture.war and server config file into a web server. However, clients may alternatively choose to package and deploy only those services required for a particular application.


This browser does not support the video element.
"Okay Google, find a frosting recipe for..." Play your story to find out more.
You ran out of time. Please move on.


Baristas generally operate a commercial espresso machine; the three most common types are manual, semi automatic or automatic. A manual machine involves pulling a lever to push the water through the ground coffee. A semi-automatic uses an electric pump to push the water through the coffee grounds, but the barista has to stop the flow of espresso using an on\off switch or button. An automatic machine will turn on and off after a preset amount of water has been pushed through the grounds. The barista usually has been trained to operate the machine and to prepare the coffee based on the guidelines of the roaster or shop owner.
The role of a barista is to acquire knowledge of the entire process of coffee to effectively prepare a desired cup of coffee. This knowledge includes the correct operation, maintenance and programming of the machine, grinding and tamping methods, extraction times, water temperature and quality, micro milk frothing, free pouring, latte art, roasting, coffee plant cultivation, drying methods, correct storage, renewable methods of disposal, recycling of the coffee and packaging used.
A barista can acquire these skills by attending barista training classes or on-the-job training.
CC-BY-SA Wikipedia


Locatioin:
Catalog:
User ID
e-mail
Employee Number
Full Name
Location
Company
Department
Title
Add All
{{acct.userId}}
{{acct.email}}
{{acct.employeeNumber}}
{{acct.fullName}}
{{acct.location}}
{{acct.company}}
{{acct.department}}
{{acct.title}}
Add
Add All


Brain Rush
Can you handle the rush?
Are you sure? All your progress and data will be cleared, and this action cannot be undone.
Please play fair and refrain from switching tabs while playing. This is warning 1. Once you reach 5 warnings, your game will automatically reset.
Can you handle the rush?

Leaderboard Exit5
Answer Streak: 0
Money: ₱ 0
Question 1:
The popular children's song It's Raining, It's Pouring mentions an old man doing what?
Level 1
25
→
←
←
End Now
Continue


Provides two main functions, il() and fil(). The il() function implements the EM algorithm developed by Ibrahim and Lipsitz (1996) <doi:10.2307/2533068> to estimate the parameters of a logistic regression model with the missing response when the missing data mechanism is nonignorable. The fil() function implements the algorithm proposed by Maity et. al. (2017+) <https://github.com/arnabkrmaity/brlrmr> to reduce the bias produced by the method of Ibrahim and Lipsitz (1996) <doi:10.2307/2533068>.
| Version: | 0.1.5 |
| Depends: | R (≥ 2.10) |
| Imports: | boot, brglm, MASS, profileModel, Rcpp, stats |
| Published: | 2017-07-17 |
| Author: | Arnab Maity [aut, cre], Vivek Pradhan [ctb], Ujjwal Das [ctb] |
| Maintainer: | Arnab Maity <akumar at stat.tamu.edu> |
| License: | GPL-3 |
| NeedsCompilation: | no |
| In views: | MissingData |
| CRAN checks: | brlrmr results |
| Reference manual: | brlrmr.pdf |
| Package source: | brlrmr_0.1.5.tar.gz |
| Windows binaries: | r-devel: brlrmr_0.1.5.zip, r-release: brlrmr_0.1.5.zip, r-oldrel: brlrmr_0.1.5.zip |
| OS X binaries: | r-release: brlrmr_0.1.5.tgz, r-oldrel: brlrmr_0.1.5.tgz |
| Old sources: | brlrmr archive |
Please use the canonical form https://CRAN.R-project.org/package=brlrmr to link to this page.


Menu ☰
DusterTheFirst's Github Webpage
PLEASE ENABLE JAVASCRIPT!!
Feed
×
Spigot TEA
Custom Code
Main Page
My Spigot
My GitHub
My Web Projects
Source Code


Dear Epicore User,
Your verification code is {####}.
Click the following link to reset your password using the above verification code.
Reset passwordThis verification code will expire after 1 hour. If the code expires, click here for a new code to be emailed to you.
After you set your password, you can log in to the EpiCore platform and begin sending or receiving requests for information (RFIs) about possible outbreaks in your region.
We are very excited to work with you to change the landscape of outbreak detection and reporting! Lets find outbreaks faster together!
If you have any questions, please contact us at<EMAIL_ADDRESS>Sincerely,
The EpiCore Team
* If the RESET YOUR PASSWORD link does not work, please try one or a combination of the following:
1. Update your browser to the latest version.
2. Open a different browser than the one you used and copy/paste your personalized link:
3. Open an incognito / InPrivate tab on your browser and paste your personalized link
4. If you are using an iPhone or iPad update iOS to the latest version


Accessible, screen-reader friendly, flexible, CSS-only toggle switches with full keyboard access and mobile support, using standard form controls.
You can use the toggles alone,
or with Bootstrap or Foundation.
For "On/Off" states, use checkboxes.

<input id="view" type="checkbox" />

Wireless
On
Off

The toggle is fluid, you can set any width on it.

...
If you need different states that are more specific than "On/Off", or more than two of them, use radio buttons.
View

<input id="week" name="view" type="radio" checked>
Week
<input id="month" name="view" type="radio">
Month

The radio switches are also fluid, so you can create your own layout.
View

...
And add up to 5 items. You could create new rules for more items, but if you have more than 5 items, you shouldn't really use a switch.
View

...
There are 3 included themes with the toggle switches.
Based on Sort Switches / Toggles by Orman Clark.
It includes 2 additional color schemes, besides the default green: blue
and yellow
.
Based on Holo Light.
Loosely based on iOS toggles.
The toggle switches should work on all modern browsers, including mobile ones.
Browsers without support for mediaqueries, such as IE8 and bellow, get standard form elements.
The onclick=""
attribute is required for older iOS and Opera Mini support.
More about the development process on my website:


{% include 'membership/snippets/detail_card.html' with member_email=email member_addresses=addresses member_phone_numbers=phone_numbers %}
{% if member.committee_memberships.exists %}
{% regroup member.committee_memberships.all by year as assignments_by_year %}
{% blocktranslate count assignments=member.committee_memberships.count %}
Committee Served
{% plural %}
Committees Served
{% endblocktranslate %}
{% if member.family.children.count or member.family.adults.count > 1 %}
{% blocktranslate with short_name=member.get_short_name %}{{ short_name }}'s Family{% endblocktranslate %}
{% for partner in member.get_partners %}
{% include 'membership/snippets/detail_card.html' with member=partner %}
{% endfor %}
{% for child in member.family.children.all %}
{% include 'membership/snippets/detail_card.html' with member=child %}
{% endfor %}


relation Type
+
Save relation
new relation type
relation name
startLabel
endLabel
add relation type
cancel


File
Open
Save
Help
About
Filename:
File Description:
File Version:
Product Name:
Product Version:
Legal Copyright:
Private Build:
Company Name:
Original Filename:


The Texas Instruments® MSP432® Peripheral Driver Library is a set of drivers for accessing the peripherals found on the MSP430 family of microcontrollers. While they are not drivers in the pure operating system sense (that is, they do not have a common interface and do not connect into a global device driver infrastructure), they do provide a mechanism that makes it easy to use the device's peripherals.
The capabilities and organization of the drivers are governed by the following design goals:
Some consequences of these design goals are:
For many applications, the drivers can be used as is. But in some cases, the drivers will have to be enhanced or rewritten in order to meet the functionality, memory, or processing requirements of the application. If so, the existing driver can be used as a reference on how to operate the peripheral.
Each MSP430ware driverlib API takes in the base address of the corresponding peripheral as the first parameter. This base address is obtained from the msp430 device specific header files (or from the device datasheet). The example code for the various peripherals show how base address is used. When using CCS, the eclipse shortcut "Ctrl + Space" helps. Type __MSP430 and "Ctrl + Space", and the list of base addresses from the included device specific header files is listed.
The following tool chains are supported:


tag, or add the js file to your page at the very top to register service worker
// If you get an error about not being able to import, double check that you have type="module" on your tag
/*
This code uses the pwa-update web component https://github.com/pwa-builder/pwa-update to register your service worker,
tell the user when there is an update available and let the user know when your PWA is ready to use offline.
*/
import 'https://cdn.jsdelivr.net/npm/@pwabuilder/pwaupdate';
const el = document.createElement('pwa-update');
document.body.appendChild(el);


Class LambdaMapView<T>
Class designed to make implementing simple IMapViews more convenient, by providing the "get" functionality via a lambda function. For a version that implements ISettableMapView as opposed to IMapView, see LambdaSettableMapView.
Inheritance
Implements
Inherited Members
Namespace: GoRogue.MapViews
Assembly: GoRogue.dll
Syntax
public sealed class LambdaMapView<T> : IMapView<T>
Type Parameters
| Name | Description |
|---|---|
| T | The type of value being returned by the indexer functions. |
Remarks
Despite actual game map representations often consisting of complex types, exposing certain properties as primitive types (via IMapView implementations) for GoRogue algorithms to use is often fairly simple (simply exposing a property in the actual map class, or similar). If your map consists of Cells of some sort, where there exists an instance of some class/struct per location that contains information about that location, TranslationMap/LambdaTranslationMap provide convenient ways to implement simple IMapViews. In the case that no such single type exists, however, a more generic IMapView implementation is needed. This class takes the "get" function as a lambda to shorten the process of creating such an implementation.
Constructors
| Improve this Doc View SourceLambdaMapView(Func<Int32>, Func<Int32>, Func<Coord, T>)
Constructor. Takes functions that retrieve the width and height of the map, and the function used to retrieve the value for a location.
Declaration
public LambdaMapView(Func<int> widthGetter, Func<int> heightGetter, Func<Coord, T> valueGetter)
Parameters
| Type | Name | Description |
|---|---|---|
| System.Func<System.Int32> | widthGetter | A delegate/lambda that retrieves the width of the map being represented. |
| System.Func<System.Int32> | heightGetter | A delegate/lambda that retrieves the height of the map being represented. |
| System.Func<Coord, T> | valueGetter | A delegate/lambda that returns the value of type T associated with the location it is given. |
Remarks
This constructor is useful if the width and height of the map being represented may change -- one can provide lambdas that retrieve the width and height of the map being represented, and these lambdas will be called any time the Width and Height properties of this class are retrieved.
LambdaMapView(Int32, Int32, Func<Coord, T>)
Constructor. Takes the width and height of the map, and the function to use to retrieve the value for a location.
Declaration
public LambdaMapView(int width, int height, Func<Coord, T> valueGetter)
Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32 | width | The (constant) width of the map. |
| System.Int32 | height | The (constant) height of the map. |
| System.Func<Coord, T> | valueGetter | A delegate/lambda that returns the value of type T associated with the location it is given. |
Remarks
This constructor is useful if the width and height of the underlying representation do not change, so they can safely be passed in as constants.
Properties
| Improve this Doc View SourceHeight
The height of the map being represented.
Declaration
public int Height { get; }
Property Value
| Type | Description |
|---|---|
| System.Int32 |
Item[Coord]
Given a Coord, returns the "value" associated with that location, by calling the valueGetter lambda provided at construction.
Declaration
public T this[Coord pos] { get; }
Parameters
| Type | Name | Description |
|---|---|---|
| Coord | pos | Location to retrieve the value for. |
Property Value
| Type | Description |
|---|---|
| T | The "value" associated with the provided location, according to the valueGetter lambda provided at construction. |
Item[Int32]
Declaration
public T this[int index1D] { get; }
Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32 | index1D |
Property Value
| Type | Description |
|---|---|
| T |
Item[Int32, Int32]
Given an X and Y value, returns the "value" associated with that location, by calling the valueGetter lambda provided at construction.
Declaration
public T this[int x, int y] { get; }
Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32 | x | X-value of location. |
| System.Int32 | y | Y-value of location. |
Property Value
| Type | Description |
|---|---|
| T | The "value" associated with that location, according to the valueGetter lambda provided at construction. |
Width
The width of the map being represented.
Declaration
public int Width { get; }
Property Value
| Type | Description |
|---|---|
| System.Int32 |
Methods
| Improve this Doc View SourceToString()
Returns a string representation of the LambdaMapView.
Declaration
public override string ToString()
Returns
| Type | Description |
|---|---|
| System.String | A string representation of the LambdaMapView. |
Overrides
ToString(Func<T, String>)
Returns a string representation of the LambdaMapView, using the elementStringifier function given to determine what string represents which value.
Declaration
public string ToString(Func<T, string> elementStringifier)
Parameters
| Type | Name | Description |
|---|---|---|
| System.Func<T, System.String> | elementStringifier | Function determining the string representation of each element. |
Returns
| Type | Description |
|---|---|
| System.String | A string representation of the LambdaMapView. |
Remarks
This could be used, for example, on an LambdaMapView of boolean values, to output '#' for false values, and '.' for true values.
ToString(Int32, Func<T, String>)
Prints the values in the LambdaMapView, using the function specified to turn elements into strings, and using the "field length" specified. Each element of type T will have spaces added to cause it to take up exactly fieldSize characters, provided fieldSize is less than the length of the element's string represention. A positive-number right-aligns the text within the field, while a negative number left-aligns the text.
Declaration
public string ToString(int fieldSize, Func<T, string> elementStringifier = null)
Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32 | fieldSize | The size of the field to give each value. |
| System.Func<T, System.String> | elementStringifier | Function to use to convert each element to a string. Null defaults to the ToString function of type T. |
Returns
| Type | Description |
|---|---|
| System.String | A string representation of the LambdaMapView. |


| PostgreSQL 9.0.10 Documentation | ||||
|---|---|---|---|---|
| Prev | Up | Chapter 35. Extending SQL | Next |
A PostgreSQL operator definition can include several optional clauses that tell the system useful things about how the operator behaves. These clauses should be provided whenever appropriate, because they can make for considerable speedups in execution of queries that use the operator. But if you provide them, you must be sure that they are right! Incorrect use of an optimization clause can result in slow queries, subtly wrong output, or other Bad Things. You can always leave out an optimization clause if you are not sure about it; the only consequence is that queries might run slower than they need to.
Additional optimization clauses might be added in future versions of PostgreSQL. The ones described here are all the ones that release 9.0.10 understands.
The COMMUTATOR clause, if provided, names an operator that is the commutator of the operator being defined. We say that operator A is the commutator of operator B if (x A y) equals (y B x) for all possible input values x, y. Notice that B is also the commutator of A. For example, operators < and > for a particular data type are usually each others' commutators, and operator + is usually commutative with itself. But operator - is usually not commutative with anything.
The left operand type of a commutable operator is the same as the right operand type of its commutator, and vice versa. So the name of the commutator operator is all that PostgreSQL needs to be given to look up the commutator, and that's all that needs to be provided in the COMMUTATOR clause.
It's critical to provide commutator information for operators that will be used in indexes and join clauses, because this allows the query optimizer to "flip around" such a clause to the forms needed for different plan types. For example, consider a query with a WHERE clause like tab1.x = tab2.y, where tab1.x and tab2.y are of a user-defined type, and suppose that tab2.y is indexed. The optimizer cannot generate an index scan unless it can determine how to flip the clause around to tab2.y = tab1.x, because the index-scan machinery expects to see the indexed column on the left of the operator it is given. PostgreSQL will not simply assume that this is a valid transformation — the creator of the = operator must specify that it is valid, by marking the operator with commutator information.
When you are defining a self-commutative operator, you just do it. When you are defining a pair of commutative operators, things are a little trickier: how can the first one to be defined refer to the other one, which you haven't defined yet? There are two solutions to this problem:
One way is to omit the COMMUTATOR clause in the first operator that you define, and then provide one in the second operator's definition. Since PostgreSQL knows that commutative operators come in pairs, when it sees the second definition it will automatically go back and fill in the missing COMMUTATOR clause in the first definition.
The other, more straightforward way is just to include COMMUTATOR clauses in both definitions. When PostgreSQL processes the first definition and realizes that COMMUTATOR refers to a nonexistent operator, the system will make a dummy entry for that operator in the system catalog. This dummy entry will have valid data only for the operator name, left and right operand types, and result type, since that's all that PostgreSQL can deduce at this point. The first operator's catalog entry will link to this dummy entry. Later, when you define the second operator, the system updates the dummy entry with the additional information from the second definition. If you try to use the dummy operator before it's been filled in, you'll just get an error message.
The NEGATOR clause, if provided, names an operator that is the negator of the operator being defined. We say that operator A is the negator of operator B if both return Boolean results and (x A y) equals NOT (x B y) for all possible inputs x, y. Notice that B is also the negator of A. For example, < and >= are a negator pair for most data types. An operator can never validly be its own negator.
Unlike commutators, a pair of unary operators could validly be marked as each others' negators; that would mean (A x) equals NOT (B x) for all x, or the equivalent for right unary operators.
An operator's negator must have the same left and/or right operand types as the operator to be defined, so just as with COMMUTATOR, only the operator name need be given in the NEGATOR clause.
Providing a negator is very helpful to the query optimizer since it allows expressions like NOT (x = y) to be simplified into x <> y. This comes up more often than you might think, because NOT operations can be inserted as a consequence of other rearrangements.
Pairs of negator operators can be defined using the same methods explained above for commutator pairs.
The RESTRICT clause, if provided, names a restriction selectivity estimation function for the operator. (Note that this is a function name, not an operator name.) RESTRICT clauses only make sense for binary operators that return boolean. The idea behind a restriction selectivity estimator is to guess what fraction of the rows in a table will satisfy a WHERE-clause condition of the form:
column OP constant
for the current operator and a particular constant value. This assists the optimizer by giving it some idea of how many rows will be eliminated by WHERE clauses that have this form. (What happens if the constant is on the left, you might be wondering? Well, that's one of the things that COMMUTATOR is for...)
Writing new restriction selectivity estimation functions is far beyond the scope of this chapter, but fortunately you can usually just use one of the system's standard estimators for many of your own operators. These are the standard restriction estimators:
eqsel for = |
neqsel for <> |
scalarltsel for < or <= |
scalargtsel for > or >= |
You can frequently get away with using either eqsel
or neqsel
for
operators that have very high or very low selectivity, even if they
aren't really equality or inequality. For example, the
approximate-equality geometric operators use eqsel
on the assumption that
they'll usually only match a small fraction of the entries in a table.
You can use scalarltsel
and scalargtsel
for comparisons on data types that
have some sensible means of being converted into numeric scalars for
range comparisons. If possible, add the data type to those understood
by the function convert_to_scalar()
in src/backend/utils/adt/selfuncs.c.
(Eventually, this function should be replaced by per-data-type functions
identified through a column of the pg_type
system catalog; but that hasn't happened
yet.) If you do not do this, things will still work, but the optimizer's
estimates won't be as good as they could be.
There are additional selectivity estimation functions designed for geometric
operators in src/backend/utils/adt/geo_selfuncs.c: areasel
, positionsel
,
and contsel
. At this writing these are just stubs, but you might want
to use them (or even better, improve them) anyway.
The JOIN clause, if provided, names a join selectivity estimation function for the operator. (Note that this is a function name, not an operator name.) JOIN clauses only make sense for binary operators that return boolean. The idea behind a join selectivity estimator is to guess what fraction of the rows in a pair of tables will satisfy a WHERE-clause condition of the form:
table1.column1 OP table2.column2
for the current operator. As with the RESTRICT clause, this helps the optimizer very substantially by letting it figure out which of several possible join sequences is likely to take the least work.
As before, this chapter will make no attempt to explain how to write a join selectivity estimator function, but will just suggest that you use one of the standard estimators if one is applicable:
eqjoinsel for = |
neqjoinsel for <> |
scalarltjoinsel for < or <= |
scalargtjoinsel for > or >= |
areajoinsel for 2D area-based comparisons |
positionjoinsel for 2D position-based comparisons |
contjoinsel for 2D containment-based comparisons |
The HASHES clause, if present, tells the system that it is permissible to use the hash join method for a join based on this operator. HASHES only makes sense for a binary operator that returns boolean, and in practice the operator must represent equality for some data type or pair of data types.
The assumption underlying hash join is that the join operator can only return true for pairs of left and right values that hash to the same hash code. If two values get put in different hash buckets, the join will never compare them at all, implicitly assuming that the result of the join operator must be false. So it never makes sense to specify HASHES for operators that do not represent some form of equality. In most cases it is only practical to support hashing for operators that take the same data type on both sides. However, sometimes it is possible to design compatible hash functions for two or more data types; that is, functions that will generate the same hash codes for "equal" values, even though the values have different representations. For example, it's fairly simple to arrange this property when hashing integers of different widths.
To be marked HASHES, the join operator must appear in a hash index operator family. This is not enforced when you create the operator, since of course the referencing operator family couldn't exist yet. But attempts to use the operator in hash joins will fail at run time if no such operator family exists. The system needs the operator family to find the data-type-specific hash function(s) for the operator's input data type(s). Of course, you must also create suitable hash functions before you can create the operator family.
Care should be exercised when preparing a hash function, because there
are machine-dependent ways in which it might fail to do the right thing.
For example, if your data type is a structure in which there might be
uninteresting pad bits, you cannot simply pass the whole structure to
hash_any
. (Unless you write your other operators and
functions to ensure that the unused bits are always zero, which is the
recommended strategy.)
Another example is that on machines that meet the IEEE
floating-point standard, negative zero and positive zero are different
values (different bit patterns) but they are defined to compare equal.
If a float value might contain negative zero then extra steps are needed
to ensure it generates the same hash value as positive zero.
A hash-joinable operator must have a commutator (itself if the two operand data types are the same, or a related equality operator if they are different) that appears in the same operator family. If this is not the case, planner errors might occur when the operator is used. Also, it is a good idea (but not strictly required) for a hash operator family that supports multiple data types to provide equality operators for every combination of the data types; this allows better optimization.
Note: The function underlying a hash-joinable operator must be marked immutable or stable. If it is volatile, the system will never attempt to use the operator for a hash join.
Note: If a hash-joinable operator has an underlying function that is marked strict, the function must also be complete: that is, it should return true or false, never null, for any two nonnull inputs. If this rule is not followed, hash-optimization of IN operations might generate wrong results. (Specifically, IN might return false where the correct answer according to the standard would be null; or it might yield an error complaining that it wasn't prepared for a null result.)
The MERGES clause, if present, tells the system that it is permissible to use the merge-join method for a join based on this operator. MERGES only makes sense for a binary operator that returns boolean, and in practice the operator must represent equality for some data type or pair of data types.
Merge join is based on the idea of sorting the left- and right-hand tables into order and then scanning them in parallel. So, both data types must be capable of being fully ordered, and the join operator must be one that can only succeed for pairs of values that fall at the "same place" in the sort order. In practice this means that the join operator must behave like equality. But it is possible to merge-join two distinct data types so long as they are logically compatible. For example, the smallint-versus-integer equality operator is merge-joinable. We only need sorting operators that will bring both data types into a logically compatible sequence.
To be marked MERGES, the join operator must appear as an equality member of a btree index operator family. This is not enforced when you create the operator, since of course the referencing operator family couldn't exist yet. But the operator will not actually be used for merge joins unless a matching operator family can be found. The MERGES flag thus acts as a hint to the planner that it's worth looking for a matching operator family.
A merge-joinable operator must have a commutator (itself if the two operand data types are the same, or a related equality operator if they are different) that appears in the same operator family. If this is not the case, planner errors might occur when the operator is used. Also, it is a good idea (but not strictly required) for a btree operator family that supports multiple data types to provide equality operators for every combination of the data types; this allows better optimization.
Note: The function underlying a merge-joinable operator must be marked immutable or stable. If it is volatile, the system will never attempt to use the operator for a merge join.


Class: Concurrent::LockFreeQueue
- Inherits:
-
Synchronization::Object
- Object
- Synchronization::Object
- Concurrent::LockFreeQueue
- Defined in:
- lib/concurrent/edge/lock_free_queue.rb
Defined Under Namespace
Classes: Node
Instance Method Summary (collapse)
-
- (LockFreeQueue) initialize
constructor
A new instance of LockFreeQueue.
- - (undocumented) pop
- - (undocumented) push(item)
-
- (undocumented) size
approximate.
Constructor Details
- (LockFreeQueue) initialize
Returns a new instance of LockFreeQueue
24 25 26 27 28 29 30 |
# File 'lib/concurrent/edge/lock_free_queue.rb', line 24 def initialize super() dummy_node = Node.new(:dummy, nil) self.head = dummy_node self.tail = dummy_node end |
Instance Method Details
- (undocumented) pop
62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 |
# File 'lib/concurrent/edge/lock_free_queue.rb', line 62 def pop # retry until some value can be returned while true # the value in @head is just a dummy node that always sits in that position, # the real 'head' is in its successor current_dummy_node = head current_tail_node = tail current_head_node = current_dummy_node.successor # if our local head is still consistent with the head node, continue # otherwise, start over if current_dummy_node == head # if either the queue is empty, or falling behind if current_dummy_node == current_tail_node # if there's nothing after the 'dummy' head node if current_head_node.nil? # just return nil return nil else # here the head element succeeding head is not nil, but the head and tail are equal # so tail is falling behind, update it, then start over compare_and_set_tail(current_tail_node, current_head_node) end # the queue isn't empty # if we can set the dummy head to the 'real' head, we're free to return the value in that real head, success elsif compare_and_set_head(current_dummy_node, current_head_node) # grab the item from the popped node item = current_head_node.item # return it, success! return item end end end end |
- (undocumented) push(item)
32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 |
# File 'lib/concurrent/edge/lock_free_queue.rb', line 32 def push(item) # allocate a new node with the item embedded new_node = Node.new(item, nil) # keep trying until the operation succeeds while true current_tail_node = tail current_tail_successor = current_tail_node.successor # if our stored tail is still the current tail if current_tail_node == tail # if that tail was really the last node if current_tail_successor.nil? # if we can update the previous successor of tail to point to this new node if current_tail_node.compare_and_set_successor(nil, new_node) # then update tail to point to this node as well compare_and_set_tail(current_tail_node, new_node) # and return return true # else, start the loop over end else # in this case, the tail ref we had wasn't the real tail # so we try to set its successor as the real tail, then start the loop again compare_and_set_tail(current_tail_node, current_tail_successor) end end end end |
- (undocumented) size
approximate
101 102 103 104 105 106 107 108 109 110 111 112 113 114 |
# File 'lib/concurrent/edge/lock_free_queue.rb', line 101 def size successor = head.successor count = 0 while true break if successor.nil? current_node = successor successor = current_node.successor count += 1 end count end |


Surfing is a surface water sport in which the wave rider, referred to as a surfer, rides on the forward or deep face of a moving wave, which is usually carrying the surfer towards the shore. Waves suitable for surfing are primarily found in the ocean, but can also be found in lakes or in rivers in the form of a standing wave or tidal bore. However, surfers can also utilize artificial waves such as those from boat wakes and the waves created in artificial wave pools.
The term surfing refers to the act of riding a wave, regardless of whether the wave is ridden with a board or without a board, and regardless of the stance used (goofy or regular stance). The native peoples of the Pacific, for instance, surfed waves on alaia, paipo, and other such craft, and did so on their belly and knees. The modern-day definition of surfing, however, most often refers to a surfer riding a wave standing up on a surfboard; this is also referred to as stand-up surfing.
Kelly Slater


Danielle Roth
BFA in Visual Communications Design
email
368 website
Favorite Foods
PIZZA
Ice Cream
Coffee


class Net::HTTPResponse
HTTP response class.
This class wraps together the response header and the response body (the entity requested).
It mixes in the HTTPHeader module, which provides access to response header values both via hash-like methods and via individual readers.
Note that each possible HTTP response code defines its own HTTPResponse subclass. These are listed below.
All classes are defined under the Net module. Indentation indicates inheritance. For a list of the classes see Net::HTTP.
Constants
- CODE_CLASS_TO_OBJ
- CODE_TO_OBJ
Attributes
The HTTP result code string. For example, '302'. You can also determine the response type by examining which response subclass the response object is an instance of.
Set to true automatically when the request did not contain an Accept-Encoding header from the user.
The HTTP version supported by the server.
The HTTP result message sent by the server. For example, 'Not Found'.
The HTTP result message sent by the server. For example, 'Not Found'.
Public Class Methods
true if the response has a body.
# File lib/net/http/response.rb, line 19 def body_permitted? self::HAS_BODY end
Private Class Methods
# File lib/net/http/response.rb, line 51 def each_response_header(sock) key = value = nil while true line = sock.readuntil("\n", true).sub(/\s+\z/, '') break if line.empty? if line[0] == ?\s or line[0] == ?\t and value value << ' ' unless value.empty? value << line.strip else yield key, value if key key, value = line.strip.split(/\s*:\s*/, 2) raise Net::HTTPBadResponse, 'wrong header line format' if value.nil? end end yield key, value if key end
# File lib/net/http/response.rb, line 38 def read_status_line(sock) str = sock.readline m = /\AHTTP(?:\/(\d+\.\d+))?\s+(\d\d\d)(?:\s+(.*))?\z/in.match(str) or raise Net::HTTPBadResponse, "wrong status line: #{str.dump}" m.captures end
# File lib/net/http/response.rb, line 45 def response_class(code) CODE_TO_OBJ[code] or CODE_CLASS_TO_OBJ[code[0,1]] or Net::HTTPUnknownResponse end
Public Instance Methods
Returns the full entity body.
Calling this method a second or subsequent time will return the string already read.
http.request_get('/index.html') {|res| puts res.body } http.request_get('/index.html') {|res| p res.body.object_id # 538149362 p res.body.object_id # 538149362 }
# File lib/net/http/response.rb, line 227 def body read_body() end
Because it may be necessary to modify the body, Eg, decompression this method facilitates that.
# File lib/net/http/response.rb, line 233 def body=(value) @body = value end
# File lib/net/http/response.rb, line 106 def inspect "#<#{self.class} #{@code} #{@message} readbody=#{@read}>" end
Gets the entity body returned by the remote HTTP server.
If a block is given, the body is passed to the block, and the body is provided in fragments, as it is read in from the socket.
Calling this method a second or subsequent time for the same HTTPResponse object will return the value already read.
http.request_get('/index.html') {|res| puts res.read_body } http.request_get('/index.html') {|res| p res.read_body.object_id # 538149362 p res.read_body.object_id # 538149362 } # using iterator http.request_get('/index.html') {|res| res.read_body do |segment| print segment end }
# File lib/net/http/response.rb, line 195 def read_body(dest = nil, &block) if @read raise IOError, "#{self.class}\#read_body called twice" if dest or block return @body end to = procdest(dest, block) stream_check if @body_exist read_body_0 to @body = to else @body = nil end @read = true @body end
Raises an HTTP error if the response is not 2xx (success).
# File lib/net/http/response.rb, line 129 def value error! unless self.kind_of?(Net::HTTPSuccess) end
Private Instance Methods
# File lib/net/http/response.rb, line 335 def procdest(dest, block) raise ArgumentError, 'both arg and block given for HTTP method' if dest and block if block Net::ReadAdapter.new(block) else dest || '' end end
# File lib/net/http/response.rb, line 281 def read_body_0(dest) inflater do |inflate_body_io| if chunked? read_chunked dest, inflate_body_io return end @socket = inflate_body_io clen = content_length() if clen @socket.read clen, dest, true # ignore EOF return end clen = range_length() if clen @socket.read clen, dest return end @socket.read_all dest end end
# File lib/net/http/response.rb, line 331 def stream_check raise IOError, 'attempt to read body out of block' if @socket.closed? end