*** User 2017-05-05 21:48:03.360 ***
21:48:03.360 [info] Disabling blocking sync...
*** User 2017-05-05 21:48:03.365 ***
21:48:03.365 [info] Configured peer_service_manager partisan_default_peer_service_manager on node 'node-1@MacBook-Pro-de-Anne-France'
*** User 2017-05-05 21:48:04.852 ***
21:48:04.852 [info] Enabling membership...
*** User 2017-05-05 21:48:04.853 ***
21:48:04.853 [info] Disabling blocking sync...
*** User 2017-05-05 21:48:04.858 ***
21:48:04.858 [info] Configured peer_service_manager partisan_default_peer_service_manager on node 'node-2@MacBook-Pro-de-Anne-France'
*** User 2017-05-05 21:48:06.338 ***
21:48:06.338 [info] Enabling membership...
*** User 2017-05-05 21:48:06.340 ***
21:48:06.340 [info] Disabling blocking sync...
*** User 2017-05-05 21:48:06.345 ***
21:48:06.345 [info] Configured peer_service_manager partisan_default_peer_service_manager on node 'node-3@MacBook-Pro-de-Anne-France'
*** User 2017-05-05 21:48:06.601 ***
Joining node: 'node-3@MacBook-Pro-de-Anne-France' to 'runner@MacBook-Pro-de-Anne-France' at port 50580
*** User 2017-05-05 21:48:06.601 ***
Joining issued: 'node-3@MacBook-Pro-de-Anne-France' to 'runner@MacBook-Pro-de-Anne-France' at port 50580
*** User 2017-05-05 21:48:06.601 ***
Joining node: 'node-2@MacBook-Pro-de-Anne-France' to 'runner@MacBook-Pro-de-Anne-France' at port 50565
*** User 2017-05-05 21:48:06.602 ***
Joining issued: 'node-2@MacBook-Pro-de-Anne-France' to 'runner@MacBook-Pro-de-Anne-France' at port 50565
*** User 2017-05-05 21:48:06.602 ***
Joining node: 'node-1@MacBook-Pro-de-Anne-France' to 'runner@MacBook-Pro-de-Anne-France' at port 50551
*** User 2017-05-05 21:48:06.603 ***
Joining issued: 'node-1@MacBook-Pro-de-Anne-France' to 'runner@MacBook-Pro-de-Anne-France' at port 50551
*** User 2017-05-05 21:48:06.664 ***
Waiting for join to complete with manager: partisan_default_peer_service_manager
*** User 2017-05-05 21:48:06.665 ***
Finished.
*** CT 2017-05-05 21:48:06.665 *** COVER INFO
Adding nodes to cover test: ['runner@MacBook-Pro-de-Anne-France']
*** CT 2017-05-05 21:48:06.674 *** COVER INFO
Successfully added nodes to cover test: []
*** User 2017-05-05 21:48:06.674 ***
Case finished: uncontracted_latency_test
*** User 2017-05-05 21:48:13.719 ***
21:48:13.719 [info] Application lasp exited with reason: stopped
*** User 2017-05-05 21:48:13.720 ***
21:48:13.720 [info] Application partisan exited with reason: stopped
=== Ended at 2017-05-05 21:48:13
=== successfully completed test case
=== Returned value: ok
Test run history
| Top level test index


Catchphrases
You can add catchphrases individually in the text box by ending each word with a carriage return. You can also upload a text file of catchphrases separated by new lines. The uploaded catchphrases can be seen listed and can be cleared below.


|
ESP32 HTTPS Server
|
Public Member Functions | |
| HTTPMultipartBodyParser (HTTPRequest *req) | |
| virtual bool | nextField () |
| virtual std::string | getFieldName () |
| virtual std::string | getFieldFilename () |
| virtual std::string | getFieldMimeType () |
| virtual bool | endOfField () |
| virtual size_t | read (byte *buffer, size_t bufferSize) |
| Public Member Functions inherited from httpsserver::HTTPBodyParser | |
| HTTPBodyParser (HTTPRequest *req) | |
Additional Inherited Members | |
| Public Attributes inherited from httpsserver::HTTPBodyParser | |
| const size_t | unknownLength = 0x7ffffffe |
| Protected Attributes inherited from httpsserver::HTTPBodyParser | |
| HTTPRequest * | _request |
|
virtual |
Returns true when all field data has been read
Implements httpsserver::HTTPBodyParser.
|
virtual |
Returns the filename of the current field or an empty string
Implements httpsserver::HTTPBodyParser.
|
virtual |
Returns the mime type of the current field.
Note: This value is set by the client. It can be altered maliciously. Do NOT rely on it for anything that affects the security of your device or other clients connected to it!
Not every BodyParser might provide this value, usually it's set to something like text/plain then
Implements httpsserver::HTTPBodyParser.
|
virtual |
Returns the name of the current field
Implements httpsserver::HTTPBodyParser.
|
virtual |
Proceeds to the next field of the body
If a field has not been read completely, the remaining content is discarded.
Returns true iff proceeding to the next field succeeded (ie there was a next field)
Implements httpsserver::HTTPBodyParser.
|
virtual |
Reads a maximum of bufferSize bytes into buffer and returns the actual amount of bytes that have been read
Implements httpsserver::HTTPBodyParser.


Contains the Panel class and all of its subviews. This package's subpackages are: the achievements, the chat, the creation, the settings, and the display.
The Panel is the central class: it provides a wrapper for a panel structure that displays subpanels and views. Those views can be added using one-line in Panel. To use this package, you must primarily interact with the Panel class.
If you wish to provide an extensive modification, please make an appropriate subpackage, following the guidelines set by previous coders.


