Plug-ins in this package/subpackages provide basic features available in scripts of the Vnano (VCSSL nano), e.g.: I/O features, utility features, and so on.
Features provided by these plug-ins is a subset of the VCSSL System Library which is a standard library of the VCSSL,
so same features are also available in scripts of the VCSSL by default.
All of the above plug-ins are released under CC0.
The plug-in providing environment-related variables.
| Variable | EOL |
|---|---|
| Value | Storing the end-of-line code depending on environment. |
| Data Type | string (constant) |
| Variable | LF |
|---|---|
| Value | Storing a kind of end-of-line code "LF". |
| Data Type | string (constant) |
| Variable | CR |
|---|---|
| Value | Storing a kind of end-of-line code "CR". |
| Data Type | string (constant) |
The plug-in providing data-type-utility functions/variables.
| Variable | INT_MAX |
|---|---|
| Value | Storing the maximum (positive) value in all representable values of "int" type. |
| Data Type | int (constant) |
| Variable | INT_MIN |
|---|---|
| Value | Storing the minimum (negative) value in all representable values of "int" type. |
| Data Type | int (constant) |
| Variable | FLOAT_MAX |
|---|---|
| Value | Storing the maximum (positive) value in all representable values of "float" type. |
| Data Type | float (constant) |
| Variable | FLOAT_MIN_ABS_NORMAL |
|---|---|
| Value | Storing the minimum absolute (positive, non-zero) value in all representable normal numbers of "float" type. |
| Data Type | float (constant) |
| Variable | FLOAT_MIN_ABS_DENORMAL |
|---|---|
| Value | Storing the minimum absolute (positive, non-zero) value in all representable numbers of "float" type containing denormal numbers. |
| Data Type | float |
| Variable | NAN |
|---|---|
| Value | Storing the value of "NaN". The "NaN" represents the special value as a result of invalid floating-point operations. Also, the NaN does not equal any values containing the NaN itself, so we can not check whether a value is NaN or not by comparing this value by "==" operation. For checking a value is nan or not, use nan(value) function. |
| Data Type | float (constant) |
| Variable | INF |
|---|---|
| Value | Storing the value of the (positive) infinity of "float" type. |
| Data Type | float (constant) |
| Variable | UP |
|---|---|
| Value | The rounding mode of round function, for rounding up the fractional part into the specified number of digits. Also, when the value to be rounded is negative, rounds the part excluding the sign in the same way as positive values. |
| Data Type | int (constant) |
| Variable | UP_SIGNIF |
|---|---|
| Value | The rounding mode of round function, for rounding up the significand part into the specified number of digits. Also, when the value to be rounded is negative, rounds the part excluding the sign in the same way as positive values. |
| Data Type | int (constant) |
| Variable | DOWN |
|---|---|
| Value | The rounding mode of round function, for rounding down the fractional part into the specified number of digits. Also, when the value to be rounded is negative, rounds the part excluding the sign in the same way as positive values. |
| Data Type | int (constant) |
| Variable | DOWN_SIGNIF |
|---|---|
| Value | The rounding mode of round function, for rounding down the significand part into the specified number of digits. Also, when the value to be rounded is negative, rounds the part excluding the sign in the same way as positive values. |
| Data Type | int (constant) |
| Variable | HALF_UP |
|---|---|
| Value |
The rounding mode of round function,
for rounding the fractional part into the specified number of digits, as follows:
|
| Data Type | int (constant) |
| Variable | HALF_UP_SIGNIF |
|---|---|
| Value |
The rounding mode of round function,
for rounding the significand part into the specified number of digits, as follows:
|
| Data Type | int (constant) |
| Variable | HALF_DOWN |
|---|---|
| Value |
The rounding mode of round function,
for rounding the fractional part into the specified number of digits, as follows:
|
| Data Type | int (constant) |
| Variable | HALF_DOWN_SIGNIF |
|---|---|
| Value |
The rounding mode of round function,
for rounding the significand part into the specified number of digits, as follows:
|
| Data Type | int (constant) |
| Variable | HALF_TO_EVEN |
|---|---|
| Value |
The rounding mode of round function,
for rounding the fractional part into the specified number of digits, as follows:
|
| Data Type | int (constant) |
| Variable | HALF_TO_EVEN |
|---|---|
| Value |
The rounding mode of round function,
for rounding the significand part into the specified number of digits, as follows:
|
| Data Type | int (constant) |
| Function | nan(value) |
|---|---|
| Feature | Checks whether the passed value is the NaN or not. Note that the NaN does not equal any values containing the NaN itself, so we can not check whether a value is NaN or not by comparing this value by "==" operation. Therefore, use this function for checking it. |
| Singature | bool nan(float value) |
| Params | (float type) value: The value to be checked. |
| Return | (bool type) "true" if the passed value is the NaN, "false" if it isn't. |
| Example | print( nan(0.0/0.0) ); // true |
| Function | inf(value) |
|---|---|
| Feature | Checks whether the passed value is the (positive or negative) infinity. |
| Singature | bool inf(float value) |
| Params | (float type) value: The value to be checked. |
| Return | (bool type) "true" if the passed value is the (positive or negative) infinity, "false" if it isn't. |
| Example | print( inf(1.0/0.0) ); // true |
| Function | length(array, dimIndex) |
|---|---|
| Feature | Gets the length of the specified dimention as "dimIndex" of the specified array "array". |
| Signature | int length(any array[]...[], int dimIndex) |
| Params |
(any type, any arrayrank) array: The array you want to get the length of it.
(int type) dimIndex: The index of the array-dimension you want to get the length on it (regarding the most left dimension as 0-th). |
| Return | (int type) The length on the specified dimension of the specified array. |
| Example | int a[10][11][12]; println( length(a,0) ); // 10 println( length(a,1) ); // 11 println( length(a,2) ); // 12 |
| Function | arrayrank(array) |
|---|---|
| Feature | Gets the number of dimensions (array rank) of the specified array. |
| Signature | int arrayrank(any array[]...[]) |
| Params | (any type, any rank) array: The array you want to get the number of dimensions of it. |
| Return | (int type) The number of dimensions of the specified array. |
| Example | int a[10][11][12]; print( arrayrank(a) ); // 3 |
| Function | round(floatValue, numberOfDigits, roundingMode) |
|---|---|
| Feature | Rounds the specified value. Note that, the param "floatValue" and the return value are float-type, and they internally store values in binary representation. This function converts the passed value into decimal representation, then round it, and finally reconvert the result into binary representation again to return it. If you want to avoid errors caused by the above binrary-decimal conversions, use round(stringValue, ...) function instead. |
| Signature | float round(float floatValue, int numberOfDigits, int roundingMode) |
| Params |
(float type) floatValue: The value to be rounded.
(int type) numberOfDigits: The number of digits of the rounded part (fractional part or significand part, depends on mode) in the rounded result value. (int type) roundingMode: The mode of rounding, e.g.: HALF_UP and so on. |
| Return | (float type) The rounded value. |
| Example | float result = round(123.0625, 3, HALF_UP); print(result); // 123.063 |
| Function | round(stringValue, numberOfDigits, roundingMode) |
|---|---|
| Feature | Rounds the specified value. |
| Signature | string round(string stringValue, int numberOfDigits, int roundingMode) |
| Params |
(string type) stringValue: The value to be rounded.
(int type) numberOfDigits: The number of digits of the rounded part (fractional part or significand part, depends on mode) in the rounded result value. (int type) roundingMode: The mode of rounding, e.g.: HALF_UP and so on. |
| Return | (string type) The rounded value. |
| Example | string result = round("123.0625", 3, HALF_UP); print(result); // 123.063 |
The plug-in providing I/O functions from/to the terminal.
When the option "UI_MODE" of the script engine is set to "CUI",
I/O will be performed from/to the standard input/output.
When the option "UI_MODE" of the script engine is set to "GUI",
a window like a terminal will be launched,
and I/O will be performed from/to it.
| Function | print(...) |
|---|---|
| Feature | Outputs values to the terminal with delimiting by spaces (tabs). |
| Signature | void print(...) |
| Params | (any data-types, any ranks, any numbers) Values to be printed. |
| Return | None |
| Example | print( "Hello", 123, 4.56, true ); // Hello 123, 4.56, true |
| Function | println(...) |
|---|---|
| Feature | Outputs values to the terminal with delimiting by spaces (tabs), and go to the new line on the terminal. |
| Signature | void println(...) |
| Params | (any data-types, any ranks, any numbers) Values to be printed. |
| Return | None |
| Example | println( "Hello", 123, 4.56, true ); // Hello 123, 4.56, true (line feed) |
The plug-in providing interactive I/O functions from/to the user.
When the option "UI_MODE" of the script engine is set to "CUI",
I/O will be performed from/to the standard input/output.
When the option "UI_MODE" of the script engine is set to "GUI",
a pop-up window will be displayed,
and I/O will be performed interactively by user's actions on the window.
| Function | popup(message) |
|---|---|
| Feature | Displays a message or a value. |
| Signature | void popup(any message) |
| Params | (any type) message: The message or the value to be displayed. |
| Return | None |
| Example | popup( "Hello" ); |
| Function | alert(message) |
|---|---|
| Feature | Displays a message. Compared with "popup" function, the window title, behaviour, and so on are tuned for displaying warning messages. |
| Signature | void alert(string message) |
| Params | (string type) message: The message to be displayed. |
| Return | None |
| Example | alert( "Oops" ); |
| Function | confirm(message) |
|---|---|
| Feature | Displays a confirmation message, and asks for the answer in the form of: Yes (y) or No (n). |
| Signature | bool confirm(string message) |
| Params | (string type) message: The message to be displayed. |
| Return | (bool type) Returns true if the user has answered "Yes" (or inputted "y" on the CUI mode). |
| Example | bool isYes = confirm( "OK?" ); |
| Function | input(message) |
|---|---|
| Feature | Displays a message, and asks for input. |
| Signature | string[] input(string message) |
| Params | (string type) message: The message to be displayed. |
| Return | (string[] type) The inputted value. (The array-length is normally 1, so you can receive it by a scalar variable, if you want.) |
| Example | string inputtedValue[] = input( "Please input" ); |
| Function | input(message) |
|---|---|
| Feature | Displays a message, and asks for input. A default value can be specified by the second argument. |
| Signature | string[] input(string message, any defaultValue) |
| Params |
(string type) message: The message to be displayed.
(any type) defaultValue: The default value. |
| Return | (string[] type) The inputted value. (The array-length is normally 1, so you can receive it by a scalar variable, if you want.) |
| Example | string inputtedValue[] = input( "Please input", "defaultValue" ); |
Provides I/O functions from/to files.
| Variable | READ |
|---|---|
| Value | The value of "mode" parameter of open function, for reading contents from a texit file. |
| Data Type | string (constant) |
| Variable | WRITE |
|---|---|
| Value | The value of "mode" parameter of open function, for writing contents to a texit file. |
| Data Type | string (constant) |
| Variable | APPEND |
|---|---|
| Value | The value of "mode" parameter of open function, for appending contents a texit file, without deleting the current contents. |
| Data Type | string (constant) |
| Variable | READ_CSV |
|---|---|
| Value |
The value of "mode" parameter of open function, for reading contents from a "numerical CSV" file. In the above, "numerical CSV" means the format that multiple numerical values are described in each line, delimited by commas: ",". Note that, it assumes that values don't contain commas or other special characters, and they are not enclosed by double-quatations. Hence, even if they are contained in values, no special handling will be performed to them. This mode reads the values, by splitting each line by commas simply. |
| Data Type | string (constant) |
| Variable | WRITE_CSV |
|---|---|
| Value |
The value of "mode" parameter of open function, for writing contents to a "numerical CSV" file. In the above, "numerical CSV" means the format that multiple numerical values are described in each line, delimited by commas: ",". Note that, it assumes that values don't contain commas or other special characters, and they are not enclosed by double-quatations. Hence, even if they are contained in values, no special handling will be performed to them. This mode writes the values in a line, by inserting commas between them simply. |
| Data Type | string (constant) |
| Variable | APPEND_CSV |
|---|---|
| Value |
The value of "mode" parameter of open function, for appending contents to a "numerical CSV" file, without deleting the current contents. In the above, "numerical CSV" means the format that multiple numerical values are described in each line, delimited by commas: ",". Note that, it assumes that values don't contain commas or other special characters, and they are not enclosed by double-quatations. Hence, even if they are contained in values, no special handling will be performed to them. This mode writes the values in a line, by inserting commas between them simply. |
| Data Type | string (constant) |
| Variable | READ_TSV |
|---|---|
| Value |
The value of "mode" parameter of open function, for reading contents from a "numerical TSV" file. In the above, "numerical TSV" means the format that multiple numerical values are described in each line, delimited by tab characters (tabs). Note that, it assumes that values don't contain tabs or other special characters, and they are not enclosed by double-quatations. Hence, even if they are contained in values, no special handling will be performed to them. This mode reads the values, by splitting each line by tabs simply. |
| Data Type | string (constant) |
| Variable | WRITE_TSV |
|---|---|
| Value |
The value of "mode" parameter of open function, for writing contents to a "numerical TSV" file. In the above, "numerical TSV" means the format that multiple numerical values are described in each line, delimited by tab characters (tabs). Note that, it assumes that values don't contain tabs or other special characters, and they are not enclosed by double-quatations. Hence, even if they are contained in values, no special handling will be performed to them. This mode writes the values in a line, by inserting tabs between them simply. |
| Data Type | string (constant) |
| Variable | APPEND_TSV |
|---|---|
| Value |
The value of "mode" parameter of open function, for appending contents to a "numerical TSV" file, without deleting the current contents. In the above, "numerical TSV" means the format that multiple numerical values are described in each line, delimited by tab characters (tabs). Note that, it assumes that values don't contain tabs or other special characters, and they are not enclosed by double-quatations. Hence, even if they are contained in values, no special handling will be performed to them. This mode writes the values in a line, by inserting tabs between them simply. |
| Data Type | string (constant) |
| Variable | READ_STSV |
|---|---|
| Value |
The value of "mode" parameter of open function, for reading contents from a numerical "Spaces & Tabs Separated Values" file. In the above, "Spaces & Tabs Separated Values" means the format that multiple numerical values are described in each line, delimited by space or tab characters. Especially, as a delimiter, sometimes multiple consecutive spaces/tabs are used instead of one space/tab, for aligning positions of columns. Note that, the format name "Spaces & Tabs Separated Values" (STSV) is not general. It is the name used only in this document and related docs. However, even though it is not clear what we should call it as, this format is often used in fields in numerical calculations and data analysis. |
| Data Type | string (constant) |
| Function | open(fileName, mode) |
|---|---|
| Feature | Opens the specified file in the specified mode, and returns the file ID assigned to it. The character encoding will be set to UTF-8 by default. If "FILE_IO_ENCODING" option exists, the encoding will be set to its value. |
| Signature | int open(string fileName, string mode) |
| Params |
(string type) fileName: The name of the path of the file to be opened.
(string type) mode: The mode representing what kind of I/O will be performed to the file: select from READ, WRITE, and so on. |
| Return |
(int type) The ID assigned to the opened file, necessary to specify when reading/writing contents from/to the opened file.
Note that, this file ID is different from the file ID assigned by OS. This file ID will be assigned in ascending order from 1, for the files opened in a script. (The same file ID may be reused after the file was closed.) |
| Example | int fileId = open("example.txt", READ); |
| Function | open(fileName, mode, encoding) |
|---|---|
| Feature | Opens the specified file in the specified mode and the encoding, and returns the file ID assigned to it. |
| Signature | int open(string fileName, string mode, string encoding) |
| Params |
(string type) fileName: The name of the path of the file to be opened.
(string type) mode: The mode representing what kind of I/O will be performed to the file: select from READ, WRITE, and so on. (string type) encoding: The encoding for reading/writing contents from/to the file (e.g.: "UTF-8", "Shift_JIS", and so on). |
| Return |
(int type) The ID assigned to the opened file, necessary to specify when reading/writing contents from/to the opened file.
Note that, this file ID is different from the file ID assigned by OS. This file ID will be assigned in ascending order from 1, for the files opened in a script. (The same file ID may be reused after the file was closed.) |
| Example | int fileId = open("example.txt", READ, "Shift_JIS"); |
| Function | close(fileId) |
|---|---|
| Feature | Closes the specified file. |
| Signature | void close(int fileId) |
| Params | (int type) fileId: The file ID of the file to be closed. (The file ID is the returned value of open function.) |
| Return | None |
| Example |
int fileId = open("example.txt", READ);
... close(fileId); |
| Function | flush(fileId) |
|---|---|
| Feature | Writes (flushes) the temporary stored contents in the writing-buffer, to the file. In most situation, it is not necessary to flush the buffer explicitly by this function, because the buffer will be flushed automatically when the file will be closed. This function is useful when, for example, your script keeps a file opened for a while, and you want to flush the buffer at the arbitrary timing. |
| Signature | void flush(int fileId) |
| Params | (int type) fileId: The file ID of the file to be flushed. (The file ID is the returned value of open function.) |
| Return | None |
| Example |
int fileId = open("example.txt", WRITE);
... flush(fileId); |
| Function | write(fileId, ...) |
|---|---|
| Feature | Writes the specified value(s) to the specified file. |
| Signature | void write(int fileId, ...) |
| Params |
(int type) fileId: The file ID of the file to which write values. (The file ID is the returned value of open function.)
(any number/type, after the above param) The value(s) to be written. |
| Return | None |
| Example |
int fileId = open("example.txt", WRITE);
... write(fileId, "abc", 123, 4.56, true); |
| Function | writeln(fileId, ...) |
|---|---|
| Feature | Writes the specified value(s) to the specified file, and goes to the next line. |
| Signature | void write(int fileId, ...) |
| Params |
(int type) fileId: The file ID of the file to which you write values. (The file ID is the returned value of open function.)
(any number/type, after the above param) The value(s) to be written. |
| Return | None |
| Example |
int fileId = open("example.txt", WRITE);
... writeln(fileId, "abc", 123, 4.56, true); |
| Function | read(fileId) |
|---|---|
| Feature | Reads all value(s) from the specified file. |
| Signature | string[] read(int fileId) |
| Params | (int type) fileId: The file ID of the file from which you read values. (The file ID is the returned value of open function.) |
| Return | (string[] type) In READ mode, the array of which length is 1, storing all content of the file, will be returned (In this case, you can store it to a scalar variable, by "=" operator simply). In READ_CSV / READ_TSV / READ_STSV modes, an array storing the whole content(s) of the file splitted by the delimiter will be returned. |
| Example |
int fileId = open("example.txt", READ);
... string contentInFile = read(fileId); |
| Function | readln(fileId) |
|---|---|
| Feature | Reads one line from the specified file. |
| Signature | string[] readln(int fileId) |
| Params | (int type) fileId: The file ID of the file from which you read values. (The file ID is the returned value of open function.) |
| Return | (string[] type) In READ mode, the array of which length is 1, storing the content of one line of the file, will be returned (In this case, you can store it to a scalar variable, by "=" operator simply). In READ_CSV / READ_TSV / READ_STSV modes, an array storing the content(s) of one line splitted by the delimiter will be returned. |
| Example |
int fileId = open("example.txt", READ);
... string contentInLine = readln(fileId); ( or ) int fileId = open("example.txt", READ_CSV); ... string valuesInLine[] = readln(fileId); |
| Function | countln(fileId) |
|---|---|
| Feature | Counts up the total number of lines in the specified file. Please note that, this function internally reads all lines from the file, and reopens the file in the same mode. Hence, if you use this function for the file from which some lines were already read, you will get incorrect result, and the reading state (e.g.: pointer to the line to be read next time) for the file will be reset. To prevent the above, use this function only just after opening the file. |
| Signature | int countln(int fileId) |
| Params | (int type) fileId: The file ID of the file of which lines should be counted up. (The file ID is the returned value of open function.) |
| Return | (int type) The total number of lines in the specified file. |
| Example |
int fileId = open("example.txt", READ);
int lineN = countln(fileId); |
| Function | save(filePath, value) |
|---|---|
| Feature | Opens the specified file, and writes the specified value, and closes the file. The character encoding will be set to UTF-8 by default. If "FILE_IO_ENCODING" option exists, the encoding will be set to its value. |
| Signature | void save(string filePath, any value) |
| Params |
(string type) filePath: The name or path of the file to which you write the value.
(any type) value: The value to be written. |
| Return | なし |
| Example | save("example.txt", 123); |
| Function | load(filePath) |
|---|---|
| Feature | Opens the specified file, and reads the whole content, and closes the file. The character encoding for the reading will be set to UTF-8 by default. If "FILE_IO_ENCODING" option exists, the encoding will be set to its value. |
| Signature | string load(string filePath) |
| Params | (string type) filePath: The name or path from which you read the content. |
| Return | (string type) The content read from the file. |
| Example | string content = read("example.txt"); |
| Function | exists(filePath) |
|---|---|
| Feature | Checks whether a file or a directory exists at the specified file path. |
| Signature | bool exists(string filePath) |
| Params | (string type) filePath: The file path to be checked. |
| Return | (bool type) Returns true if a file or a directory exists at the specified file path. |
| Example | bool result = exists("./temp/example.txt"); |
| Function | isdir(directoryPath) |
|---|---|
| Feature | Checks whether the element (file or directory) located at the specified path is a directory. |
| Signature | bool isdir(string directoryPath) |
| Params | (string type) directoryPath: The directory path to be checked. |
| Return | (bool type) Returns true if the element at the specified path is a directory. |
| Example | bool result = isdir("./temp/example_folder"); |
| Function | listdir(directoryPath) |
|---|---|
| Feature | Gets the names of all elements (files and subdirectories) in the specified directory. |
| Signature | string[] listdir(string directoryPath) |
| Params | (string type) directoryPath: The path of the directory of which names of elements should be gotten. |
| Return | (string[] type) The array storing names of the all elements in the specified directory. |
| Example | string elementNames[] = listdir("./temp/example_folder"); |
| Function | mkdir(directoryPath) |
|---|---|
| Feature | Creates the specified directory. Please note that, this function does not create the parent directory automatically, so the parent directory must already exist. If the parent directory does not exist, please create it at first, and then create the (sub)directory. Also, if the specified directory already exist, this function do nothing (does not raise an error). |
| Signature | void mkdir(string directoryPath) |
| Params | (string type) directoryPath: The path of the directory to be created. |
| Return | None |
| Example |
mkdir("./temp");
mkdir("./temp/example_folder"); mkdir("./temp/example_folder/example_folder2"); |
The plug-in providing time-utility functions
| Function | time() |
|---|---|
| Feature | Measures the elapsed time from the beginning of the execution of the current script, in the unit of millisecond. |
| Signature | int time() |
| Params | None |
| Return | (int type) The elapsed time from the beginning of the execution of the current script, in the unit of millisecond. |
| Example | int t = time(); print( t ); |
| Function | sleep(sleepTime) |
|---|---|
| Feature | Stops the execution of the script, during the specified time in the unit of millisecond. |
| Singature | void sleep( int sleepTime ) |
| Params | (int type) sleepTime: The time in the unit of millisecond, for which the script to be stopped. |
| Return | None |
| Example | sleep(1000); // Stops 1 second |
The plug-in providing functions for terminating scripts
| Function | exit() |
|---|---|
| Feature | Terminates the execution of the script without generating errors. |
| Signature | void exit() |
| Parameters | None |
| Return | None |
| Example | exit(); |
| Function | exit(exitStatusCode) |
|---|---|
| Feature | Terminates the execution of the script without generating errors, with specifying the exit status code. |
| Signature | void exit(int exitStatusCode) |
| Params | (int type) exitStatusCode: The exit status code (it is depends on implementations of the script engine and the host application that how it will be handled) |
| Return | None |
| Example | exit(1); |
| Function | error(errorMessage) |
|---|---|
| Feature | Terminates the execution of the script with generating an error having the specified message. |
| Signature | void error(string errorMessage) |
| Parameters | (string type) errorMessage: The content of the error message to be notified to the user of the script. |
| Return | None |
| Example | error( "something is wrong !" ); |
The XNCI1 plug-in providing utility functions for testing.
| Function | assert(expectedCondition) |
|---|---|
| Feature | Do nothing if the value of the expected condition specified as an argument is "true", and generates an error if it is "false". |
| Signature | void assert( bool expectedCondition ) |
| Params | (bool type) expectedCondition: The value of the expected condition. |
| Return | None |
| Example | int x; x = 1; assert( 0 < x ); // OK x = -1; assert( 0 < x ) ; // Error |