Innovative teacher training introduces a new set of demanding challenges and issues.
Teaching has become a very complex and demanding process.
Teachers with little exposure to digital media and with little preparation with digital media may face
difficulties in dealing with the complexity of classroom teacing.
These new teachers may often find the demands of the classroom too challenging and quckily become
discourages or adopt a simplisitc view of teaching where 'Tricks & Trade' serve as a
substitute for thoughtful process.
By using Spectrum Education tool, it provides extensive training of teachers which will help them in understanding digital Media and know better strategies for successful classroom management. The teachers will be well versed with teaching skills,instructional strategies,curricula and assessment practices. Our goal is to reinforce best practices for classroom management and to create an online learning environment to support pre-service and in-dervice teachers.


A KNIGHT'S TALE * *
2001 – USA Director: Brian Helgeland Starring: Heath Ledger, Shannyn Sossamon, Mark Addy, Rufus Sewell, Alan Tudyk, Paul Bettany
Reviewed by Frankie Paiva
Just avoid it. It's that simple. `A Knight's Tale' is a new medieval jousting comedy/drama that molds itself into whatever the story requires, with little regard for plausibility, time, reason, or feeling. The movie is like a young child that's just discovered clay. It is juvenile, and severely lacking in form, content, and consistency.
That said, Heath Ledger is awfully good as William Thatcher, a squire who takes over his dead master's position in of-noble-blood-only jousting matches across Europe. William has trained since childhood, and has the skills and sheer gut for competition. He just needs some practice. As he rises to prominence, he gains a rival (Rufus Sewell), and goes after the heart of a fair maiden (Shannyn Sossamon). Also showing up are two annoying actors, Mark Addy and Alan Tudyk as `humorous' sidekicks.
The film opens with a crowd of bloodthirsty jousting patrons hungrily awaiting carnage, and simultaneously clapping and singing along with Queen's `We Will Rock You'. The modern rock hit fun continues throughout, with Thin Lizzy, David Bowie, and Heart eventually getting in on the action. The scoring gives the film a modern effect it doesn't need. Just when writer/director Brian Helgeland manages to get his production back on track, he derails with another song. Let's give them Eric Clapton and sword fighting! No! Let's do Robbie Williams and medieval slaughter!
It doesn't help that jousting really isn't that exciting, and Helgeland doesn't attempt to make it so. He does, at least, explain the rules of the game, which are helpful to the non-history-oriented, but to this 21st-century eye, the game just comes off as silly. Thousands of years from now, I'm sure the creatures living on Earth will think the same thing of beach volleyball.
After supporting roles in two other Columbia productions, `10 Things I Hate About You' and `The Patriot', Heath Ledger gets his first starring role. He does his best, and brings a mix of boyish charm and ruggedness often associated with the likes of Matt Damon or fellow countryman Russell Crowe. The other performances are passable, never quite meeting satisfactory.
`A Knight's Tale' tries desperately to be a younger, hipper version of `Gladiator', and it fails. It doesn't matter that the story veers nowhere, and the supporting actors need medical help, but that Helgeland has no, even vague, point to this whole mess. Add that the film is almost never entertaining or funny, and its quality, even as airplane entertainment, becomes highly questionable.
But what about Heath Ledger, the smiling, good-looking Australian star? Well, he has better things ahead of him, hopefully. He's talented, and gives this summer movie masses of deceiving credibility. Better luck next time.
Read more reviews at www.moviepie.com
========== X-RAMR-ID: 29350 X-Language: en X-RT-ReviewID: 246383 X-RT-TitleID: 1107871 X-RT-SourceID: 876 X-RT-AuthorID: 1334 X-RT-RatingText: 2/4
The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


Toggle navigation
SigCloud
About
Management
Service Management
Node Management
Contact
Login
Monitoring
Clusters
Cluster1
Cluster2
All Clusters
Symbols
OK
WARNING
DANGER
{{cluster.cluster_name}}
Machine-Service-Specs Monitoring
Pick a machine to monitor
{{machine.machine_name}}
All Machines
{{machine.machine_name}}
{{service.service_name}}
Service-Specs Monitoring
{{service.service_name}}
Current State :
Last Hard State :
Last Check
: {{service.service_specs.last_check*1000 | date:'MM/dd/yyyy'}}


Suspect gets N500,000 bail over N9,000 fraud - Premium Times Nigeria
by Agency ReportA Tinubu Magistrates’ Court in Lagos State on Thursday granted N500,000 bail to a 32-year-old man, Ogbonna Iteh, who allegedly possessed fake 200 dollars and defrauded a woman of N9,000.
The Magistrate, T.A. Anjorin-Ajose, also ordered the defendant to produce two sureties as a condition for the bail.
He said that one of the sureties must be a blood relation of the defendant and the other, a civil servant.
The News Agency of Nigeria (NAN) reports that Mr Iteh, who resides at Aboki Estate, Ikate, Elegunshi, Eti-Osa, Lagos State, is facing a three-count charge of conspiracy, fraud and possession of fake currency.
He, however, pleaded not guilty to the offences.
The prosecutor, Ajaga Agboko, told the court that the defendant and one other person at large conspired to defraud one Faith Samuel of N9000.
He said that Mr Iteh committed the offences on Nov. 13, at 8:00a.m., at Abijo Lekki, Ibeju-Lekki, Lagos State.
Mr Agboko said the defendant also had in his possession fake 200 dollars.
“Iteh’s accomplice (who drove their vehicle), gave a ride to Samuel, who was taking her children to school.
“In the vehicle, Iteh said that he just returned from abroad and God sent him to help the complainant; he gave her 200 dollars and told her to bring any amount she has in naira.
“Samuel told them she had only N9,000 in her account; the duo told her to go and withdraw it; they followed her to a bank; she withdrew the money and gave it to them.
“The duo left; the complainant went into the bank to change the 200 dollars but was told that it was fake.
“Samuel traced them back to where they picked her and saw only the defendant where he was trying to defraud another woman, she raised an alarm and he was caught,” the prosecutor alleged.
He said the offences contravened Sections 314, 329 and 411 of the Criminal Law of Lagos State, 2015.
Anjorin-Ajose adjourned the case until Dec. 5 for substantive hearing. (NAN)


UTF-8 string routines
- About UTF-8 string routines
- UTF-8 string types
- Creating and destroying strings
- Predefined strings
- Creating strings by referencing other data
- Sizes and offsets
- Getting code points
- Inserting into strings
- Appending to strings
- Removing parts of strings
- Assigning one string to another
- Replacing parts of string
- Searching
- Comparing
- UTF-16 conversion
- Low-level UTF-8 routines
- Low-level UTF-16 routines
These functions are declared in the main Allegro header file:
#include <allegro5/allegro.h>
About UTF-8 string routines
Some parts of the Allegro API, such as the font rountines, expect Unicode strings encoded in UTF-8. These basic routines are provided to help you work with UTF-8 strings, however it does not mean you need to use them. You should consider another library (e.g. ICU) if you require more functionality.
You should also see elsewhere for a proper introduction to Unicode. Briefly, Unicode is a standard consisting of a large character set of over 100,000 characters, and rules, such as how to sort strings. A code point is the integer value of a character, but not all code points are characters, as some code points have other uses. Clearly it is impossible represent each code point with a 8-bit byte or even a 16-bit integer, so there exist different Unicode Transformation Formats, most importantly UTF-8 and UTF-16.
UTF-8 has many nice properties, but the main advantages are that it is backwards compatible with C strings, and ASCII characters (code points <= 127) are encoded in UTF-8 exactly as they would be in ASCII.
Here is a diagram of the representation of the word "ål", with a NUL terminator, in both UTF-8 and UTF-16.
---------------- ---------------- --------------
String å l NUL
---------------- ---------------- --------------
Code points U+00E5 (229) U+006C (108) U+0000 (0)
---------------- ---------------- --------------
UTF-8 encoding 0xC3, 0xA5 0x6C 0x00
---------------- ---------------- --------------
UTF-16LE encoding 0xE5, 0x00 0x6C, 0x00 0x00, 0x00
---------------- ---------------- --------------
You can see the aforementioned properties of UTF-8. The first character U+00E5 (å) has a value greater than 127, so its encoding takes more than a single byte; it requires two bytes. U+006C (l) and U+0000 (NUL) both exist in the ASCII range, i.e. less than 127, so take exactly one byte each, just as in a pure ASCII string. A zero byte never appears except to represent the NUL character, so many functions which expect C-style strings will work with UTF-8 strings without modification.
On the other hand, UTF-16 represents each code code by either two or four bytes, so functions expecting C-style strings will not work at all.
In the following functions, be careful whether a function takes byte offsets or code-point indices. In general, all position parameters are in byte offsets, not code point indices. This may be surprising, but if you think about, is required for good performance. It also means many functions will work even if they do not contain UTF-8, so you may actually store arbitrary data in the strings.
For actual text processing, where you want to specify positions with code point indices, you should use al_ustr_offset to find the byte position of a code point.
UTF-8 string types
ALLEGRO_USTR
typedef struct _al_tagbstring ALLEGRO_USTR;
An opaque type representing a string. ALLEGRO_USTRs normally contain UTF-8 encoded strings, but they may be used to hold any byte sequences, including NULs.
ALLEGRO_USTR_INFO
typedef struct _al_tagbstring ALLEGRO_USTR_INFO;
A type that holds additional information for an ALLEGRO_USTR that references an external memory buffer. See al_ref_cstr, al_ref_buffer and al_ref_ustr.
Creating and destroying strings
al_ustr_new
ALLEGRO_USTR *al_ustr_new(const char *s)
Create a new string containing a copy of the C-style string s
. The string must eventually be freed with al_ustr_free.
See also: al_ustr_new_from_buffer, al_ustr_newf, al_ustr_dup, al_ustr_new_from_utf16
al_ustr_new_from_buffer
ALLEGRO_USTR *al_ustr_new_from_buffer(const char *s, size_t size)
Create a new string containing a copy of the buffer pointed to by s
of the given size. The string must eventually be freed with al_ustr_free.
See also: al_ustr_new
al_ustr_newf
ALLEGRO_USTR *al_ustr_newf(const char *fmt, ...)
Create a new string using a printf-style format string.
Notes:
The "%s" specifier takes C string arguments, not ALLEGRO_USTRs. Therefore to pass an ALLEGRO_USTR as a parameter you must use al_cstr, and it must be NUL terminated. If the string contains an embedded NUL byte everything from that byte onwards will be ignored.
The "%c" specifier outputs a single byte, not the UTF-8 encoding of a code point. Therefore it's only usable for ASCII characters (value <= 127) or if you really mean to output byte values from 128--255. To insert the UTF-8 encoding of a code point, encode it into a memory buffer using al_utf8_encode then use the "%s" specifier. Remember to NUL terminate the buffer.
See also: al_ustr_new, al_ustr_appendf
al_ustr_free
void al_ustr_free(ALLEGRO_USTR *us)
Free a previously allocated string. Does nothing if the argument is NULL.
al_cstr
const char *al_cstr(const ALLEGRO_USTR *us)
Get a char *
pointer to the data in a string. This pointer will only be valid while the underlying string is not modified and not destroyed. The pointer may be passed to functions expecting C-style strings, with the following caveats:
ALLEGRO_USTRs are allowed to contain embedded NUL ('') bytes. That means
al_ustr_size(u)
andstrlen(al_cstr(u))
may not agree.An ALLEGRO_USTR may be created in such a way that it is not NUL terminated. A string which is dynamically allocated will always be NUL terminated, but a string which references the middle of another string or region of memory will not be NUL terminated.
If the ALLEGRO_USTR references another string, the returned C string will point into the referenced string. Again, no NUL terminator will be added to the referenced string.
See also: al_ustr_to_buffer, al_cstr_dup
al_ustr_to_buffer
void al_ustr_to_buffer(const ALLEGRO_USTR *us, char *buffer, int size)
Write the contents of the string into a pre-allocated buffer of the given size in bytes. The result will always be 0-terminated, so a maximum of size - 1
bytes will be copied.
See also: al_cstr, al_cstr_dup
al_cstr_dup
char *al_cstr_dup(const ALLEGRO_USTR *us)
Create a NUL ('') terminated copy of the string. Any embedded NUL bytes will still be presented in the returned string. The new string must eventually be freed with al_free. If an error occurs NULL is returned.
See also: al_cstr, al_ustr_to_buffer
al_ustr_dup
ALLEGRO_USTR *al_ustr_dup(const ALLEGRO_USTR *us)
Return a duplicate copy of a string. The new string will need to be freed with al_ustr_free.
See also: al_ustr_dup_substr
al_ustr_dup_substr
ALLEGRO_USTR *al_ustr_dup_substr(const ALLEGRO_USTR *us, int start_pos,
int end_pos)
Return a new copy of a string, containing its contents in the byte interval [start_pos, end_pos). The new string will be NUL terminated and will need to be freed with al_ustr_free.
If you need a range of code-points instead of bytes, use al_ustr_offset to find the byte offsets.
See also: al_ustr_dup
Predefined strings
al_ustr_empty_string
const ALLEGRO_USTR *al_ustr_empty_string(void)
Return a pointer to a static empty string. The string is read only and must not be freed.
Creating strings by referencing other data
al_ref_cstr
const ALLEGRO_USTR *al_ref_cstr(ALLEGRO_USTR_INFO *info, const char *s)
Create a string that references the storage of a C-style string. The information about the string (e.g. its size) is stored in the structure pointed to by the info
parameter. The string will not have any other storage allocated of its own, so if you allocate the info
structure on the stack then no explicit "free" operation is required.
The string is valid until the underlying C string disappears.
Example:
ALLEGRO_USTR_INFO info;
ALLEGRO_USTR *us = al_ref_cstr(&info, "my string");
See also: al_ref_buffer, al_ref_ustr
al_ref_buffer
const ALLEGRO_USTR *al_ref_buffer(ALLEGRO_USTR_INFO *info, const char *s, size_t size)
Like al_ref_cstr but the size of the string data is passed in as a parameter. Hence you can use it to reference only part of a string or an arbitrary region of memory.
The string is valid while the underlying C string is valid.
See also: al_ref_cstr, al_ref_ustr
al_ref_ustr
const ALLEGRO_USTR *al_ref_ustr(ALLEGRO_USTR_INFO *info, const ALLEGRO_USTR *us,
int start_pos, int end_pos)
Create a read-only string that references the storage of another string. The information about the string (e.g. its size) is stored in the structure pointed to by the info
parameter. The string will not have any other storage allocated of its own, so if you allocate the info
structure on the stack then no explicit "free" operation is required.
The referenced interval is [start_pos, end_pos).
The string is valid until the underlying string is modified or destroyed.
If you need a range of code-points instead of bytes, use al_ustr_offset to find the byte offsets.
See also: al_ref_cstr, al_ref_buffer
Sizes and offsets
al_ustr_size
size_t al_ustr_size(const ALLEGRO_USTR *us)
Return the size of the string in bytes. This is equal to the number of code points in the string if the string is empty or contains only 7-bit ASCII characters.
See also: al_ustr_length
al_ustr_length
size_t al_ustr_length(const ALLEGRO_USTR *us)
Return the number of code points in the string.
See also: al_ustr_size, al_ustr_offset
al_ustr_offset
int al_ustr_offset(const ALLEGRO_USTR *us, int index)
Return the offset (in bytes from the start of the string) of the code point at the specified index in the string. A zero index parameter will return the first character of the string. If index is negative, it counts backward from the end of the string, so an index of -1 will return an offset to the last code point.
If the index is past the end of the string, returns the offset of the end of the string.
See also: al_ustr_length
al_ustr_next
bool al_ustr_next(const ALLEGRO_USTR *us, int *pos)
Find the byte offset of the next code point in string, beginning at *pos
. *pos
does not have to be at the beginning of a code point. Returns true on success, then value pointed to by pos
will be updated to the found offset. Otherwise returns false if *pos
was already at the end of the string, then *pos
is unmodified.
This function just looks for an appropriate byte; it doesn't check if found offset is the beginning of a valid code point. If you are working with possibly invalid UTF-8 strings then it could skip over some invalid bytes.
See also: al_ustr_prev
al_ustr_prev
bool al_ustr_prev(const ALLEGRO_USTR *us, int *pos)
Find the byte offset of the previous code point in string, before *pos
. *pos
does not have to be at the beginning of a code point. Returns true on success, then value pointed to by pos
will be updated to the found offset. Otherwise returns false if *pos
was already at the end of the string, then *pos
is unmodified.
This function just looks for an appropriate byte; it doesn't check if found offset is the beginning of a valid code point. If you are working with possibly invalid UTF-8 strings then it could skip over some invalid bytes.
See also: al_ustr_next
Getting code points
al_ustr_get
int32_t al_ustr_get(const ALLEGRO_USTR *ub, int pos)
Return the code point in us
beginning at pos
.
On success returns the code point value. If pos
was out of bounds (e.g. past the end of the string), return -1. On an error, such as an invalid byte sequence, return -2.
See also: al_ustr_get_next, al_ustr_prev_get
al_ustr_get_next
int32_t al_ustr_get_next(const ALLEGRO_USTR *us, int *pos)
Find the code point in us
beginning at *pos
, then advance to the next code point.
On success return the code point value. If pos
was out of bounds (e.g. past the end of the string), return -1. On an error, such as an invalid byte sequence, return -2. As with al_ustr_next, invalid byte sequences may be skipped while advancing.
See also: al_ustr_get, al_ustr_prev_get
al_ustr_prev_get
int32_t al_ustr_prev_get(const ALLEGRO_USTR *us, int *pos)
Find the beginning of a code point before *pos
, then return it. Note this performs a pre-increment.
On success returns the code point value. If pos
was out of bounds (e.g. past the end of the string), return -1. On an error, such as an invalid byte sequence, return -2. As with al_ustr_prev, invalid byte sequences may be skipped while advancing.
See also: al_ustr_get_next
Inserting into strings
al_ustr_insert
bool al_ustr_insert(ALLEGRO_USTR *us1, int pos, const ALLEGRO_USTR *us2)
Insert us2
into us1
beginning at pos
. pos
cannot be less than 0. If pos
is past the end of us1
then the space between the end of the string and pos
will be padded with NUL ('') bytes. pos
is specified in bytes.
Use al_ustr_offset to find the byte offset for a code-points offset
Returns true on success, false on error.
See also: al_ustr_insert_cstr, al_ustr_insert_chr, al_ustr_append
al_ustr_insert_cstr
bool al_ustr_insert_cstr(ALLEGRO_USTR *us, int pos, const char *s)
Like al_ustr_insert but inserts a C-style string.
See also: al_ustr_insert, al_ustr_insert_chr
al_ustr_insert_chr
size_t al_ustr_insert_chr(ALLEGRO_USTR *us, int pos, int32_t c)
Insert a code point into us
beginning at byte offset pos
. pos
cannot be less than 0. If pos
is past the end of us
then the space between the end of the string and pos
will be padded with NUL ('') bytes.
Returns the number of bytes inserted, or 0 on error.
See also: al_ustr_insert, al_ustr_insert_cstr
Appending to strings
al_ustr_append
bool al_ustr_append(ALLEGRO_USTR *us1, const ALLEGRO_USTR *us2)
Append us2
to the end of us1
.
Returns true on success, false on error.
This function can be used to append an arbitrary buffer:
ALLEGRO_USTR_INFO info;
al_ustr_append(us, al_ref_buffer(&info, buf, size));
See also: al_ustr_append_cstr, al_ustr_append_chr, al_ustr_appendf, al_ustr_vappendf
al_ustr_append_cstr
bool al_ustr_append_cstr(ALLEGRO_USTR *us, const char *s)
Append C-style string s
to the end of us
.
Returns true on success, false on error.
See also: al_ustr_append
al_ustr_append_chr
size_t al_ustr_append_chr(ALLEGRO_USTR *us, int32_t c)
Append a code point to the end of us
.
Returns the number of bytes added, or 0 on error.
See also: al_ustr_append
al_ustr_appendf
bool al_ustr_appendf(ALLEGRO_USTR *us, const char *fmt, ...)
This function appends formatted output to the string us
. fmt
is a printf-style format string. See al_ustr_newf about the "%s" and "%c" specifiers.
Returns true on success, false on error.
See also: al_ustr_vappendf
al_ustr_vappendf
bool al_ustr_vappendf(ALLEGRO_USTR *us, const char *fmt, va_list ap)
Like al_ustr_appendf but you pass the variable argument list directly, instead of the arguments themselves. See al_ustr_newf about the "%s" and "%c" specifiers.
Returns true on success, false on error.
See also: al_ustr_appendf
Removing parts of strings
al_ustr_remove_chr
bool al_ustr_remove_chr(ALLEGRO_USTR *us, int pos)
Remove the code point beginning at byte offset pos
. Returns true on success. If pos
is out of range or pos
is not the beginning of a valid code point, returns false leaving the string unmodified.
Use al_ustr_offset to find the byte offset for a code-points offset.
See also: al_ustr_remove_range
al_ustr_remove_range
bool al_ustr_remove_range(ALLEGRO_USTR *us, int start_pos, int end_pos)
Remove the interval [start_pos, end_pos) (in bytes) from a string. start_pos
and end_pos
may both be past the end of the string but cannot be less than 0 (the start of the string).
Returns true on success, false on error.
See also: al_ustr_remove_chr, al_ustr_truncate
al_ustr_truncate
bool al_ustr_truncate(ALLEGRO_USTR *us, int start_pos)
Truncate a portion of a string at byte offset start_pos
onwards. start_pos
can be past the end of the string (has no effect) but cannot be less than 0.
Returns true on success, false on error.
See also: al_ustr_remove_range, al_ustr_ltrim_ws, al_ustr_rtrim_ws, al_ustr_trim_ws
al_ustr_ltrim_ws
bool al_ustr_ltrim_ws(ALLEGRO_USTR *us)
Remove leading whitespace characters from a string, as defined by the C function isspace()
.
Returns true on success, or false on error.
See also: al_ustr_rtrim_ws, al_ustr_trim_ws
al_ustr_rtrim_ws
bool al_ustr_rtrim_ws(ALLEGRO_USTR *us)
Remove trailing ("right") whitespace characters from a string, as defined by the C function isspace()
.
Returns true on success, or false on error.
See also: al_ustr_ltrim_ws, al_ustr_trim_ws
al_ustr_trim_ws
bool al_ustr_trim_ws(ALLEGRO_USTR *us)
Remove both leading and trailing whitespace characters from a string.
Returns true on success, or false on error.
See also: al_ustr_ltrim_ws, al_ustr_rtrim_ws
Assigning one string to another
al_ustr_assign
bool al_ustr_assign(ALLEGRO_USTR *us1, const ALLEGRO_USTR *us2)
Overwrite the string us1
with another string us2
. Returns true on success, false on error.
See also: al_ustr_assign_substr, al_ustr_assign_cstr
al_ustr_assign_substr
bool al_ustr_assign_substr(ALLEGRO_USTR *us1, const ALLEGRO_USTR *us2,
int start_pos, int end_pos)
Overwrite the string us1
with the contents of us2
in the byte interval [start_pos, end_pos). The end points will be clamed to the bounds of us2
.
Usually you will first have to use al_ustr_offset to find the byte offsets.
Returns true on success, false on error.
See also: al_ustr_assign, al_ustr_assign_cstr
al_ustr_assign_cstr
bool al_ustr_assign_cstr(ALLEGRO_USTR *us1, const char *s)
Overwrite the string us
with the contents of the C-style string s
. Returns true on success, false on error.
See also: al_ustr_assign_substr, al_ustr_assign_cstr
Replacing parts of string
al_ustr_set_chr
size_t al_ustr_set_chr(ALLEGRO_USTR *us, int start_pos, int32_t c)
Replace the code point beginning at byte offset pos
with c
. pos
cannot be less than 0. If pos
is past the end of us1
then the space between the end of the string and pos
will be padded with NUL ('') bytes. If pos
is not the start of a valid code point, that is an error and the string will be unmodified.
On success, returns the number of bytes written, i.e. the offset to the following code point. On error, returns 0.
See also: al_ustr_replace_range
al_ustr_replace_range
bool al_ustr_replace_range(ALLEGRO_USTR *us1, int start_pos1, int end_pos1,
const ALLEGRO_USTR *us2)
Replace the part of us1
in the byte interval [start_pos, end_pos) with the contents of us2
. start_pos
cannot be less than 0. If start_pos
is past the end of us1
then the space between the end of the string and start_pos
will be padded with NUL ('') bytes.
Use al_ustr_offset to find the byte offsets.
Returns true on success, false on error.
See also: al_ustr_set_chr
Searching
al_ustr_find_chr
int al_ustr_find_chr(const ALLEGRO_USTR *us, int start_pos, int32_t c)
Search for the encoding of code point c
in us
from byte offset start_pos
(inclusive).
Returns the position where it is found or -1 if it is not found.
See also: al_ustr_rfind_chr
al_ustr_rfind_chr
int al_ustr_rfind_chr(const ALLEGRO_USTR *us, int end_pos, int32_t c)
Search for the encoding of code point c
in us
backwards from byte offset end_pos
(exclusive). Returns the position where it is found or -1 if it is not found.
See also: al_ustr_find_chr
al_ustr_find_set
int al_ustr_find_set(const ALLEGRO_USTR *us, int start_pos,
const ALLEGRO_USTR *accept)
This function finds the first code point in us
, beginning from byte offset start_pos
, that matches any code point in accept
. Returns the position if a code point was found. Otherwise returns -1.
See also: al_ustr_find_set_cstr, al_ustr_find_cset
al_ustr_find_set_cstr
int al_ustr_find_set_cstr(const ALLEGRO_USTR *us, int start_pos,
const char *accept)
Like al_ustr_find_set but takes a C-style string for accept
.
al_ustr_find_cset
int al_ustr_find_cset(const ALLEGRO_USTR *us, int start_pos,
const ALLEGRO_USTR *reject)
This function finds the first code point in us
, beginning from byte offset start_pos
, that does not match any code point in reject
. In other words it finds a code point in the complementary set of reject
. Returns the byte position of that code point, if any. Otherwise returns -1.
See also: al_ustr_find_cset_cstr, al_ustr_find_set
al_ustr_find_cset_cstr
int al_ustr_find_cset_cstr(const ALLEGRO_USTR *us, int start_pos,
const char *reject)
Like al_ustr_find_cset but takes a C-style string for reject
.
al_ustr_find_str
int al_ustr_find_str(const ALLEGRO_USTR *haystack, int start_pos,
const ALLEGRO_USTR *needle)
Find the first occurrence of string needle
in haystack
, beginning from byte offset pos
(inclusive). Return the byte offset of the occurrence if it is found, otherwise return -1.
See also: al_ustr_find_cstr, al_ustr_rfind_str, al_ustr_find_replace
al_ustr_find_cstr
int al_ustr_find_cstr(const ALLEGRO_USTR *haystack, int start_pos,
const char *needle)
Like al_ustr_find_str but takes a C-style string for needle
.
al_ustr_rfind_str
int al_ustr_rfind_str(const ALLEGRO_USTR *haystack, int end_pos,
const ALLEGRO_USTR *needle)
Find the last occurrence of string needle
in haystack
before byte offset end_pos
(exclusive). Return the byte offset of the occurrence if it is found, otherwise return -1.
See also: al_ustr_rfind_cstr, al_ustr_find_str
al_ustr_rfind_cstr
int al_ustr_rfind_cstr(const ALLEGRO_USTR *haystack, int end_pos,
const char *needle)
Like al_ustr_rfind_str but takes a C-style string for needle
.
al_ustr_find_replace
bool al_ustr_find_replace(ALLEGRO_USTR *us, int start_pos,
const ALLEGRO_USTR *find, const ALLEGRO_USTR *replace)
Replace all occurrences of find
in us
with replace
, beginning at byte offset start_pos
. The find
string must be non-empty. Returns true on success, false on error.
See also: al_ustr_find_replace_cstr
al_ustr_find_replace_cstr
bool al_ustr_find_replace_cstr(ALLEGRO_USTR *us, int start_pos,
const char *find, const char *replace)
Like al_ustr_find_replace but takes C-style strings for find
and replace
.
Comparing
al_ustr_equal
bool al_ustr_equal(const ALLEGRO_USTR *us1, const ALLEGRO_USTR *us2)
Return true iff the two strings are equal. This function is more efficient than al_ustr_compare so is preferable if ordering is not important.
See also: al_ustr_compare
al_ustr_compare
int al_ustr_compare(const ALLEGRO_USTR *us1, const ALLEGRO_USTR *us2)
This function compares us1
and us2
by code point values. Returns zero if the strings are equal, a positive number if us1
comes after us2
, else a negative number.
This does not take into account locale-specific sorting rules. For that you will need to use another library.
See also: al_ustr_ncompare, al_ustr_equal
al_ustr_ncompare
int al_ustr_ncompare(const ALLEGRO_USTR *us1, const ALLEGRO_USTR *us2, int n)
Like al_ustr_compare but only compares up to the first n
code points of both strings.
Returns zero if the strings are equal, a positive number if us1
comes after us2
, else a negative number.
al_ustr_has_prefix
bool al_ustr_has_prefix(const ALLEGRO_USTR *us1, const ALLEGRO_USTR *us2)
Returns true iff us1
begins with us2
.
See also: al_ustr_has_prefix_cstr, al_ustr_has_suffix
al_ustr_has_prefix_cstr
bool al_ustr_has_prefix_cstr(const ALLEGRO_USTR *us1, const char *s2)
Returns true iff us1
begins with s2
.
See also: al_ustr_has_prefix
al_ustr_has_suffix
bool al_ustr_has_suffix(const ALLEGRO_USTR *us1, const ALLEGRO_USTR *us2)
Returns true iff us1
ends with us2
.
See also: al_ustr_has_suffix_cstr, al_ustr_has_prefix
al_ustr_has_suffix_cstr
bool al_ustr_has_suffix_cstr(const ALLEGRO_USTR *us1, const char *s2)
Returns true iff us1
ends with s2
.
See also: al_ustr_has_suffix
UTF-16 conversion
al_ustr_new_from_utf16
ALLEGRO_USTR *al_ustr_new_from_utf16(uint16_t const *s)
Create a new string containing a copy of the 0-terminated string s
which must be encoded as UTF-16. The string must eventually be freed with al_ustr_free.
See also: al_ustr_new
al_ustr_size_utf16
size_t al_ustr_size_utf16(const ALLEGRO_USTR *us)
Returns the number of bytes required to encode the string in UTF-16 (including the terminating 0). Usually called before al_ustr_encode_utf16 to determine the size of the buffer to allocate.
See also: al_ustr_size
al_ustr_encode_utf16
size_t al_ustr_encode_utf16(const ALLEGRO_USTR *us, uint16_t *s,
size_t n)
Encode the string into the given buffer, in UTF-16. Returns the number of bytes written. There are never more than n
bytes written. The minimum size to encode the complete string can be queried with al_ustr_size_utf16. If the n
parameter is smaller than that, the string will be truncated but still always 0 terminated.
See also: al_ustr_size_utf16, al_utf16_encode
Low-level UTF-8 routines
al_utf8_width
size_t al_utf8_width(int c)
Returns the number of bytes that would be occupied by the specified code point when encoded in UTF-8. This is between 1 and 4 bytes for legal code point values. Otherwise returns 0.
See also: al_utf8_encode, al_utf16_width
al_utf8_encode
size_t al_utf8_encode(char s[], int32_t c)
Encode the specified code point to UTF-8 into the buffer s
. The buffer must have enough space to hold the encoding, which takes between 1 and 4 bytes. This routine will refuse to encode code points above 0x10FFFF.
Returns the number of bytes written, which is the same as that returned by al_utf8_width.
See also: al_utf16_encode
Low-level UTF-16 routines
al_utf16_width
size_t al_utf16_width(int c)
Returns the number of bytes that would be occupied by the specified code point when encoded in UTF-16. This is either 2 or 4 bytes for legal code point values. Otherwise returns 0.
See also: al_utf16_encode, al_utf8_width
al_utf16_encode
size_t al_utf16_encode(uint16_t s[], int32_t c)
Encode the specified code point to UTF-8 into the buffer s
. The buffer must have enough space to hold the encoding, which takes either 2 or 4 bytes. This routine will refuse to encode code points above 0x10FFFF.
Returns the number of bytes written, which is the same as that returned by al_utf16_width.
See also: al_utf8_encode, al_ustr_encode_utf16