| DataReaderQosConfiguration |
The configuration class for DataWriterQos.
|
| DataWriterQosConfiguration |
The configuration class for DataWriterQos.
|
| DeadlineQosPolicyConfiguration |
The configuration class for DeadlineQosPolicy.
|
| DestinationOrderQosPolicyConfiguration |
Class managing DestinationOrderQosPolicy
|
| DomainParticipantQosConfiguration |
The configuration class for DomainParticipantQos.
|
| DurabilityQosPolicyConfiguration |
The configuration class for DurabilityQosPolicy.
|
| DurabilityServiceQosPolicyConfiguration |
The configuration class for DurabilityServiceQosPolicy.
|
| EntityFactoryQosPolicyConfiguration |
The configuration class for EntityFactoryQosPolicy.
|
| GroupDataQosPolicyConfiguration |
The configuration class for GroupDataQosPolicy.
|
| HistoryQosPolicyConfiguration |
The configuration class for HistoryQosPolicy.
|
| KafkaChannelConfiguration |
The configuration class for Kafka channel
|
| KafkaConfiguration |
The configuration class for Kafka
|
| LatencyBudgetQosPolicyConfiguration |
The configuration class for LatencyBudgetQosPolicy.
|
| LifespanQosPolicyConfiguration |
The configuration class for LifespanQosPolicy.
|
| LivelinessQosPolicyConfiguration |
The configuration class for LivelinessQosPolicy.
|
| OpenDDSChannelConfiguration |
|
| OpenDDSConfiguration |
The configuration class for OpenDDS
|
| OwnershipQosPolicyConfiguration |
The configuration class for OwnershipQosPolicy.
|
| OwnershipStrengthQosPolicyConfiguration |
The configuration class for OwnershipStrengthQosPolicy.
|
| PartitionQosPolicyConfiguration |
The configuration class for PartitionQosPolicy.
|
| PresentationQosPolicyConfiguration |
The configuration class for PresentationQosPolicy.
|
| PropertyQosPolicyConfiguration |
The configuration class for PropertyQosPolicy.
|
| PublisherQosConfiguration |
The configuration class for PublisherQos.
|
| ReaderDataLifecycleQosPolicyConfiguration |
The configuration class for ReaderDataLifecycleQosPolicy.
|
| ReliabilityQosPolicyConfiguration |
The configuration class for ReliabilityQosPolicy.
|
| ResourceLimitsQosPolicyConfiguration |
The configuration class for ResourceLimitsQosPolicy.
|
| SubscriberQosConfiguration |
The configuration class for SubscriberQos.
|
| TimeBasedFilterQosPolicyConfiguration |
The configuration class for TimeBasedFilterQosPolicy.
|
| TopicDataQosPolicyConfiguration |
The configuration class for TopicDataQosPolicy.
|
| TopicQosConfiguration |
The configuration class for TopicQos.
|
| TransportPriorityQosPolicyConfiguration |
The configuration class for TransportPriorityQos.
|
| UserDataQosPolicyConfiguration |
The configuration class for UserDataQosPolicy.
|
| WriterDataLifecycleQosPolicyConfiguration |
The configuration class for WriterDataLifecycleQosPolicy.
|