Getting Started
Getting started with Bifrost is very simple.
Visual Studio
The main Visual Studio solution file that is being used and maintained sits inside the
Source\Solutions
folder and is called Bifrost_All.sln
.
It holds all the projects and you should be able to run this directly.
Minimum requirement is Visual Studio 2015.
Remember that if you have turned off automatic restore of NuGet packages in Visual Studio. You will have to right click the solution in Solution Explorer and chose to explicitly restore packages.
To run the QuickStart once you've got it compiling is simply setting the Bifrost.QuickStart
project as the startup project in Visual Studio.
Visual Studio Code
Note
Description coming soon. Some of the developers are using Visual Studio Code running with .NET Core. It works fine - description will come later.
Build Script
In the root folder of the project sits a F# - FAKE build script, this is the one the build servers are using. If you just want it to build everything and run all the automated tests, you can pass in the target for doing just that.
On Windows:
build.cmd BuildAndSpecs
On Linux / macOS
./build.sh BuildAndSpecs
Running JavaScript specs
The easiest way to run the JavaScript specs is to use Forseti. Open a console / terminal
and navigate into the ./Source
folder.
On Windows, run the following:
..\Tools\Forseti\Forseti.exe
On Linux / Mac with Mono installed:
mono ../Tools/Forseti/Forseti.exe
This will run all specs, but also start watching the folders for changes and automatically run the affected specs.


Next, we compare the numerical results with the electron plasma wave
dispersion relation, which is given by[1]
|
(83) |
where
, and
|
(84) |
is the plasma dispersion function. The plasma dispersion function is related
to the error function of imaginary argument by
|
(85) |
The
function is implemented in Wolfram Mathematica. By using
function of Wolfram Mathematica, the equation (83)
can be easily solved numerically to find the root. For the parameter used in
the simulation
,
gives
. From this, we obtain
.
The oscillation frequency of the electric field can be estimated by counting
the peaks in Fig. 8, from which we obtain
, which agrees the theoretic value given above. Figure
8 shows that the amplitude of the electric filed decreases
exponentially with time. Figure 9 compares the theoretic growth rate
with the simulation results, which also shows good agreement with each other.
Figure 9:
Comparison of the damping rate given by Eq.
(83)
with the simulation results.
.
|
In the weak growth rate approximation, the real frequency of electron plasma
wave is given by
|
(86) |
for a Maxwellian plasma. For the numerical case given here,
. Using this in Eq. (86), we obtain
, which roughly agrees with the exact value
.
In the weak growth rate approximation, the growth rate is given by Eq.
(45), i.e.,
|
(87) |
Using this, we obtain
From this, we obtain
|
(89) |
Using
in Eq. (89), we obtain
, which roughly agrees with the exact value
obtained above. Note that if we used
, instead of the exact frequency
, then Eq.
(89) would give
, which is almost one
order larger than the exact value
. This
highlights the inaccuracy of the approximate formula we encounter in
textbooks[1], where
is used to estimate
the damping rate.
yj
2016-01-26