{{ define "title" }}Import Championship{{ end }} {{ define "content" }}
Here you can import championships in a JSON format (this format matches the format given when you export a championship). We do not recommend attempting to manually create this data, as the format is quite complex. However if you want to move championships across servers but don't have file access then you can use this feature!
{{ end }}


---
layout: page
title: Major announcements
description: Not all emails should look the same. Sometimes it’s appropriate to ditch the starter templates and design something unique. Here are a few emails we’ve sent for major announcements.
hide-menu: true
---
{% tip %}
Note: The source for these emails is provided for historical purposes only. It’s ok to grab parts of a design, but these templates should not be used as a starting point because the code is likely outdated.
{% endtip %}


@Suspendable fun waitForLedgerCommit(hash: SecureHash): SignedTransaction
Suspends the flow until the transaction with the specified ID is received, successfully verified and sent to the vault for processing. Note that this call suspends until the transaction is considered valid by the local node, but that doesn't imply the vault will consider it relevant.


Properties needed by your ant build can be specified here (in standard properties file format):
# comment
name1=value1
name2=$VAR2
These are passed to Ant like "-Dname1=value1 -Dname2=value2".
Always use $VAR style (even on Windows) for references to Jenkins-defined
environment variables. On Windows, %VAR% style references may be used
for environment variables that exist outside of Jenkins.
Backslashes are used for escaping, so use \\ for a single backslash.
Double quotes (") should be avoided, as ant on *nix wraps parameters in quotes
quotes and runs them through eval, and Windows has its own issues
with escaping.. in either case, use of quotes may result in build failure.
To define an empty property, simply write varname=


Hi All, I'm new to the forum so excuse me if I missed it, but I've tried searching for a DC voltage / current monitoring setup for emon. It seems most Solar uses are for Grid tied and AC inverter uses with standard CT sensor.
What I'm looking to buy / built / program, is an ALL DC version for a small solar setup, a few PV panels and a Charge Controller with 12 VDC batteries and a 12 VDC load, a water pump for a pond.
This is probably overkill for a small solar system like this, but I'm trying to balance the running of the pump to the power into and out of the solar system. Basically, there are 3 input / ouputs. 18 Volt solar panels, output from Charge controller to battery (could be charging or drawing current - if cloudy) and output to load (12V DC water pump).
I'd love to use the ecomTX and 3 current sensors for each item connected to the Charge Controller, in order to monitor the solar power generated, stored and consumed. So basically, it's a solar PV monitor, but all DC, no inverters or AC or Grid.
If anyone can help me get to the best starting point, I would be very grateful and if work needed, I will develop and contribute the system, but don't want to re-invent the emon Solar DC monitoring wheel, so to speak.
Thanks,
Scott
Re: Are there any all DC Solar monitor hardware / software setups for emon?
This is what i built few weeks ago - emontx is basically same as jeenode. http://openenergymonitor.org/emon/node/2109 . You need external current sensing device.
Re: Are there any all DC Solar monitor hardware / software setups for emon?
I'm fairly certain that some users have at least thought about monitoring the d.c. side - though not low voltage d.c. as you are intending. You don't mention the currents you are envisaging, so I don't know whether Hall effect sensors or plain shunts would be in order, but if the latter then you'd need to keep their volt drops low to keep power losses to a minimum so some amplification would be required to get a usable voltage to feed the ADC.
The emonTx is designed for a.c. mains use so it's probably not the best starting point, you might be better starting with an Arduino board with a custom interface to your hardware. You also need to think about your control algorithm. Calypso_rae's Mk 2 router algorithm is intrinsically tied to mains frequency and the characteristics of the energy meter, it seems to me that - depending on the characteristics of your pump, you will be essentially free of these limitations and you could drive your pump at variable speed or on/off with whatever period and duty cycle you desire. However, the basic control algorithm should stand you in good stead.
Re: Are there any all DC Solar monitor hardware / software setups for emon?
Oh - did not fully read that in addition to dc monitoring also a way to control output is needed. Attached a link to a schematic and code (with google translator) to a mppt controlled dc hot water heater. Its not exactly same what you want but another view to the same challenge: http://translate.google.com/translate?sl=fi&tl=en&js=n&prev=_t&hl=en&ie=UTF-8&eotf=1&u=http%3A%2F%2Fwww.poikkis.net%2Findex.php%3Ftopic%3D5155.0
Basically this circuit has a constant load resitor and then with varying output it switches excess energy to additional hot water tank heater resistors based on how much energy is available. I.e you could have motor on constantly and then switch the heater elements on using this kind of setup.
Re: Are there any all DC Solar monitor hardware / software setups for emon?
Erm...
I think the fish would die if the water were to be heated.
Re: Are there any all DC Solar monitor hardware / software setups for emon?
Thanks, that looks great and will be very helpful. a good place to start. I didn't know much about the jeenode before, I will check it out.
Re: Are there any all DC Solar monitor hardware / software setups for emon?
The currents are low, I'm talking about a 50 Watt panel at 18 volts, a fairly simple 12 DC charge controller with multiple charge modes. Yes, probably use a shunt and OpAmp into the ADC. The 12 VDC Pump is somewhat flexible, it draws less than 2 amps at most voltage levels, from 11 - 13 volts out of the load side of the charge controller.
The Battery is deep cycle 12VDC 40 Amp hours, so with good control routine, should keep it in the 50% - 100% range. In full sun and the pump running, should just lightly or trickle charge the battery, so no need for a dump load, plus, just running the pump evening and/or early morning will almost ensure the battery is never fully charged, come peak solar time.
However, on cloudy or rainy days, don't want to run the fountain pump too much to drain the batteries too low. And one of the main reasons to have the monitoring, is to know if maybe need a 60 or 80 watt PV panel, for example. So part of this is to help tweak the setup under real site conditions, not just estimates, of average solar days, etc. and of course, see how much power is made from sun and used on pond. It's not for any significant saving on AC, more not paying to run AC power out to the pond / fountain waterscape.
Re: Are there any all DC Solar monitor hardware / software setups for emon?
lol.... Yes, don't want to heat the water, but I may add an underwater LED light to burn any extra watts I might have in summer months.


--- title: Events menu: main1 weight: 30 permalink: events/ --- {% assign events = site.events | where_exp: "event", "event.date > site.time" %}


Tyrannosaurus server. Does everything you want from a server. Defaults to a simple static server, but rest callbacks can be added later.
#addListener(eventName, listener)
Adds a listener function to the given event name. Currently we only do close events, but we could add more.
Adds a listener function to the given event name. Currently we only do close events, but we could add more.
{string} The name of the event.
{function} The callback to be called when the event happens.
#addPaths(urlPath, staticPaths)
Adds the given set of paths to the specified route. Note that if multiple static paths are specified they are treated as fallbacks.
Adds the given set of paths to the specified route. Note that if multiple static paths are specified they are treated as fallbacks.
{string} The url path to listen on.
{string|array} The set of static paths that this url should map to. When multiple are specified, if a resource cannot be found in the first static path the next paths will be searched in order.
#addRoute(method, path, callback)
Adds a route to the given method and path.
Adds a route to the given method and path.
{string} The method. Should be GET, PUT, POST, DELETE, or PATCH.
{string} The path. In general, a path should be a series of strings with slashes between, but tyranno-serve also allows you to specify route variables by starting a folder with a colon. For example, /users/:userId/products/:productId would allow any string to be specified for the userId and productId. In addition, if you specify a path with two colons, it will consume all characters after including slashes (this is how the static file server works.). In general, multiple url definitions may conflict, (for example '/users/:userId' for getting user info but then '/users/:userId/products/:productId' for getting a user's product). Tyranno-Serve will try to find the most specific possible match for a particular url by matching folders. For example, if the user and product paths were specified and nothing else, if you looked for '/users/abc/products' it would come out with not found. This is because there was something specified under products but it required an id, and nothing was specified under just products. '/users/abc' and 'users/abc/products/def' would work as expected however.
A callback function that takes a request and a response object. The request and response object are the same that would be received from the http.Server.listen command with some additions:
#badRequestDefault(input)
Sets the default callback for bad request.
Sets the default callback for bad request.
{string|function} @see notFoundDefault.
#close(callback)
Turns off this server so that resources like ports and file watchers are released.
Turns off this server so that resources like ports and file watchers are released.
{function} A callback function for when closing has started.
#constructor(input)
Constructs the tyranno serve. Can be constructed similarly to how it is used on the command line.
Constructs the tyranno serve. Can be constructed similarly to how it is used on the command line.
{string|object} Either a path to a json file to use for settings or an object of settings. Note that this parameter is optional.
#internalServerErrorDefault(input)
Sets the default callback for internal server error.
Sets the default callback for internal server error.
{string|function} @see notFoundDefault.
#listen(callback)
Actually starts listening for incoming requests.
Actually starts listening for incoming requests.
{function} A callback function for when listening has started.
#notFoundDefault(input)
Sets the default callback for not found.
Sets the default callback for not found.
{string|function} Either a string or a function. If it's a callback it is used directly. If it's a string it is treated as a filename. WARNING: because the fallback and path mechanism is incompatible with this this string must either be an absolute path or relative to the CWD. Otherwise it can't find it.
#serve(request, response)
Serves a particular request for this server object. Does routing logic and adds utility functions to the request and response objects before they are passed into the callback registered for a particular route.
Serves a particular request for this server object. Does routing logic and adds utility functions to the request and response objects before they are passed into the callback registered for a particular route.
The incoming http request.
The response object to send data to.
Adds the given static paths to the server using the file watcher to watch for changes.
{TyrannoServe} The server to add the static file watch to
{string} The url path to add to
{string|Array
{FileWatcher} The fie watcher for watching.
The ResponseAugmenter is responsible for augmenting responses that come in throught the server with utility functions.
#augment(request, response)
Actually augments the response. The augmented functions are: ok, notFound, badRequest, internalServerError, and redirect. With the exception of redirect, all of these return a ResponseSender object. Redirect takes a redirectUrl string as an argument. NotFound, BadRequest, and InternalServerError all have defaults that can be set up.
Actually augments the response. The augmented functions are: ok, notFound, badRequest, internalServerError, and redirect. With the exception of redirect, all of these return a ResponseSender object. Redirect takes a redirectUrl string as an argument. NotFound, BadRequest, and InternalServerError all have defaults that can be set up.
The object to augment.
#constructor(server)
Constructs the augmenter with default values for notFound, badRequest, and internalServerError.
Constructs the augmenter with default values for notFound, badRequest, and internalServerError.
{Number} Milliseconds to wait between the time a change is detected and the time a reload command is sent.
{false|[string]}
The ResponseSender is a utility class that allows you to easily send data with a particular response code.
#constructor(server, request, response, statusCode, defaultCallback)
Constructor.
Constructor.
{TyrannoServe} The server object; used for settings.
The request object to use
The response object to use.
{number} The status code to send when we write a response.
{function} Default function to call for this type.
#content(value, mimeType)
Sends the given content to the caller as a response.
Sends the given content to the caller as a response.
{string} The value to send.
{string} The mime type to send.
#data(value)
Sends json data back to the caller as a response.
Sends json data back to the caller as a response.
Any object to be sent.
#doDefault
Does the default action if available.
Does the default action if available.
#file(filePath, nextCallback)
Serves a file from the given location.
Serves a file from the given location.
{string} The path of the file in question.
{function} A function to call if you get a not found.
Class for interpreting settings files and settings objects and converting them into a standard, easy to use format.
#fromArgv(argv)
From argv converts an argument input into a standard settings json object that can be used by tyranno-serve.
From argv converts an argument input into a standard settings json object that can be used by tyranno-serve.
The command line arguments.
object
:
The json-like argument object.
#fromFile(settingsFile)
Creates a settings object from the given filename.
Creates a settings object from the given filename.
{string} The filename to load the settings from.
#fromInput(input)
Instantiates a settings object from an arbitrary input parameter.
Instantiates a settings object from an arbitrary input parameter.
{string|object} If a string it reads the filename, otherwise it loads and normalizes it as an object.


Offers
For when you love the item but don't love the price
How do offers work?
Offers are for when you love an item, but don’t love the price. After an item has been on the app for 72 hours and it hasn’t sold, offers will open up on that item. You’ll be able to enter a price lower than the listed price, and if the owner accepts, the order will go through and you’ll be charged.
Do offers expire?
Sellers have 24 hours to respond to an offer before it expires. You can’t cancel an offer after it’s been submitted -- offers are binding.
Is there a minimum offer amount?
To protect sellers from lowball offers, we enforce a minimum offer. If your offer is lower than we allow, we'll show an error message when you tap to make the offer.
Why do some items not have a button to make an offer?
Offers aren’t available on an item until it’s been posted for 72 hours. This is to give sellers a few days for their item to sell at full price before they need to consider any offers. If an item doesn’t have a Make Offer button, offers haven’t opened up yet on that item.
How do I leave an offer?
If an item has been listed for 72 hours and still hasn’t sold, there will be a “Make Offer” button next to the “Buy Now” button. Simply tap the button, enter your offer, and then select your shipping and payment preferences. You won’t be charged unless the owner approves your offer.
Do I need to pay extra for shipping?
Nope! All prices on Curtsy include shipping. For instance, if an item is listed at $50 and you offer $42, you'll only be charged $42 if your item is accepted.
What if my offer isn’t accepted?
Oh no! We recommend messaging the seller and trying to agree on a price. If they’re willing to accept a lower offer, you can make another offer at that lower price.
Do I have to do anything after my offer is accepted?
Nope! Your card will be charged and the item will be shipping to you shortly. Feel free to message the seller and ask when they can ship it.
What if I change my mind?
Offers are binding, meaning if the seller accepts, you’re agreeing to purchase the item from them and your card will be charged. Be sure that you want the item before you make an offer.
Any other questions?
Message us in the app, or use the links below.


- Potentially fixed swapfiles breaking watching
- Updated dependencies
- Updated engines to be node >=0.12 as to align with safefs v4
- May still work with node 0.10, file a bug report if it doesn't
- Fixed
previousStat
not existing sporadically on delete events
- Updated dependencies
- Fixed interval option not beeing passed on to child watchers (regression since v2.4.7)
- Fixed watchr emitting error events incorrectly (regression since v2.4.7)
- Fixed
"me" is undefined
errors (regression since v2.4.7)
- You can now pass falsey values for
catchupDelay
to disable it
- Added the ability to turn off following links by setting
followLinks
to false
- Prefer accuracy over speed
- Use the watch method by default, but don't trust it at all, always double check everything
- More work on swap file handling
- File copies will now trigger events throughout the copy rather than just at the start of the copy
- Fixed bubblr events
- Fixed swap file detection
- Made it so if
duplicateDelay
is falsey we will not do a duplicate check
- Fix
Object #<Object> has no method 'emit'
error
- Changed the
preferredMethod
option into preferredMethods
which accepts an array, defaults to ['watch','watchFile']
- If the watch action fails at the eve level we will try again with the preferredMethods reversed
- This solves issue #31 where watching of large files would fail
- Changed the
interval
option to default to 5007
(recommended by node) instead of 100
as it was before
- The
watch
method provides us with immediate notification of changes without utilising polling, however the watch
method fails for large amounts of files, in which case we will fall back to the watchFile
method that will use this option, if the option is too small we will be constantly polling the large amount of files for changes using up all the CPU and memory, hence the change into a larger increment which has no CPU and memory impact.
- Fixed fallback when preferredMethod is
watchFile
- Fixed uncaught exceptions when intialising watchers under certain circumstances
- Better handling and detection of failed watching operations
- Better handling of duplicated events
- Watching is now an atomic operation
- If watching fails for a descendant, we will close everything related to that watch operation of the eve
- We now prefer the
watch
method over the watchFile
method
- This offers great reliability and way less CPU and memory foot print
- If you still wish to prefer
watchFile
, then set the new configuration option preferredMethod
to watchFile
- Closes issue #30 thanks to Howard Tyson
- Added
outputLog
option
- Added
ignorePaths
option
- Now properly ignores hidden files
- Added
Watcher::isIgnoredPath
method
- Added tests for ignored and hidden files
- Fixed closing when a child path watcher doesn't exist
- Added close tests
- Fixed a bug with closing directories that have children
- This is a backwards compatiblity break, however updating is easy, read the notes below.
- We've updated the events we emit to be:
log
for debugging, receives the arguments logLevel ,args...
watching
for when watching of the path has completed, receives the arguments err, isWatching
change
for listening to change events, receives the arguments changeType, fullPath, currentStat, previousStat
error
for gracefully listening to error events, receives the arguments err
- read the README to learn how to bind to these new events
- The
changeType
argument for change listeners has been changed for better clarity and consitency:
change
is now update
new
is now create
unlink
is now delete
- We've updated the return arguments for
require('watchr').watch
for better consitency:
- if you send the
paths
option, you will receive the arguments err, results
where results
is an array of watcher instances
- if you send the
path
option, you receive the arguments err, watcherInstance
- Fixed sub directory scans ignoring our ignore patterns
- Updated dependencies
- We now ignore common ignore patterns by default
ignorePatterns
configuration option renamed to ignoreCommonPatterns
- Added new
ignoreCustomPatterns
configuration option
- Updated dependencies
- Closes issue #22 and issue #21
- Added missing
bin
configuration
- Fixed completion callback not firing when trying to watch a path that doesn't exist
- Fixed new listeners not being added for directories that have already been watched
- Fixed completion callbacks happening too soon
- Thanks to pull request #14 by Casey Foster
- Re-added markdown files to npm distribution as they are required for the npm website
- Fixed spelling of
persistent
- Explicitly set the defaults for the options
ignoreHiddenFiles
and ignorePatterns
- Added support for
interval
and persistant
options
- Improved unlink detection
- Optimised unlink handling
watchr.watchr
changes
- now only accepts one argument which is an object
- added new
paths
property which is an array of multiple paths to watch
- will only watch paths that actually exist (before it use to throw an error)
- Fixed a few bugs
- Added support for node v0.7/v0.8
- Moved tests from Mocha to Joe
- Fixed a bug with closing watchers
- Now requires pre-compiled code
- Big rewrite
- Got rid of the delay
- Now always fires events
- Watcher instsances inherit from Node's EventEmitter
- Events for
change
, unlink
and new
- Better support for ignoring hidden files
- Improved documentation, readme
- Added
History.md
file
- Added unit tests using Mocha


11 January 2007
As of 15 December, the Ministry of Health Togo has reported 3 cases of yellow fever (males, ages 9, 15 and 20 years) from the region of Savanes and Kara (see previous report). All cases are alive and were laboratory confirmed by the Institute Pasteur in Dakar.
To avoid further spread, an initial joint Ministry of Health/WHO country office investigation team, sent to the field, recommended a vaccination campaign in response to the outbreak.
A mass vaccination campaign will be carried out in the affected regions with 1 550 000 vaccine doses from the Global Alliance for Vaccines and Immunization (GAVI) Emergency Stockpile. The vaccination campaign will be conducted with the support of WHO, European Commission Humanitarian Aid Department (ECHO) and UNICEF.


| Package | Description |
|---|---|
| com.hcl.domino.data | |
| com.hcl.domino.design | |
| com.hcl.domino.design.action |
| Class and Description |
|---|
| DbDesign
Provides access to a database's design elements, allowing querying, selection,
and creation.
|
| Class and Description |
|---|
| Column
Access to a View or Folder column and its settings.
|
| Column.IndexType
Enum for alternate index(es) of a view based on this column.
|
| Column.SortType
Enum for enforced sorting of a column
|
| DbDesign
Provides access to a database's design elements, allowing querying, selection,
and creation.
|
| DbDesign.FolderOrView |
| DbDesign.FormOrSubform
Deprecated.
|
| DbDesign.SignCallback
Callback interface to get notified about progress when signing
|
| DbDesignCatalog.DatabaseDesignAnalysis
Result of the template inheritance scan
|
| DbDesignCatalog.DesignRefreshBreakHandler |
| DbProperties
Access to a database design.
|
| DbProperties.LaunchContextNotes |
| DbProperties.LaunchContextWeb |
| DbProperties.PreviewPaneDefault |
| DbProperties.PropertiesOptions |
| DbProperties.UnreadReplicationSetting |
| DesignAgent
Access to a database design.
|
| DesignAgent.AgentLanguage |
| DesignElement
Access to forms, views, resources read/write
|
| DesignElement.NamedDesignElement |
| Field |
| Field.Kind |
| Field.Type |
| FileResource
Represents a File Resource design element.
|
| Folder
Represents a Folder design element.
|
| Form
Access to a database design.
|
| GenericFolderOrView
Access to a database design.
|
| GenericFolderOrView.OnRefreshType |
| GenericFormOrSubform |
| ImageResource |
| NamedFileElement
Represents common behavior for file-resource-esque design elements with "$FileData"
and "$FileNames" or equivalent items.
|
| ScriptLibrary
Parent interface for script-library design elements.
|
| Subform
Access to a database design.
|
| SubformReference
Represents a reference to a subform, either by name or by formula
|
| SubformReference.Type |
| View
Access to a database design.
|
| Class and Description |
|---|
| ComputableValue
Represents an element in a design that can be represented either as a static
string or a formula computation.
|
Copyright © 2019–2021 HCL. All rights reserved.


PLANET SICK-BOY: http://www.sick-boy.com
Who would make a movie like this? I guess the first place to look would be the producer credit. Go ahead, take a peek at it. Jenno Topping? Does that sound the slightest bit strange to you? Maybe Jenno is a new brand of ice cream and if you put some chocolate sprinkles on it, they would be a Jenno Topping. Perhaps it's a pseudonym to hide his real identity. And speaking of pseudonyms, the editor is named Michael Jablow. ‘Nuff said.
Next check the director credit. Yup, that's two names. Can anyone name a good movie that had two directors? OK, two non-sibling directors - the brothers Farrelly (Kingpin) and Hughes (Menace II Society) don't count. These two are making their directorial debut and have only A Very Brady Sequel under their screenplay belt.
Can't Hardly Wait is one of those annoying coming-of-age pictures where every character learns something important about themselves and, occasionally, about those around them as well. Set on the eve of the affluent Huntington High graduation, Can't Hardly Wait offers nothing that its predecessors hasn't, but has possibly broken new ground in terms of underage drinking and teen sex. And I'm not saying that's a bad thing, either.
Of course, there is the obligatory graduation party thrown by the obligatory girl who is afraid that her parent's house will be trashed. There is also the obligatory nice guy (Embry, Vegas Vacation) who for years has hidden his love of the obligatory prom queen (Love Hewitt, Party of Five), who has been dating the obligatory jock (Facinelli) throughout their four year high school interment.
 Strangely missing are the obligatory man-hating lesbian and the obligatory boy-from-the-wrong-side-of-the-tracks. This is OK with me because it kept the running time down to a stomachable length.
What would make somebody decide to see a movie like this? Take a look at Love-Hewitt's rack and ask the question again.
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


Astropy 1.0 is a major release that adds significant new functionality since the 0.4.x series of releases.
In particular, coordinate conversions to/from Altitude/Azimuth are now supported (see Support for Alt/Az coordinates), a new package to help with data visualization has been added (see New data visualization subpackage), and a new package for common analytic functions is now also included (see New analytic functions subpackage).
The ASCII Tables (astropy.io.ascii) sub-package now includes fast C-based readers/writers for common formats, and also supports a new ASCII format that better preserves meta-data (see New ASCII features), the modeling package has been significantly improved and now supports composite models (see New modeling features), and the Table class can now include SkyCoord and Time objects containing arrays (see New Table features).
In addition to these major changes, Astropy 1.0 includes a large number of smaller improvements and bug fixes, which are described in the Full Changelog. By the numbers:
Astropy v1.0 is a long-term support (LTS) release. This means v1.0 will be supported with bug fixes for 2 years from its release, rather than 6 months like the non-LTS releases. More details about this, including a wider rationale for Astropy’s version numbering scheme, can be found in Astropy Proposal for Enhancement 2.
Note that different sub-packages in Astropy have different stability levels. See the Current status of sub-packages page for an overview of the status of major components. LTS can be expected for anything with green or blue (stable or mature) status on that page. For yellow (in development) subpackages, LTS may be provided, but major changes may prevent backporting of complex changes, particularly if they are connected to new features.
The coordinates package now supports conversion to/from AltAz coordinates. This means coordinates can now be used for planning observations. For example:
>>> from astropy import units as u
>>> from astropy.time import Time
>>> from astropy.coordinates import SkyCoord, EarthLocation, AltAz
>>> greenwich = EarthLocation(lat=51.477*u.deg,lon=0*u.deg)
>>> albireo = SkyCoord('19h30m43.2805s +27d57m34.8483s')
>>> altaz = albireo.transform_to(AltAz(location=greenwich, obstime=Time('2014-6-21 0:00')))
>>> print altaz.alt, altaz.az
60d32m28.4576s 133d45m36.4967s
For a more detailed outline of this new functionality, see the Example: Observation Planning and the AltAz documentation.
To enable this functionality, coordinates now also contains the full IAU-sanctioned coordinate transformation stack from ICRS to AltAz. To view the full set of coordinate frames now available, see the coordinates Reference/API.
Added a new, customizable Galactocentric coordinate frame. The other coordinate frames (e.g., ICRS, Galactic) are all Heliocentric (or barycentric). The center of this new coordinate frame is at the center of the Galaxy, with customizable parameters allowing the user to specify the distance to the Galactic center (galcen_distance), the ICRS position of the Galactic center (galcen_ra, galcen_dec), the height of the Sun above the Galactic midplane (z_sun), and a final roll angle that allows for specifying the orientation of the z axis (roll):
>>> from astropy import units as u
>>> from astropy.coordinates import SkyCoord, Galactocentric
>>> c = SkyCoord(ra=152.718 * u.degree,
... dec=-11.214 * u.degree,
... distance=21.5 * u.kpc)
>>> c.transform_to(Galactocentric)
<SkyCoord (Galactocentric: galcen_distance=8.3 kpc, galcen_ra=266d24m18.36s, galcen_dec=-28d56m10.23s, z_sun=27.0 pc, roll=0.0 deg): (x, y, z) in kpc
(-13.6512648452, -16.6847348677, 12.4862582821)>
>>> c.transform_to(Galactocentric(galcen_distance=8*u.kpc, z_sun=15*u.pc))
<SkyCoord (Galactocentric: galcen_distance=8.0 kpc, galcen_ra=266d24m18.36s, galcen_dec=-28d56m10.23s, z_sun=15.0 pc, roll=0.0 deg): (x, y, z) in kpc
(-13.368458678, -16.6847348677, 12.466872262)>
The new Data Visualization package is intended to collect functionality that can be helpful when visualizing data. At the moment, the main functionality is image normalizing (including both scaling and stretching) but this will be expanded in future. Included in the image normalization functionality is the ability to compute interval limits on data, (such as percentile limits), stretching with non-linear functions (such as square root or arcsinh functions), and the ability to use custom stretches in Matplotlib that are correctly reflected in the colorbar:
import numpy as np
import matplotlib.pyplot as plt
from astropy.visualization import SqrtStretch
from astropy.visualization.mpl_normalize import ImageNormalize
# Generate test image
image = np.arange(65536).reshape((256, 256))
# Create normalizer object
norm = ImageNormalize(vmin=0., vmax=65536, stretch=SqrtStretch())
fig = plt.figure(figsize=(6,3))
ax = fig.add_subplot(1,1,1)
im = ax.imshow(image, norm=norm, origin='lower', aspect='auto')
fig.colorbar(im)
(Source code, png, hires.png, pdf)
This subpackage provides analytic functions that are commonly used in astronomy. These already understand Quantity, i.e., they can handle units of input and output parameters. For instance, to calculate the blackbody flux for 10000K at 6000 Angstrom:
>>> from astropy import units as u
>>> from astropy.analytic_functions import blackbody_lambda, blackbody_nu
>>> blackbody_lambda(6000 * u.AA, 10000 * u.K)
<Quantity 15315791.836941158 erg / (Angstrom cm2 s sr)>
>>> blackbody_nu(6000 * u.AA, 10000 * u.K)
<Quantity 0.00018391673686797075 erg / (cm2 Hz s sr)
See Analytic Functions (astropy.analytic_functions) for more details.
In future versions of Astropy, the functions in this module might also be accessible as Model classes.
The astropy.io.ascii module now includes a significantly faster Cython/C engine for reading and writing ASCII files. This is available for the following formats: basic, commented_header, csv, no_header, rdb, and tab. On average the new engine is about 4 to 5 times faster than the corresponding pure-Python implementation, and is often comparable to the speed of the pandas ASCII file interface (read_csv and to_csv). The fast reader has parallel processing option that allows harnessing multiple cores for input parsing to achieve even greater speed gains.
By default, read() and write() will attempt to use the fast C engine when dealing with compatible formats. Certain features of the full read / write interface are not available in the fast version, in which case the pure-Python version will automatically be used.
For full details including extensive performance testing, see Fast ASCII I/O.
One of the problems when storing a table in an ASCII format is preserving table meta-data such as comments, keywords and column data types, units, and descriptions. Using the newly defined Enhanced Character Separated Values format it is now possible to write a table to an ASCII-format file and read it back with no loss of information. The ECSV format has been designed to be both human-readable and compatible with most simple CSV readers.
In the example below we show writing a table that has float32 and bool types. This illustrates the simple look of the format which has a few header lines (starting with #) in YAML format and then the data values in CSV format.
>>> t = Table()
>>> t['x'] = Column([1.0, 2.0], unit='m', dtype='float32')
>>> t['y'] = Column([False, True], dtype='bool')
>>> from astropy.extern.six.moves import StringIO
>>> fh = StringIO()
>>> t.write(fh, format='ascii.ecsv')
>>> table_string = fh.getvalue()
>>> print(table_string)
# %ECSV 0.9
# ---
# columns:
# - {name: x, unit: m, type: float32}
# - {name: y, type: bool}
x y
1.0 False
2.0 True
Without the header this table would get read back with different types (float64 and string respectively) and no unit values. Instead with the automatically-detected ECSV we get:
>>> Table.read(table_string, format='ascii')
<Table masked=False length=2>
x y
m
float32 bool
------- -----
1.0 False
2.0 True
Note that using the ECSV reader requires the PyYAML package to be installed.
New subclasses of Model are now a bit easier to define, requiring less boilerplate code in general. Now all that is necessary to define a new model class is an evaluate method that computes the model. Optionally one can define fittable parameters, a fit_deriv, and/or an inverse. The new, improved custom_model decorator reduces the boilerplate needed for many models even more. See Defining New Model Classes for more details.
Array broadcasting has also been improved, enabling a broader range of possibilities for the values of model parameters and inputs. Support has also been improved for Model Sets (previously referred to as parameter sets) which can be thought of like an array of models of the same class, each with different sets of parameters, which can be fitted simultaneously either to the same data, or to different data sets per model. See Instantiating and Evaluating Models for more details.
It is now possible to create compound models by combining existing models using the standard arithmetic operators such as + and *, as well as functional composition using the | operator. This provides a powerful and flexible new way to create more complex models without having to define any special classes or functions. For example:
>>> from astropy.modeling.models import Gaussian1D
>>> gaussian1 = Gaussian1D(1, 0, 0.2)
>>> gaussian2 = Gaussian1D(2.5, 0.5, 0.1)
>>> sum_of_gaussians = gaussian1 + gaussian2
The resulting model works like any other model, and also works with the fitting framework. See the introduction to compound models and full compound models documentation for more examples.
The underlying data container for the Astropy Table object has been changed in Astropy v1.0. Previously, tables were stored internally as a Numpy structured array object, with column access being a memory view of the corresponding Numpy array field. Starting with this release the fundamental data container is an ordered dictionary of individual column objects and each Column object is the sole owner of its data.
The biggest impact to users is that operations such as adding or removing table columns is now significantly faster because there is no structured array to rebuild each time.
For details please see Table implementation change in 1.0.
Version v1.0 of Astropy introduces a new concept of the “Mixin Column” in tables which allows integration of appropriate non-Column based class objects within a Table object. These mixin column objects are not converted in any way but are used natively.
The available built-in mixin column classes are Quantity, SkyCoord, and Time. User classes for array-like objects that support the Mixin protocol can also be used in tables as mixin columns.
Warning
While the Astropy developers are excited about this new capability and intend to improve it, the interface for using mixin columns is not stable at this point and it is not recommended for use in production code.
As an example we can create a table and add a time column:
>>> from astropy.table import Table
>>> from astropy.time import Time
>>> t = Table()
>>> t['index'] = [1, 2]
>>> t['time'] = Time(['2001-01-02T12:34:56', '2001-02-03T00:01:02'])
>>> print(t)
index time
----- -----------------------
1 2001-01-02T12:34:56.000
2 2001-02-03T00:01:02.000
The important point here is that the time column is a bona fide Time object:
>>> t['time']
<Time object: scale='utc' format='isot' value=['2001-01-02T12:34:56.000' '2001-02-03T00:01:02.000']>
>>> t['time'].mjd
array([ 51911.52425926, 51943.00071759])
For all the details, including a new QTable class, please see Mixin columns.
The WCS class can now be used as a Matplotlib projection to make plots of images with WCS coordinates overlaid, making use of the WCSAxes affiliated package behind the scenes. More information on using this functionality can be found in the WCSAxes documentation.
Astropy is now no longer supported on Python 3.1 and 3.2. Python 3.x users should use Python 3.3 or 3.4. In addition, support for Numpy 1.5 has been dropped, and users should make sure they are using Numpy 1.6 or later.
To see a detailed list of all changes in version v1.0, including changes in API, please see the Full Changelog.


S1 - Problem Statements
1. Community structures - a CrossRef for ALM?
What would be the optimal structure of community, to support coordination and collaboration. Do we need it? If so, when? And how would we tell?
Reasons to cooperate:
- Share costs
- Comparability
- Legitimacy
- Coordination with other (standards) groups
2. Advocacy and promotion:
There is a lack of inspiration and awareness outside this workshop.
- ALM advocacy is similar to OA advocacy effort
- Need new name to bring people together
3.Anti-gaming mechanisms, process interoperability:
- What is the difference between gaming and legitimate attention?
- How do we tell?
- How do we tell the people that care? Messaging is very important – technical explanations will not work.
Cluster II
4. Coverage, what to measure, what matters, to who?
What is currently scalably measurable and immeasurable and how do we make the immeasurable measurable?
- Create tools for publishing and citing
- Tools to crowdsource what can't be machine measured
- Focus on implicit data (footprints)
Cluster III
5. Semantic Analysis:
Current metrics lack context, such as sentiment, source, intensity etc. Context is multi-dimensional but users of metrics need low-metrics (eg. good/bad, for method).
- Need a good context vocabulary
- Need to map hurdles.
- Necessity for altmetrics as opposed to traditional citations.
6. Evidence, context, trust, and interpretation:
- How do you contextualise alms?
- What contexts matter to who?
- Do we get different information, or do they just all tell us the same thing, and is the current lack of context an opportunity to create our own narrative, or do we need to get with the program ASAP and on next to reality now?
Cluster IV
7. Personalization, use case targeting:
Altmetrics should enable scholars and institutions to present themselves to funders, peers and the public. Within this problem we considered it was relevant and important to:
- Track the identity of who generates the metric (i.e. who tweets)
- Reconsider the name of these activities to capture the idea of context-
- Consider other research outputs (beyond articles)
8. Data Interoperability:
In an ever more distributed and chaotic landscape our challenge is the reconciliation of that which is being counted and the counts themselves.
- How do we identify and reconcile copies of that which is being counted?
- There is a need to create and foster standards and best practice which allow understanding, comparison, and aggregation across source data providers and altmetric providers.
- We need to provide further context for the counts through normalization and identification of sources.
9. Too many measures, how to present? Single Number?
How do we:
- Have transparency of measures and indicators
- Have at least as many measures as there are interesting things to measure
- Have an articulation of what the numbers represent
- Create a measurability map based on difficulty and demand
- Develop new, sexy name
- Broaden the network around a charter
- Target publishers, researchers and funders as ambassadors
- Utilize communities of practice to better understand and evaluate altmetrics (e.g., eLife editorial board)
- Provide context for metric on a single item by identifying similar items, using automated classification
- Find a specific directed question that context helps with
- Crowdsource binning all science tweets to make an open data set: researcher, journalist, funder, etc.
- Create prioritized list of use cases in the following categories:
- Story telling informed by metrics
- Organizational intelligence for strategy
- Evaluation for a monetary decision
1. *Collect all the metrics that people are using now in ImpactStory, altmetric.com, PLOS, and let people vote on and add to them. Make sure that things we know about but that we haven't been able to calculate are also included:
- Ian will get the eLife editorial board to do this
- Lisa will try to do this eScholarship journal editorial boards and paper series admininistrators
- Juan will try to do this with Latin American publishers and editors
Scope-planning of tool is critical
2. Quickly build something for people to respond to in a simple manner.
- There are so many metrics, you need to make it manageable, i.e. grouping metrics so that they can be scanned; groups should be expandable to see details
- Data input
- Sources
- What items
- How important
- Other supporting data
- Way to point to provenance
- Demographic characteristics of responders
e.g. Here's a measure (Ian's) what is the diffusion of a core idea of a paper2.5 list of outputs/trackable artifacts/signals3. Make sure you engage with all the different stakeholders;make sure to reach out to the funding community to see what metrics they are gathering4. We recognize that in capturing information for the tool, we will find information about things that are currently immeasurable, so we will create a place for people to submit examples of those objects, in order to create a large collection that can be analyzed in order to move those types of objects into the "measurable" category.5. Idea of a registry of metrics which serves as a central clearinghouse for openly describing all metrics being gathered, and that is extensible so that we can capture the aspects of those metrics that are important to different communities. On top of this, we may be able to create profiles of metrics that are important to different communities. Those profiles should be versionable so that we can see whether different communities evolve over time in their attitudes and use of metrics. Where this registry should live remains an open question, so we may possibly build this tomorrow and not worry about it.
1. Collect use cases (a wiki - something more open than googledocs; a home). Seed with samples, offer a basic structure. Create awareness and communication.2. Determine criteria for prioritization or a voting mechanism; some sort of model for ranking/sorting the collection.3. Pass 'solved' use cases to the advocacy/ambassador group for their use in communication and outreach and apply ourselves further to expand these other use cases into well-documented, solid user stories.Aim for presenting at Force 11 in March.4. For hackathon >> challenge that by sunset tomorrow show us the iteration of use case 1, 2, 3
Alex - reverse engineer - for what they do tomorrow, ask what use case are you trying to solve?
Example -- Make it easy to find stuff:
- Add altmetrics for relevance in a discovery tool, how to utilize in a search tool
- which search too, where would it make sense to add that
- what is the simplest thing that could be done in one day to give a demonstration of, I want to find stuff based on altmetrics
5. Open challenge to the community solve a use case by 15th Feb - use cases that are not do-able in an afternoon: a grand challenge. Solve, create a YouTube video to show this.
1. Renamed: classifying science-related tweets (and therefore Twitter users):2. Assemble list of scientists
- ask Euan (altmetric.com) for his information, data, algorithm, etc.
- gather pre-existing lists
3. Create a simple web form (you or someone else can update your status)4. Decide on classification (see below)5. Make available as data dump, open API
Example classifications...
- Profession:
- Academic
- student (undergrad, grad)
- faculty (assist, assoc. prof)
- scientist (sr, jr)
- Journalist
- blogger
- sci writer
- …
- Other
- librarian
- publisher
- …
- Field (esp. for academics)
- Interests
1. Identify “ambassadors” in respective fields.2. Make and present them with, use cases specific to their respective fields3. Capitalize on appropriate and effective relationships [to best evangelize and advocate for altmetrics].


Strictly's Michelle Visage posts iconic throwback to mark RuPaul's birthday
The Drag Race judge paid tribute to her pal and colleague RuPaul with a throwback snap on his birthday
by Irishmirror.ieMichelle Visage treated fans to an iconic throwback snap as she sent well wishes to to RuPaul on his 59th birthday on Sunday.
The Drag Race judge, 51, took to Instagram to upload a image of RuPaul dressed in drag clad with a cowboy hat and suede waistcoat alongside a blonde wig and face of expertly applied make-up.
Next to RuPaul in the throwback image was Michelle who wore a similar western-style ensemble with a cow print shirt and hat.
Alongside the image, that had a strong 90s feel thanks to the pairs clothing, she penned: "HAPPY BIRTHDAY to my ride or die. This world is a better place because of your love and wisdom.
"Everyday I thank God for you. Thank you for all that you have done, for all that you continue to do and for what's to come. You are magical, Ru and I couldn't possibly love you more. X"
RuPaul and Michelle have pioneered the LGBTQIA+ community over the past 20 years and brought drag to the mainstream thanks to RuPaul’s Drag Race which began in the US and started in the UK this year.
Both Michelle and RuPaul are on the judging panel of the hit show.
It comes after Strictly Come Dancing fans are worried for Michelle as she has landed a place at the bottom of the leaderboard on Saturday's edition of the dancing show.
She performed to the popular 1990 Madonna hit Vogue with professional partner Giovanni Pernice, but her time left in the competition could now be at risk due to receiving the lowest score.
The dancing duo scored 32 points for their couples' choice routine but it put them below all the other couples in tonight's show.
One fan took to Twitter to share: "See if Emma makes it through to the #StrictlyComeDancing final over Michelle Visage I will be absolutely FUMING."
Another viewer penned: "How is Michelle behind Chris and Saffron? She did fantastic tonight".
A third begged: "Everybody vote now for Michelle & Giovanni please!! We can’t let them go now".
And a fourth explained: "Wait, Michelle & Giovanni came BOTTOM of the leaderboard??? WTAF?!"
Do you have a story to sell? Get in touch with us at<EMAIL_ADDRESS>or call us direct 0207 29 33033


{% load static %}
{% load user_group %}
Dashboard
{% block styles %}
{% endblock %}
Dashboard
{{users | length}} Users
| id |
Username |
Email |
Group |
Action |
{% for user in users %}
{{user.group}}
| {{user.id}} |
{{user.username}} |
{{user.email}} |
{{user.group}} |
Remove |
{% endfor %}
{{business | length}} Businesses
| id |
name |
Email |
Neighbourhood |
Action |
{% for bus in business %}
| {{bus.id}} |
{{bus.name}} |
{{bus.email}} |
{{bus.neighbourhood}} |
Delete |
{% endfor %}
{{hoods | length}} Hoods
| id |
Name |
Location |
No. of Occupants |
Fire Dept |
Police No |
Hosp Emergency No |
Action |
{% for hood in hoods %}
| {{hood.id}} |
{{hood.name}} |
{{hood.location}} |
{{hood.occ_count}} |
{{hood.fire_dept}} |
{{hood.police_cont}} |
{{hood.health_eme}} |
Delete |
{% endfor %}
{% block scripts %}
{% endblock %}


{% extends "base.html" %} {% block body %}
We did a series of video and written case studies for Rollbar, a software startup in San Francisco, and created a customer page on their website to highlight these stories. Here's a collection of example videos, including Instacart, Twilio and CircleCI, showing how Rollbar accelerates their continuous delivery adoption.


Because we consider you an important customer, our first priority is to offer you exceptional times and stays throughout our properties.

As part of our commitment to meeting your expectations, we have set up a customer privacy protection policy. This Policy formalizes our commitments to you and describes how Travelville uses your personal data.
The main rules applicable within the Travelville are founded on six principles.
-
CONSENT
"Personal data" means any information collected and logged in a format that allows you to be identified personally, either directly (e.g. name) or indirectly (e.g. telephone number) as a natural person.
Before providing us with this information, we recommend that you read this document describing our customer privacy protection policy.
This Personal Data Protection Policy forms part of the terms and conditions that govern our accommodation services. By accepting these terms and conditions, you expressly accept the provisions of this Policy.
-
Travelville's SIX PRINCIPLES FOR PROTECTING YOUR PERSONAL DATA
The six principles below are applicable within Travelville
- Legitimacy: We will collect and process your personal data only for the purposes described in this Policy.
- Relevance and accuracy: We will only collect personal data that is necessary for data processing. We will take all reasonable steps to ensure that the personal data we hold is accurate and up to date.
- Storage: We will hold your personal data for the period necessary for processing the same in compliance with the provisions of the law.
- Access, rectification, opposition: You may access, modify, correct or delete your personal data. You may also oppose the use of your personal data, particularly to avoid receiving sales and marketing information.
- Confidentiality and security: We will ensure reasonable technical and organizational measures are in place to protect your personal data against alteration or accidental or unlawful loss, or unauthorized use, disclosure or access.
- Sharing and international transfer:We may share your personal data within the Travelville Ltd or with third parties (such as commercial partners and/or service providers) for the purposes set out in this Policy. We will take appropriate measures to guarantee security when sharing or transferring such data.
-
SCOPE OF APPLICATION
This Policy applies:
- To all data processing implemented in our managed properties, i.e. those operating under an Travelville Ltd brand name
- To all Travelville Ltd reservation websites www.Travelville.com
-
WHAT PERSONAL DATA IS COLLECTED?
At various times, we will be obliged to ask you, as a Travelville Ltd customer, for information about you and/or members of your family, such as:
- Contact details (for example, last name, first name, telephone number, email)
- Personal information (for example, date of birth, nationality)
- Information relating to your children (for example, first name, date of birth, age)
- Your credit card number (for transaction and reservation purposes)
- Your arrival and departure dates
- Your preferences and interests (for example, smoking or non-smoking room, preferred floor, type of bedding, type of newspapers/magazines, sports, cultural interests)
- Your questions/comments, during or following a stay in one of our properties.
The information collected in relation to persons under 18 years of age is limited to their name, nationality and date of birth, which can only be supplied to us by an adult. We would be grateful if you could ensure that your children do not send us any personal data without your consent (particularly via the Internet). If such data is sent, you can contact the Data Privacy department to arrange for this information to be deleted.
We do not deliberately collect sensitive information, such as information concerning race, ethnicity, political opinions, religious and philosophical beliefs, union membership, or details of health or sexual orientation.
Moreover, depending on applicable local laws, other information could be considered sensitive, such as your credit card number, your leisure activities, personal activities and hobbies, and whether or not you are a smoker. We may be obliged to collect such information in order to meet your requirements or provide you with an appropriate service, such as a specific diet.
In this case, depending on the laws in force in certain countries, your prior consent may be required with regard to the collection of sensitive information.
-
WHEN IS YOUR PERSONAL DATA COLLECTED?
Personal data may be collected on a variety of occasions, including:
-
Accommodation activities:
- Booking a room
- Checking-in and paying
- Eating/drinking at the hotel bar or restaurant during a stay
- Requests, complaints and/or disputes.
-
Participation in marketing programs or events:
- Participation in customer surveys (for example, the Guest Satisfaction Survey)
- Online games or competitions
- Subscription to newsletters, in order to receive offers and promotions via email.
-
Transmission of information from third parties:
- Tour operators agencies
- GDS reservation systems
- others
-
Internet activities:
- Connection to Travelville websites (IP address, cookies)
- Online forms (online reservation, questionnaires, Travelville pages on social networks, network login devices such as Facebook login etc.).
-
FOR WHAT PURPOSES?
We collect your personal data for the purposes of:
- Meeting our obligations to our customers.
-
Managing the reservation of rooms and accommodation requests:
- Creation and storage of legal documents in compliance with accounting standards.
-
Managing your stay at our properties:
- Monitoring your use of services (telephone, bar etc.)
- Managing access to rooms
- Internal management of lists of customers having behaved inappropriately during their stay at the hotel (aggressive and anti-social behaviour, non-compliance with the accommodation contract, non-compliance with safety regulations, theft, damage and vandalism, or payment incidents).
-
Improving our service, especially:
- Processing your personal data in our customer marketing program in order to carry out marketing operations, promote brands and gain a better understanding of your requirements and wishes
- Adapting our products and services to better meet your requirements
- Customizing commercial offers and the promotional messages we send to you
- Informing you of special offers and any new services created by Travelville Ltd
-
Managing our relationship with customers before, during and after your stay:
- Providing details for the customer database
- Segmentation operations based on reservation history and customer travel preferences with a view to sending targeted communications
- Predicting and anticipating future behaviours
- Developing statistics and commercial scores, and carrying out reporting
- Knowing and managing the preferences of new or repeat customers
- Sending you newsletters, promotions and tourist, hotel or service offers, or contacting you by telephone
- Managing requests to unsubscribe from newsletters, promotions, tourist offers and satisfaction surveys
- Taking into account the right to object
- Use a trusted third party to cross-check, analyse and apply certain devices to your collected data at the time of booking or at the time of your stay, in order to determine your interests and your customer profile, and to allow us to send you personalized offers.
-
Improving Travelville Ltd services, especially:
- Carrying out surveys and analyses of questionnaires and customer comments
- Managing claims/complaints
-
Securing and enhancing your use of Travelville Ltd websites, especially:
- Improving navigation
- Implementing security and fraud prevention.
- Conforming to local legislation (for example, storing of accounting documents).
-
CONDITIONS OF THIRD-PARTY ACCESS TO YOUR PERSONAL DATA
To guarantee you the right of access and amendment we have to share your personal data with internal and external recipients subject to the following conditions:
-
Within Travelville, in order to offer you the best service, we can
share your personal data and give access to authorized personnel
from the Group, including:
- Hotel and building staff
- Reservation staff using Travelville reservation tools
- IT departments
- Commercial partners and marketing services
- Medical services if applicable
- Legal services if applicable
-
Generally, any appropriate person within Travelville entities
for certain specific categories of personal data.
-
With service providers and partners: your personal data may be
sent to a third party for the purposes of supplying you with
services and improving your stay, for example:
-
External service providers: IT sub-contractors, international
call centres, banks, credit card issuers, external lawyers,
dispatchers, printers, travel, entertainment companies.
-
Commercial partners: Travelville may, unless you specify
otherwise to the Data Privacy department, enhance your profile
by sharing certain personal information with its preferred
commercial partners. In this case, a trusted third party may
cross-check, analyse and apply certain devices to your data.
This data processing will allow Travelville and its privileged
contractual partners to determine your interests and your
customer profile, and will allow us to send you personalized
offers.
-
Social networking sites: If interact on Travelville social
media accounts, you explicitly authorize Travelville Ltd to
access and store the public data on your activity, as well as
the other data mentioned during use.
-
Local authorities: We may also be obliged to send your information
to local authorities if this is required by law or as part of an
inquiry and in accordance with local regulations.
-
PROTECTION OF YOUR PERSONAL DATA DURING INTERNATIONAL TRANSFERS
For the purposes set out in Clause 7 of this Policy, we may transfer your personal data to internal or external recipients who may be in countries offering different levels of personal data protection.
Consequently, in addition to implementation of this Policy, Travelville employs appropriate measures to ensure secure transfer of your personal data to a Travelville entity or to an external recipient located in a country offering a different level of privacy from that proposed in the country where the personal data is collected.
Other than those that are required to carry out your reservation, dataflows to countries having different levels of personal data protection are regulated by standard contractual manager-to-subcontractor clauses defined by the European Commission. Dataflows to the United States are made to entities that belong to Safe Harbor.
-
DATA SECURITY
Travelville takes appropriate technical and organizational measures, in accordance with applicable legal provisions, to protect your personal data against illicit or accidental destruction, accidental alteration or loss, and unauthorized access or disclosure.
To this end, we have taken technical measures (such as firewalls) and organizational measures (such as a user ID/password system, means of physical protection etc.).
When you submit credit card data when making a reservation, SSL (Secure Socket Layer) encryption technology is used to guarantee a secure transaction.
-
STORAGE OF DATA
We retain your personal data only for the period necessary for the purposes set out in this Policy or in accordance with the provisions of applicable law.
-
ACCESS/ MODIFICATION/ DELETION
You have the right to access your personal data collected by Travelville and to modify it subject to applicable legal provisions.
You may also exercise your right to object by writing to the address below.
In the event of difficulty exercising your rights, please contact the Data Privacy department for Travelville directly by sending an email to<EMAIL_ADDRESS>or by writing to the address below:
Travelville
Data Privacy Department
142, Velachery Main Rd, Indira Gandhi Nagar
Velachery, Chennai, Tamil Nadu 600042
For the purposes of confidentiality and personal data protection, we will need to identify you in order to respond to your request. You will be asked to include a copy of an official piece of identification, such as a driver's license or passport, along with the completed form you can download here.
If your personal data is inaccurate, incomplete or not up to date, please send the appropriate amendments to the Data Privacy department as indicated above.
All requests will receive a response as swiftly as possible and in accordance with applicable law.
You may also exercise your rights in respect of your personal data that is stored and processed by a hotel following a stay.
-
UPDATES
We may modify this Policy from time to time. Consequently, we recommend that you consult it regularly, particularly when making a reservation at one of our hotels.
-
QUESTIONS AND CONTACTS
For any questions concerning Travelville’s personal data protection policy, please contact us by telephone on +91 99999 99999


"The journey of a thousand miles begins with a single step." - Lao Tzu
Version control is a management system that helps keep track of the changes you make on your work as a developer. It allows developers to keep track of their work and communicate/collaborate with their teams on larger projects.
Git is a popular version control software that is used locally on the computer. Because it is local, a developer can access without the internet and push it to a centralized repository when ready. It keeps track of changes if the developer makes commits throughout their work, as long as the activity.
GitHub is a popular environment on the internet where developers are able to collaborate remotely on a project. For public repositories, developers can share, contribute to, give feedback, and learn from each others' code.


Edit preview :: REPLACETITLE
From Wikipedia, the free encyclopedia
Jump to:
navigation
,
search
Current revision
New edit
REPLACETHISPLEASE
COMPLETETEXT
Navigation
Main page
Contents
Featured content
Current events
Random article
Search
Interaction
About Wikipedia
Community portal
Recent changes
Contact Wikipedia
Donate to Wikipedia
Help
Toolbox
Upload file
Special pages


| Command | Description |
|---|---|
| git init | Creates a new local repository. |
| git clone [url] | Downloads a project and its entire version history from remote repository. |
| git remote add [bookmark-name] [url] | Assigns the original repository to a remote repository that can be used to fetch changes not present in the local repository without modifying your files. |
| git remote -v | Lists all configured remote repositories. |
| git status | Lists all new or modified files and their current state (i.e., tracked, untracked, etc.) |
| git diff | Shows file differences not yet staged. |
| git diff --staged | Shows file differences between staging and the last file version. |
| git add [filename] | Adds the file to the staging area in preparation for versioning. To add all files, use "." in place of the filename. |
| git reset [filename] | Unstages the file without losing its contents. |
| git rm [filename] | Deletes the fiel from the working directory and stages the deletion. |
| git commit -m "[descriptive message]" | Records staged files in version history. Use the -m flag to add a description of the changes. |
| git push | Uploads local commits to the remote repository. |
| git fetch [bookmark] | Downloads all history from the repository bookmark. |
| git branch | Lists all local branches in the current repository. |
| git branch [branch-name] | Creates a new branch. |
| git checkout [branch-name] | Switches to the specified branch and updates the working directory. |
| git merge [branch] | Combines the specified branch's history into the current branch. |
| git branch -d [branch-name] | Deletes the specified branch. |


CS-AP Training:
Related Content
CSAP Confluence
Training Screencasts
Download Screencast
Video Height:
300
500
700
1080
Note:
Content best viewed full screen,
Browser:
Latest versions of firefox, chrome, edge
Your browser does not support the video tag.


| Failed File | NoPatch Image | WithPatch Image | Differing pixels in white | Difference per pixel |
|---|---|---|---|---|
|
fileworker2_1.png Download SKP |
View Image
|
View Image
|
212% (211)
View Image
|
215% (perceptual diff) | 214
View Image
|