|
||||||||||
| PREV PACKAGE NEXT PACKAGE | FRAMES NO FRAMES |
See:
Description
| Interface Summary | |
| AtomizableIterator | A SequenceIterator is used to iterate over a sequence. |
| AxisIterator | A SequenceIterator is used to iterate over a sequence. |
| DocumentInfo | The root node of an XPath tree. |
| Item | An Item is an object that can occur as a member of a sequence. |
| LookaheadIterator | A SequenceIterator is used to iterate over a sequence. |
| NamespaceResolver | Interface that supports lookup of a lexical QName to get the expanded QName. |
| NodeInfo | A node in the XML parse tree representing an XML element, character content, or attribute. |
| SequenceIterator | A SequenceIterator is used to iterate over any XPath 2 sequence (of values or nodes). |
| SiblingCountingNode | Interface that extends NodeInfo by providing a method to get the position of a node relative to its siblings. |
| VirtualNode | This interface is implemented by NodeInfo implementations that act as wrappers on some underlying tree. |
| Class Summary | |
| AbstractNode | This class is an abstract implementation of the Saxon NodeInfo interface; it also contains concrete implementations of most of the DOM methods in terms of the NodeInfo methods. |
| AllElementStripper | The AllElementStripper refines the Stripper class to do stripping of all whitespace nodes in a document |
| ArrayIterator | ArrayIterator is used to enumerate items held in an array. |
| Axis | An axis, that is a direction of navigation in the document structure. |
| AxisIteratorImpl | A SequenceIterator is used to iterate over a sequence. |
| DocumentBuilderFactoryImpl | Implementation of JAXP 1.1 DocumentBuilderFactory. |
| DocumentBuilderImpl | This class implements the JAXP DocumentBuilder interface, allowing a Saxon TinyTree to be constructed using standard JAXP parsing interfaces. |
| DocumentPool | An object representing the collection of documents handled during a single transformation. |
| EmptyIterator | EmptyIterator: an iterator over an empty sequence. |
| ListIterator | Class ListIterator, iterates over a sequence of items held in a Java ArrayList, or indeed in any other kind of List |
| Name | This class exists to contain some static methods for validating the syntax of names. |
| NamePool | An object representing a collection of XML names, each containing a Namespace URI, a Namespace prefix, and a local name; plus a collection of namespaces, each consisting of a prefix/URI pair. |
| NamespaceConstant | This class is not instantiated, it exists to hold a set of constants representing known namespaces. |
| Navigator | The Navigator class provides helper classes for navigating a tree, irrespective of its implementation |
| Navigator.AncestorEnumeration | General-purpose implementation of the ancestor and ancestor-or-self axes |
| Navigator.AxisFilter | AxisFilter is an iterator that applies a NodeTest filter to the nodes returned by an underlying AxisIterator. |
| Navigator.BaseEnumeration | BaseEnumeration is an abstract implementation of an AxisIterator, it simplifies the implementation of the underlying AxisIterator by requiring it to provide only two methods: advance(), and getAnother() |
| Navigator.DescendantEnumeration | General-purpose implementation of the descendant and descendant-or-self axes, in terms of the child axis. |
| Navigator.FollowingEnumeration | General purpose implementation of the following axis, in terms of the ancestor, child, and following-sibling axes |
| Navigator.PrecedingEnumeration | |
| Orphan | A node (implementing the NodeInfo interface) representing an attribute, text node, comment, processing instruction, or namespace that has no parent (and of course no children). |
| ProcInstParser | ProcInstParser is used to parse pseudo-attributes within Processing Instructions |
| ReverseArrayIterator | ReverseArrayIterator is used to enumerate items held in an array in reverse order. |
| SingletonIterator | SingletonIterator: an iterator over a sequence of zero or one values |
| StrippedDocument | A StrippedDocument represents a view of a real Document in which selected whitespace text nodes are treated as having been stripped. |
| StrippedNode | A StrippedNode is a view of a node, in a virtual tree that has whitespace text nodes stripped from it. |
| Validation | This class contains constants and static methods to manipulate the validation property of a type. |
| XMLChar | This class defines the basic XML character properties. |
| Exception Summary | |
| NamespaceException | A NamespaceException represents an error condition whereby a QName (for example a variable name or template name) uses a namespace prefix that is not declared |
| QNameException | A QNameException represents an error condition whereby a QName (for example a variable name or template name) is malformed |
This package defines the interface to the Saxon tree structure. This structure is used to represent both the source document and the stylesheet.
The classes in the package are rather a miscellany. What they have in common is that
they describe the way the Saxon tree structure is accessed, in a way that it independent
of the two tree implementations (in packages net.sf.saxon.tree
and
net.sf.saxon.tinytree
).
Broadly speaking, the classes fall into four categories:
net.sf.saxon.tree
package). These classes are
not generally needed by applications, with the exception of NamePool, which complex applications may
need to manipulate.
Michael H. Kay
25 April 2002
|
||||||||||
| PREV PACKAGE NEXT PACKAGE | FRAMES NO FRAMES |